Mostrando entradas con la etiqueta Ejemplo. Mostrar todas las entradas
Mostrando entradas con la etiqueta Ejemplo. Mostrar todas las entradas

Operadores Condicionales

viernes, 28 de mayo de 2010 · 2 comentarios
Generalmente los operadores condicionales se usan en combinación con los operadores ralacionales para determinar si una condición es true o false. Los tres operadores condicionales se listan a continuación:

&&: el operador && (AND) se usa para determinar si las condiciones a ambos lados del operador resultan en true o false. Primero se evalúa el resultado de la condición a la izquierda del operando, si resulta en true, entonces el resultado de la condición a la derecha del operador es evaluado. Si ambas condiciones resultan en true, entonces esta operación también resulta en true. Si la condición a la izquierda del operador resulta en false, la condición a la derecha del operador no es evaluada, y la operación completa resulta en false. La siguiente expresión ilustra el uso de este operador:
(a < b) && (b < c)

||: El operador || (OR) se usa para determinar si al menos uno de las dos condiciones en alguno de los lados de este operador es true. Si la condición a la izquierda de este operador resulta en false, entonces la condición a la derecha es evaluada, si esta última condición resulta en true, entonces el resultado de la operación es true. Si la condición a la izquierda de este operador es true, entonces la condición a la derecha no es evaluada, y el resultado de la operación es true. La siguiente expresión ilustra el uso de este operador:
(a < b) || (b < c)

!: El operador ! (NOT) se usa para negar el resultado obtenido en una operación. Si el resultado de una operación es true, entonces el resultado de esta operación después de aplicar el operador ! Es false, y al contrario, el caso que la operación es false, la operación completa es true. La siguiente expresión ilustra el uso del operador NOT:
!(a < b)

He aquí un programa que demuestra el operador &&. El programa determina si el valor de d es un factor de n. Lo hace al realizar una operación de módulo. Si el sobrante de n/d es cero, entonces d es un factor. Sin embargo, como la operación de módulo incluye una división, la forma del operador condicional de && se usa para evitar un error de división entre cero.

// Demuestra los operadores Condicionales
class CCops{
public static void main(String args[]) {
int n, d, q;

n = 10;
d = 2;
if(d != 0 && (n % d) == 0)
System.out.println(d +” es un factor de “ + n);

d = 0; //ahora, fijamos d en cero

// Como d es cero, el segundo operando no se evalúa.
if(d != 0 (n % d) == 0)
System.out.println(d + “ es una factor de “ + n);
}
}


[ Seguir leyendo ]

Operadores Aritméticos

miércoles, 26 de mayo de 2010 · 0 comentarios
Java define los siguientes operadores aritméticos:

Operador: Significado
+ Suma
- Resta
* Multiplicación
/ División
% Módulo
++ Incremento
– Decremento

Los operadores +, -, * y / funcionan de la misma manera en Java que en cualquier otro lenguaje de cómputo (o el álgebra, si ese es el caso). Estos operadores pueden aplicarse a cualquier tipo numérico de datos y usarse en objetos de tipo char.

Aunque las acciones de los operadores aritméticos le resultan familiares a todos los lectores, existen unas cuantas situaciones especiales que requieren cierta explicación. En primer lugar, recuerde que cuando / se aplica a un entero, cualquier resto se truncará: por ejemplo, 10/3 será igual a 3 en una división entre enteros. Para obtener la fracción de la división debe usar el operador de módulo %. Este operador funciona de la misma forma en Java que en otros lenguajes: presenta el sobrante de una división entre enteros como, por ejemplo, 10%3 es 1. en Java, el % puede aplicarse a tipos enteros y punto flotante. Por lo tanto, 10.0 % 3.0 también es 1. El siguiente programa demuestra el operador de módulo.

