Instrucciones de Control
Su funcionamiento es idéntico al que
se les da en los otros lenguajes de programación.
Ejemplo:
if ( Edad > 200 )
{
System.out.println("La edad digitada
sobrepasa el límite");
......
}
else
if ( Edad < 0 )
{
System.out.println("La edad digitada es
menor que cero");
.......
}
else
{
System.out.println("Edad registrada");
......
}
Su funcionamiento es igual al de su equivalente
en C++.
Ejemplo:
switch ( Estado )
{
case 0:
System.out.println("Estado OK ");
......
break;
case 1:
{
System.out.println("Estado EN ACTUALIZACIÓN");
.....
}
break;
case 2:
System.out.println("Estado ERROR DE CALCULO");
return;
......
default :
System.out.println("Estado NO CONOCIDO");
.....
}
Bucles
La sintaxis y definición de bucles For
en Java es igual a la de C++:
for ( Valores Iniciales ; Test para que el
bucle continúe; Incrementos )
{
Sentencias
}
Ejemplo:
int i,x;
for ( i = 1 ; i <= 10 ; i ++ )
{
x=i * 30;
}
En este ejemplo se hace un bucle usando la
variable entera i como contador, cuyo valor inicial es 1 y la
condición para que el bucle continúe es que i sea
menor o igual a 10, el incremento de i como se puede ver es de
una unidad.
También es posible usar varios indicadores
o variables dentro de FOR y la definición de variables
dentro del bucle:
int i , j , x ;
for ( i = 1 , j = 10 ; ( i <= 20 ) &&
( j < 15 ) ; i += 5 , j ++ )
{
int z; // Variable local al bucle
z = i * j ;
x = ( z + 4 ) / 3 ;
}
Otra posibilidad en el bucle for es la de detener
su ejecución a partir de múltiples condiciones:
int x,i ;
for ( i = 1; i <= 100; i++ )
{
x= i * 3;
if ( x > 200 ) break;
}
La palabra reservada break indica que
se detenga el bucle, en este caso si el valor de x es mayor que
200.
Como la mayoría de palabras reservadas
de Java, la sintaxis de ésta es igual a la de C++.
While ( Condición )
{
..................
Instrucciones
................
}
Un bucle WHILE se realiza siempre y cuando
se cumpla una condición dada.
Ejemplo:
int i =1;
while ( i < 23 )
{
.................
i ++ ;
}
El bucle anterior se repite 22 veces ya que
la condición es que i sea menor que 23 y el incremento
de i es unitario.
Otra forma de detener un bucle WHILE se hace
usando la palabra reservada break.
Ejemplo:
int i =1, x =4;
while ( i < 23 )
{
.................
x = x * i + 3 ;
if ( x > 40 ) break;
i ++ ;
}
En este ejemplo aparte de la condición
de i < 23 , el bucle se detendrá con la condición
x > 40.
Punteros y Arreglos JAVA
La noción de puntero es innata en Java,
todos los objetos son punteros, como ya se sabe no es suficiente
con definirlos sino hay que construirlos dinámicamente
con la sentencia new y si es necesario pasar algunos parámetros
al constructor.
No es necesario destruir ( borrar ) un objeto
creado dinámicamente como en otros lenguajes, basta con
igualar el puntero a dicho objeto a null (palabra reservada
que significa objeto nulo) para que el intérprete del Java
se encargue de eliminar el espacio de memoria que usa el objeto
( siempre y cuando no existan otros punteros apuntando a esa instancia
), o simplemente asignar un objeto a otra instancia, con lo cual
se dejaría un bloque de memoria que no tiene referencias.
Al pasar un objeto como parámetro este
se pasa por referencia, esto quiere decir que si dentro del método
se cambia el valor del parámetro, el valor del objeto que
se usó para pasar ese parámetro también cambiará.
Una diferencia significativa entre un puntero
en Java con un puntero en otro lenguaje convencional es que no
se puede cambiar de forma directa la dirección de memoria
(instancia) a la que apunta un puntero como sucede en C:
Ejemplo:
int *puntero;
......
puntero++; // puntero apunta al siguiente entero
en la RAM.
La única forma de hacer que un puntero
haga referencia a otra posición de memoria (instancia)
es asignarlo a un objeto creado con la sentencia new o usando
el operador = y asignar otra área de memoria a dicho objeto.
Ejemplo:
String cadena1=new String("Hola Mundo");
String cadena2=new String("Esta es una
cadena con siete palabras");
........
cadena1=cadena2;
En este caso el objeto cadena1 que tiene una
referencia a una instancia de la clase String que contiene la
cadena "Hola Mundo" es asignado a una instancia de String
que contiene la cadena "Esta es una cadena con siete palabras",
quedando liberada la memoria ocupada por la primera instancia
de String que estaba asignada al objeto cadena1, después
de la asignación los dos objetos cadena1 y cadena2 apuntan
(hacen referencia) a la misma instancia de la clase String que
contiene la cadena "Esta es una cadena con siete palabras".
Arreglos Unidimensionales
Un arreglo puede contener elementos que son
tipos de datos u objetos, los cuales deben ser creados e inicializados
para poder ser usados posteriormente en el arreglo.
Se pueden crear arreglos de dos maneras diferentes
de crear arreglos en Java. La primera usa new y especifica que
tan grande debe ser el arreglo. Los elementos de un array creados
de esta manera son creados con el valor por defecto del tipo de
array, por ejemplo los elementos de un array de int son inicializados
a 0, los de un array de objetos son inicializados a null.
El índice en un arreglo empieza siempre
desde CERO.
Ejemplo:
// Creación de arreglos de tipos de
datos
int edades [ ] = new int[100]; // Arreglo de
enteros de100 elementos
// Creación de arreglos de objetos
Integer enteros[ ] = new Integer[ 2 ]; //
Arreglo de 2 objetos
Integer dato1,dato2;
// Inicialización de dos objetos
dato1=new Integer(1234);
dato2=new Integer(2344);
// Asignación de datos a los elementos
del arreglo de variables
edades[0]=100;
edades[1]=13;
edades[2]=19;
// Asignación de datos a los elementos
de los arreglos de objetos
enteros[0]=dato1; // Asignación del
primero objeto del arreglo.
enteros[1]=dato2; // Asignación del
segundo objeto del arreglo.
Como se aprecia en el ejemplo, primero es necesario
crear un arreglo e indicar cuantos elementos tiene el arreglo,
lo cual reserva el espacio necesario para almacenar los punteros
necesarios para guardar las referencias a los datos almacenados
por el arreglo, adicionalmente es necesario crear cada uno de
los objetos que se van a guardar en el arreglo para luego hacer
la referencia de ellos.
Otro punto que hay que destacar es que el rango
de los elementos de arreglo va desde cero "0" hasta
el número de elementos menos 1.
La otra manera de crear un arreglo de tipo
de datos es inicializándolo en su definición. Esta
sintaxis crea un array dinámicamente e inicializa sus elementos
a los valores especificados.
Ejemplo:
int edades [ ] = { 10, 32, 53, 67 };
Arreglos Multidimensionales
Son arreglos de arreglos, su definición
es similar a la de los unidimensionales con la diferencia que
hay que inicializarlos primero para indicar cuantos arreglos contendrán
(filas) y a su vez inicializar estos (columnas) para indicar cuantos
elementos contendrán, para finalmente crear los elementos
que se guardarán en el arreglo.
Ejemplo:
int bidimensional [ ] [ ]=new int [25] [30];
//Arreglo de 25 filas y 30 columnas
int dosniveles [ ] [ ] = new int [25] [ ];
// Arreglo de 25 filas
dosniveles[0]=new int[5]; /* Inicialización
de la primera fila que contendrá 5 columnas */
dosniveles[1]=new int[6]; /* Inicialización
de la segunda fila que contendrá 6 columnas */
dosniveles[2]=new int[85]; /* Inicialización
de la tercera fila que contendrá 85 columnas */
dosniveles[3]=new int[5]; /* Inicialización
de la cuarta fila que contendrá 5 columnas */
......
dosniveles[24]=new int[15];
Como se puede apreciar en el ejemplo anterior
los arreglos bidimensionales no están restringidos a tener
todas las filas con el mismo número de columnas, capacidad
que ofrece más flexibilidad en la programación y
minimiza el uso de RAM.
Hay que recordar que la definición y
creación de un arreglo no crea los objetos que van a estar
contenidos en el arreglo.
Como en la definición de arreglos unidimensionales,
también es posible inicializar un arreglo en el momento
de su definición:
Ejemplo:
int bidimensional [ ] [ ] = { { 11, 12, 13
} , { 21, 22, 23 }, { 31, 32, 33 } };
Recursividad en JAVA
La recursividad es la propiedad en la que una
función se llama así misma, es muy útil para
la solución de algunos problemas, porque se presenta en
forma clara y fácil de entender. Java permite la recursividad
en los métodos de una clase.
Ejemplo:
long Factorial ( long n )
{
if ( n < 0 ) return 0;
if ( n == 0 ) return 1;
return n*Factorial(n-1);
}
El método anterior calcula el factorial
de un número entero, como se ve siempre debe de existir
una condición dentro de una función que se llama
así misma para que se detenga el ciclo.
Si no se hubiera utilizado recursividad el
método se hubiera escrito de la siguiente manera:
long Factorial( long n )
{
long rpta=1;
if ( n < 0 ) return 0;
if ( n == 0 ) return 1;
for(i=1;i<=n;i++) rpta=rpta*i;
return rpta;
}
|