//Demuestra el operador %.
class ModDemo {
public static void main(String args[]) {
int iresult, irest;
double dresult, drest;

iresult = 10 / 3;
irest = 10 % 3;

dresult = 10.0 / 3.0;
dresult = 10.0 % 3.0;

System.out.println(“Resultado y sobrante de 10 / 3: “ + iresult + “ “ + irest);

System.out.println(“Resultado y sobrante de 10.0 / 3.0: “ + dresult + “ “ + drest);

}
}

A continuación se muestra la salida del programa:
Resultado y sobrante de 10 / 3: 3 1
resultado y sobrante de 10.0 / 3.0: 3.33333333333333 1.0

Como verá, % presenta un sobrante 1 para ambas operaciones, de entero o de punto flotante.

Incremento y decremento
++ y – son los operadores de incremento y decremento en Java. Como verá, tienen algunas propiedades especiales que los hacen interesantes. Empecemos por revisar de manera precisa las acciones que los operadores de incremento y decremento llevan a cabo.

El operador de incremento agrega 1 a su operando y el de decremento resta 1. De ahí que,
x = x + 1;
es lo mismo que
x++;
y
x = x – 1;
es lo mismo que
--x;

Ambos operadores pueden preceder (prefijo) o seguir (sufijo) al operando. Por ejemplo,
x = x + 1;
puede escribirse como
++x; // forma de prefijo
o como
x++; // forma de sufijo

En el siguiente ejemplo, el que el incremento se aplique como prefijo o como sufijo no representa ninguna diferencia. Sin embargo, se presenta una diferencia importante cuando se usa un incremento o decremento como parte de una expresión más larga, cuando un operador de incremento o decremento precede a su operando, Java realiza la operación correspondiente antes de obtener el valor del operando con el fin de que el resto de la expresión use dicho valor. Si el operador sigue a su operando, Java obtendrá el valor del operando antes de incrementarlo o decrementarlo. Tome en cuenta lo siguiente:

x = 10;
y = ++x;

En este caso, y será 11. Sin embargo, si el código se escribe como:

x = 10;
y = x++;

entonces y será 10. en ambos casos, x aún tendrá un valor de 11; la diferencia es el momento en que ocurre. Tener la capacidad de controlar el momento en que la operación de incremento o decremento tiene lugar implica ventajas importantes.
[ Seguir leyendo ]

El Alcance y la Vida de las Variables

martes, 25 de mayo de 2010 · 0 comentarios
Hasta ahora, todas la variables que hemos usado se declararon al principio del método main(). Sin embargo, Java permite que las variables se declaren dentro de cualquier bloque. El inicio de un bloque se marca con un carácter '{', y el fin del bloque, con el correspondiente carácter '}'. Un bloque puede contener otro bloque (o cualquier número de bloques) dentro de él, estos se denominan bloques anidados. Un bloque define el alcance; por lo tanto, cada vez que inicia un nuevo bloque, está creando un nuevo alcance. Un alcance determina cuáles objetos son visibles a otras partes de su programa. Así mismo, determina la vida de dichos objetos.

Casi todos los demás lenguajes de cómputo definen dos categorías generales de alcance: global y local. Aunque están soportadas por Java, no constituyen las mejores formas de categorizar los alcances de Java. Los alcances más importantes son los definidos por una clase y los definidos por un método.

El alcance definido por un método inicia con su llave de apertura. Sin embargo, si dicho método contiene parámetros, éstos se incluyen también dentro de su alcance.

Como regla general, las variables que están declaradas dentro de un alcance no son visibles (es decir, accesibles) a un código que esté definido fuera de este alcance. Por lo tanto, cuando declara una variable dentro del un alcance, localiza esa variable y la protege de acceso no autorizado, de modificación o de ambas posibilidades. Por supuesto, las reglas de alcance proporcionan la base del encapsulamiento.

Así mismo, los alcances pueden están anidados. Por ejemplo, cada vez crea un bloque de código, crea un nuevo alcance anidado. Cuando esto ocurre, el alcance exterior encierra al interior. Esto significa que los objetos declarados en el alcance exterior se volverán visibles al código dentro del alcance interno. Sin embargo, la situación contraria no aplica: los objetos declarados dentro del alcance interior no serán visibles fuera de él.

Para comprender el efecto del los alcances anidados, considere el siguiente programa:

// Demuestra el alcance del bloque.
class AlcanceDemo {
public static void main(String args[]) {
int x; // conocido a todo el código en main
x = 10;
if (x == 10) { //inicia nuevo alcance
int c = 20; //conocido sólo a este bloque
// x y c son conocidos aquí.
System.out.println(“ x y c : “+ x +” “+ c);
x= c * 2;
}
c = 100 // Error. A c no se le conoce aquí, está fuera de su alcance.
// x es aún conocido aquí.
System.out.pritnln(“x es “ + x);
}
}
Como lo indica el comentario, la variable x se declara al principio del alcance de main() y es accesible a todo el código posterior dentro de main(). Dentro del bloque if, está declarada c. Debido a que un bloque define un alcance, c sólo es visible dentro del código de su bloque. Por tal motivo, fuera de su bloque, la línea c = 100; hará que ocurra un error en tiempo de ejecución porque c no es visible fuera de su bloque. Dentro del bloque if, x puede usarse porque el código dentro del bloque (es decir, un alcance anidado) tiene acceso a variables declaradas por un alcance incluido.

Dentro de un bloque, las variables pueden declararse en cualquier punto; sin embargo, sólo son válidas después de ser declaradas. De manera que, si define una variable al inicio de un método, ésta estará disponible para todo el código dentro del método . Por el contrario, si declara un variable al final de un bloque, ésta carecerá de uso porque ningún código tendrá acceso a ella.

A este respecto, hay que recordar otro elemento: las variables se crean cuando se introduce su alcance y se destruye cuando se abandona su alcance. Esto significa que una variable no contendrá su valor una vez que se haya salido de sus alcance. Por lo tanto, las variables declaradas dentro de un bloque perderán su valor cuando se abandone el bloque. Así, la vida de una variable está confinada a su alcance.
[ Seguir leyendo ]

Desarrollo de la clase Automotor

viernes, 16 de octubre de 2009 · 0 comentarios
En el tema anterior se desarrolló una clase llamada Automotor que encapsulaba información acerca de automotores. Esta clase almacenaba tres elementos de información acerca de un vehículo: el número de pasajeros que puede tener, la capacidad de del tanque de combustible y su consumo promedio de gasolina.

He aquí el código completo que usa la clase Automotor:

/* Programa que usa la clase Automotor.
Llame a este archivo AutomotorDemo.java
*/
class AutomotorDemo {
public static void main(String args[]) {
Automotor minivan = new Automotor();
int rango;

//asigna valores a campos de minivan
minivan.pasajeros = 7;
minivan.tanquegas = 60;
minivan.kpl = 6;

//calcula el rango suponiendo un tanque lleno de combustible
rango = minivan.tanquegas * minivan.kpl;
system.out.println(“Una minivan puede transportar “ + minivan.pasajeros + “ pasajeros con un rango de “ + rango);

}
}


Debe llamar con el nombre de AutomotorDemo.java al archivo que contiene este programa porque el método main() está en la clase AutomotorDemo, no en la clase Automotor. Cuando compile este programa, encontrará que se han creado dos archivos .class, uno para Automotor y otro para AutomotorDemo. El compilador de Java coloca automáticamente cada clase en su propio archivo .class. No es necesario que ambas clases estén en el mismo archivo fuente. Puede poner cada clase en sus propios archivos, llamados Automotor.java y AutomotorDemo.java, respectivamente.

Para ejecutar este programa, debe ejecutar AutomotorDemo.class. Se despliega la siguiente salida:

Una minivan puede transportar 7 pasajeros con un rango de 360

Antes de seguir adelante, revisemos un principio fundamental: cada objeto tiene sus propias copias de las variables de instancia definidas para su clase. Por lo tanto, el contenido de las variables en un objeto puede diferir del contenido de las variables en otro. No existe una conexión entre los dos objetos excepto por el hecho de que ambos objetos son del mismo tipo. Por ejemplo, si tiene dos objetos Automotor, cada uno tiene sus propia copia de pasajeros, tanquegas y kpl, y el contenido de éstos puede diferir entre los dos objetos.
[ Seguir leyendo ]

Un Primer Programa de Ejemplo

martes, 13 de octubre de 2009 · 0 comentarios

Empecemos por escribir el programa corto de ejemplo que se muestra a continuación:

/*
Este es un programa simple de Java.
Llame a este archivo Ejemplo.java
*/
class Ejemplo{
// Un programa de Java empieza con una llamada a main().
public static void main(String args[]) {
System.out.println(“Java esta en la web.”);
}
}

En el caso de la mayor parte de los lenguajes de computación, el nombre del archivo que contiene el código fuente de un programa es arbitrario. Sin embargo, éste no es el caso de Java. Lo primero que debe aprender acerca de Java es que el nombre que asigne a un archivo fuente es muy importante. Para este ejemplo, el nombre del archivo fuente debe ser Ejemplo.java. Veamos por qué.

En Java a un archivo fuente se le llama oficialmente unidad de compilación. Éste es un archivo de texto que contiene una o más definiciones de clase. El compilador de Java requiere que un archivo fuente use la extensión de nombre de archivo .java.

Como verá al revisar el programa, el nombre de la clase definida por el programa también es Ejemplo. No se trata de una coincidencia. En Java, todo el código debe residir dentro de una clase. Por convención, el nombre de esa clase debe coincidir con el del archivo que contiene el programa. También debe asegurarse de que las mayúsculas y minúsculas del nombre del archivo coincidan con el nombre de la clase. La razón de ello es que Java es sensible a mayúsculas y minúsculas. En este punto, es posible que la convención de que los nombres de archivo correspondan con los nombres de clase parezca arbitraria. Sin embargo, esta convención hace más fácil el mantenimiento y la organización de sus programas.

El primer programa de ejemplo, línea por línea
Aunque Ejemplo.java es muy corto, incluye varias características clave que le son comunes a todos los programas de Java. Examinemos de cerca cada parte del programa.

/*
Este es un programa simple de Java.
Llame a este archivo Ejemplo.java
*/

Se trata de un comentario. Como casi todos los demás lenguajes de programación, Java le permite ingresar un comentario en el archivo fuente de un programa. El contenido de un comentario es ignorado por el compilador. En cambio, un comentario describe o explica la operación del programa a cualquier persona que esté leyendo su código fuente. En este caso, el comentario describe el programa y le recuerda que el archivo fuente debe llamarse Ejemplo.java. Por supuesto, en aplicaciones reales, los comentarios suelen explicar la manera en la que funciona alguna parte del programa, o bien, lo que una característica específica lleva a cabo.

La siguiente línea del código del programa se muestra a continuación:
class Ejemplo{

Esta línea usa la palabra clave class para declarar que se está definiendo una nueva clase. Ejemplo es el nombre de la clase. La definición de clase empieza con una llave de apertura ({) y termina con una cierre (}). Los elementos entre las dos llaves son miembros de la clase. Por el momento, no se preocupe demasiado por los detalles de una clase, pero tome en cuenta que en Java toda la actividad del programa ocurre dentro de una.

La siguiente línea del programa es el comentario de una sola línea, el cual se muestra aquí:
// Un programa de Java empieza con una llamada a main().

Éste es el segundo tipo de comentario soportado por Java. Un comentario de una sola línea comienza con // y termina al final de la línea. Como regla general, los programadores usan comentarios de varias líneas para comentarios más largos y de una sola línea para descripciones breves, línea por línea.

A continuación se muestra la siguiente línea del código:
public static void main(String args[]) {

Esta línea empieza el método main(). En Java, a una subrutina se la llama método. Como se sugiere en el comentario anterior, ésta es la línea en la que el programa empezará a ejecutarse. Todas las aplicaciones de Java empiezan la ejecución mediante una llamada a main().

La palabra clave public es un especificador de acceso. Un especificador de acceso determina la manera en la que otras partes de un programa pueden acceder a los miembros de la clase. Cuando un miembro de una clase está precedido por public, entonces es posible acceder a dicho miembro mediante un código que esté fuera de la clase en la que se encuentre declarado. (Lo opuesto de public es private, lo cual evita que un miembro sea utilizado por un código definido fuera de su clase.) En este caso, main() debe declararse como public porque debe ser llamado por el código fuera de su clase cuando el programa se inicie. La palabra clave static permite que main() sea llamado por el intérprete de Java antes de que se haga cualquier objeto. La palabra clave void simplemente le indica al compilador que main() no regresa un valor. Como se verá, los métodos también pueden regresar valores.

Como ya se estableció, main() es el método al cual se llama al iniciar una aplicación en Java. Cualquier información que necesite pasar a un método es recibida por variables especificadas dentro del conjunto de paréntesis que viene después del nombre del método. A estas variables se les denominan parámetros. Si no se requieren parámetros para un método determinado, necesitará incluir de cualquier modo los paréntesis vacíos. En main() sólo hay un parámetro, String args[], el cual declara un parámetro denominado args. Se trata de una matriz de objetos del tipo String. (Las matrices son colecciones de objetos similares.) Los objetos de tipo String almacenan secuencias de caracteres. En este caso, args recibe cualquier argumento de línea de comandos que esté presente al momento de ejecutar el programa. Este programa no usa esta información.

El último carácter de esta línea es la {. Esto señala el inicio del cuerpo de main(). Todo el código incluido en un método ocurrirá entre la llave de apertura del método y su llave de cierre.

A continuación se muestra la siguiente línea de código. Note que esto ocurre dentro de main()
System.out.println(“Java esta en la web.”);

Esta línea da salida a la cadena “Java esta en la web.” seguida por una nueva línea en la pantalla. En realidad la salida se logra mediante el método integrado println(). En este caso println() despliega la cadena que se le pasa. Como verá, println() puede usarse también para desplegar otros tipos de información. La línea empieza con System.out, System que es una clase predefinida que proporciona acceso al sistema y out es el flujo de salida que está conectado a la consola. Por consiguiente, System.out es un objeto que encapsula la salida de la consola.

Tome en cuenta que la instrucción println() termina con un punto y coma. En Java, todas las instrucciones terminan con un punto y coma. La razón de que otras líneas del programa no terminen con punto y coma es que no son instrucciones en un sentido técnico.

La primera } del programa termina main() y la última termina la definición de clase de Ejemplo.

Un último comentario: Java es sensible a las mayúsculas y minúsculas. Si lo olvida, se puede meter en problemas serios. Por ejemplo, si escribe por accidente Main en lugar de main, o PrintLn en lugar de println, el programa anterior será incorrecto. Más aún, si bien el compilador de Java compilará clases que no contengan un método main(), no tendrá manera de ejecutarlas. De este modo, si escribe main de manera incorrecta, el compilador compilará de cualquier modo su programa. Sin embargo, el intérprete de Java reportará un error porque no encontrará el método main().
[ Seguir leyendo ]
Entradas Antiguas data:homeMsg

CodigoByte

Codigo QR

Etiquetas

Blogumulus by Roy Tanck and Amanda Fazani

Twitter

Seguir codigobyte en Twitter

Twitter Actualizar

    sigueme en Twitter

    Participa

    Java Twitter

    ¿Cúal es la extensión usada para guardar los archivos fuente Java?

    Mangoos

    Mangoos
    http://mangoosbuscador.wordpress.com/

    Anunciantes

    Se escribe con...

    Se escribe con...