| |
| índice |
Existen cuatro tipos de datos numéricos enteros: byte, short , int y long; que permiten almacenar enteros de longitud máxima 8bits, 16 bits, 32 bits y 64 bits respectivamente. La longitud de los tipos de datos en Java es fija para asegurar la portabilidad en distintas implementaciones del lenguaje.
byte -----> 8 bits
short -----> 16 bits
int -----> 32 bits
long -----> 64 bits
La asignación de un tipo a una variable se realiza escribiendo el nombre de la variable después del tipo, en el siguiente ejemplo:
int x, y; //se declaran dos variables enteras de 32 bits.
long x. y; // se declaran dos variables enteras de 64 bits.
En la declaración también se puede asignar un valor a la variable mediante el símbolo igual. Ejemplo:
byte var1, var2 = 7;
/* se declaran dos variables de 8 bits y se asigna el valor 7 a
la segunda de ellas, dejando la primera sin inicializar. */
Los valores enteros se pueden denotar como se muestra en el ejemplo anterior o escribiéndolos en octal o hexadecimal. Para especificar un entero en octal se precede el entero con un cero y si desea en hexadecimal se precede con 0x.
int a = 017, b = 0xF, c = 0xBB;
así se declaran tres variables enteras de 32 bits. En a se almacena el 17 en octal (15 en decimal), en b se almacena Fen hexadecimal (15 en decimal) y en c se almacena BB en hexadecimal (187 en decimal).
Hay dos tipos de número real en Java.
Ejemplo:
float x = 23.8, y, z; // se declaran tres reales y se asigna el valor 23.8 a la variable x.
Los números en coma flotante se denotan como: parte-entera.parte-fraccionaria o también utilizando la notación científica donde el carácter e o E indica que el número se multipilica por 10 elevado al número que sigue a la e o E.
Ejemplo:
float total = 1.56e2, parcial = 2.34E4;
total y parcial son dos variables en coma flotante; total tiene el valor 156 y parcial 23400.
Este tipo de dato utiliza un carácter Unicode de 16 bits y se establece mediante un valor entre comillas simples. Ejemplo:
char letra, caracter = �e� ;
Este tipo de variable puede tomar el valor verdadero o falso.
Ejemplo:
boolean flag = true; la variable flag toma el valor verdadero.
Todos los tipos de datos elementales en Java están asociados
a operadores que se utilizan para construir expresiones.
Pueden utilizarse con reales y con los diversos tipos de enteros. En la tabla siguiente se muestran los diferentes operadores que existen.
| operador | símbolo | expresión | significado |
|---|---|---|---|
| multiplicación | * | a * b | a por b |
| división | / | a / b | a dividido entre b |
| suma | + | a + b | b sumado a a |
| resta | - | a - b | b restado a a |
| resto de la división entera entre b | % | a % b | resto de dividir a entre b |
El operador % sólamente se puede aplicar a datos enteros.
Estos operadores realizan operaciones aritméticas tales como la suma y después asignan el resultado a una de las variables usadas en la expresión que contiene el operador.
Ejemplos:
int a = 3, b = 9; a += b;
El resultado es la suma de a y b ( 12 ), y se guarda el
valor en a. Equivale: a = a + b
int a = 4, b = 11; b %= inta;
El resultado es el resto de la división entera de b entre a ( 3 ) y se guarda en b.
En la tabla siguiente se muestran los diferentes operadores que existen.
| símbolo | operador | expresión | significado |
|---|---|---|---|
| = | asignación | a = b | pone el valor de b en a |
| += | suma y asigna | a += b | pone el valor de a+b en a |
| -= | resta y asigna | a -= b | pone el valor de a-b en a |
| *= | multiplica y asigna | a *= b | pone el valor de a*b en a |
| /= | divide y asigna | a /= b | pone el valor de a/b en a |
| %= | resto de la división entera y asigna | a % b | pone el valor de a%b en b |
Otros dos operadores son el de incremento (++) y el de decremento (--). Se emplean en dos formas: antes o después de la variable a tratar.
Ejemplo:
cont ++;
incrementa el valor de la variable cont y lo reemplaza en cont. Devuelve el valor antiguo de cont. Por ejemplo si inicicialmente cont tenía el valor 8, el resultado de esta expresión sería modificar el valor a 9 y retornar el valor 8.
++ cont;
suponiendo que el valor de cont es 12, esta expresión hace que se incremente el valor en 1, el 13 se almacena en cont y se retorna dicho valor.
Los resultados que se obtienen con estos operadores pueden utilizarse en otros contextos donde esos valores puedan emplearse, como en asignaciones.
Ejemplo:
int a = 0 , b;
b = a ++; la variable b toma el valor 0 y la variable a se incrementa en 1.
| símbolo | operador | expresión | significado |
|---|---|---|---|
| pos-incremento | ++ | x++ | incrementa x en 1, retorna el valor anterior |
| pre-incremento | ++ | ++x | incrementa x en 1, retorna el valor nuevo |
| pos-decremento | - - | x- - | decrementa x en 1, retorna el valor anterior |
| pre-decremento | - - | - -x | decrementa x en 1, retorna el valor nuevo |
Estos operadores se pueden aplicar a números enteros y a números en punto flotante. Las operaciones que realizan devuelven un valor booleano.
| símbolo | operador | expresión | significado |
|---|---|---|---|
| = = | igual a | x = = y | verdadero si x es igual a y, falso en otro caso |
| > | mayor que | x > y | verdadero si x es mayor que y, falso en otro caso |
| < | menor que | x < | y verdadero si x es menor que y, falso en otro caso |
| >= | mayor o igual que | x > | y verdadero si x es mayor o igual que y, falso en otro caso |
| <= | menor o igual que x | < | y verdadero si x es menor o igual que y, falso en otro caso |
Ejemplo:
int a = 30, b = 26;
boolean var1, var2;
var1= (a < 30); // var1 toma el valor falso porque el valor de a es 30.
var2 =(b >=26); // var2 toma el valor verdadero porque el valor de b es igual a 26.
| símbolo | operador | expresión | significado |
|---|---|---|---|
| && | and lógico | a && b | devuelve verdadero si a y b son verdaderos, devuelve falso en cualquier otro caso. |
| | | | or lógico | a | | b | devuelve falso si a y b son falsos, verdadero en cualquier otro caso |
| ! | negación lógica | !a | devuelve falso si a es verdadero, devuelve verdadero si a es falso |
Este tipo de operadores se pueden utilizar en expresiones que incluyen operadores relacionales y variables de tipo numérico.
Ejemplo:
int a. b, c = 44;
boolean var1, var2;
a = 22;
b = 33;
var1 = (a < 10) && (b == 33); // var1 toma el valor falso.
var2 = !var1 && !(b < 22 && a< 23); // var2 toma el valor verdadero.
Java trata algunos tipos de datos como objetos y se utiliza un mecanismo
de paso de mensajes para tratarlos. Los dos ejemplos más importantes
de este tipo de datos son los vectores y las cadenas de caracteres.
Un ejemplo de declaración de un vector:
int buffer[ ] = new int [10];
Así se declara que la variabe buffer es un vector de enteros y tendrá espacio para 10 enteros.
Ejemplo:
char alfabeto[ ] = new char [28];
Declara un vector de caracteres llamado alfabeto que contendrá 28 caracteres.
Algunos tipos de datos que en otros lenguajes se tratan como tipos de datos básicos, en Java se consideran como objetos y se le pueden pasar mensajes. Por ejemplo para obtener el número de elementos de un vector se envía el mensaje length al vector.
Por ejemplo la expresión:
vector.length( );
está compuesta por un objeto receptor (vector) y un mensaje (length( )). El resultado de este mensaje es un entero que representa el número de elementos del vector.
Las cadenas de caracteres se pueden definir de la misma manera que los tipos de datos básicos, es decir, como se define un entero o un carácter.
Ejemplo:
String nombre, direcci�n;
Se están declarando dos variables de tipo String.
Los String se escriben encerrados entre comillas.
Ejemplo:
String direcci�n, nombre = "David";
Al igual que los vectores, las cadenas de caracteres son consideradas como objetos en Java y tienen métodos asociados.
Ejemplo:
nombre.length( );
Determina la longitud del String nombre.
A todos los tipos de datos básicos en Java se les da valores mediante sentencias de asignación. Por ejemplo en este código
int a, b, c;
a = 10;
b = 37;
c = 91;
se declaran tres variables a, b y c y se utiliza la asignación para darle los valores.
Normalmente en Java, si se desea asignar un valor a un objeto hay que mandarle un mensaje. Sin embargo, se hace una excepción con los vectores y las cadenas de caracteres. Ejemplo:
String identificador;
identificador = "frodo";
La inicialización se realizó como si se tratara de un tipo de datos básico.
De igual forma se procede con los vectores. Ejemplo:
int posiciones[ ]= new int[5];
posiciones = (1, 2, 3, 4, 5);
En Java:
Las cadenas de caracteres en Java se consideran como objetos. Por tanto es conveniente empezar por ver algunos conceptos principales acerca de objetos para entender cómo se manejan los cadenas de caracteres.
Un mensaje es algo que se envía a un objeto. Un mensaje está compuesto por un nombre y varios argumentos, o ningún argumento. Cuando se envía un mensaje a un objeto puede ocurrir que:
En Java hay dos tipos de secuencias de caracteres: String y StringBuffer. Los objetos del tipo String son constantes y no se pueden cambiar, mientras que los del tipo StringBuffer son modificables.
Hay varias formas de crear Strings y StringBuffer. Se pueden declarar de forma fácil con la declaración normal que se ha visto hasta ahora. Ejemplo:
String nombre, direcci�n;
StringBuffer apellido;
Y se inicializan mediante asignaciones. Ejemplo:
nombre = "Mar�a";
Esto se debe a que, aunque en Java, las cadenas de caracteres sean consideradas como objetos existen facilidades para este tipo de datos que son no orientadas a objetos. Si las secuencias de caracteres fueran objetos puros, la asignación del ejemplo anterior no estaría permitida. La única forma adecuada para comunicarse con un objeto real es a través de un mensaje. Ejemplo:
usuario.setStringValue ("a1065");
Para utilizar cadenas de caracteres, se puede emplear String o StringBuffer. Son dos clases diferentes.
String representa las cadenas constantes, mientras que StringBuffer representa las cadenas modificables. Esto no quiere decir que la clase String sirva sólo para almacenar cadenas escritas literalmente en el programa, como:
String cadena = "esto es un ejemplo de una cadena de caracteres";
Un objeto de la clase String puede construirse con cualquier valor. Son posibles varios constructores, y sólo después de construir el objeto se hace intocable. Como su longitud es constante, el núcleo Java reserva para las cadenas constantes el espacio estrictamente necesario para su representación en memoria.
Las cadenas no constantes gestionan su longitud y el tamaño de su representación en memoria.
Ejemplo:
import java.io*;
class TestStringBuffer {
public static void main (String argv[ ) {
StringBuffer cadena = new StringBuffer ( );
cadena.append ("_123456789");
System.out.println (cadena + " " + cadena.Length( ) + ", " cadena.capacity ( ));
cadena.setLength ( 5 );
System.out.println (cadena + " " + cadena.Length( ) + ", " + cadena.capacity( ));
}
}
El resultado será el siguiente:
C:\programasJava\gramatica\java TestStringBuffer
_123456789 10, 16
_1234 5, 16
La cadena varía en su longitud (pasa de 10 caracteres a 5), pero su capacidad no varía: el núcleo Java le ha asignado 16 de modo predeterminado, porque el constructor utilizado no especificaba la capacidad, y se fija a 16 cuando la longitud de la cadena disminuye.
Las ventajas de los String frente a los StringBuffer son:
Un StringBuffer no puede transformarse en String, aunque se podría entender así a la vista del siguiente ejemplo:
StringBuffer cadena = new StringBuffer( );
cadena.append ("esto es una prueba");
System.out.println (cadena.toString( ));
La cadena no constante no se transforma en cadena constante, sino que da lugar a una cadena constante. Ésta es un nuevo objeto, que no reemplaza al antiguo, sino que tiene su propia existencia separada de la cadena StringBuffer que la ha generado.
Las operaciones que se pueden efectuar con un String son las siguientes:
Ejemplo:
String letras = "MAYUSCULAS";
System.out.println (letras.toLowerCase( ));
Este ejemplo crea una segunda cadena a partir de la primera, que no sufre cambios. Esta segunda cadena se utiliza para la llamada al método println( ), y después desaparece.
Los métodos más utilizados se muestran en la siguiente tabla:
| Método | Significado | Retorna |
|---|---|---|
| length( ) | determina la longitud de una cadena y lo retorna | un entero |
| charAt(ch) | busca el carácter situado en la posición ch dentro del string | un carácter |
| indexOf (str) | busca el string str en el objeto destino y retorna la posición que ocupa. La búsqueda comienza por el principio del string destino | un entero |
| lastIndexOf(str) | busca el string str en el objeto destino y retorna la posición que ocupa. La búsqueda comienza por el final del string destino | un entero |
| substring(int1,int2) | retorna un substring del string destino que contiene los caracteres desde la posición int1 hasta la int2 del string destino | un string |
Ejemplo-length:
int suma;
String cadena1, cadena2;
/*c�digo donde se le dan valores a las variables*/
suma = cadena1.length( ) + cadena2.length( );
Se declaran dos objetos String cadena1 y cadena2, se les envía el mensaje length, cada uno de estos mensajes devolverá un valor correspondiente a la longitud del string que esté tratando. La suma de los dos valores se almacena en la variable suma.
Ejemplo-charAt:
String nombre;
nombre = " tutorial.txt";
nombre.charAt(4);
El string nombre no se modifica, pero se retorna el carácter
de la posición 2; en este caso devolvería una ' r '.
Otro ejemplo:
int contador = 0;
String nombre;
...
/* c�digo donde se asigna un valor al string*/
...
int i = 0;
while (i < nombre.length( )){
char valor = nombre.charAt (i);
if (valor = 'a' || valor = 'e' || valor = 'i')
contador++;
i++;
}
Este ejemplo calcula cuántas veces aparecen las vocales a, e,
o i en el string.
Ejemplo-indexOf:
String texto;
texto = "esto es un texto de prueba";
texto.indexOf("es");
Realiza la búsqueda del string "es" en texto comenzando por el principio del string. Retornará un 0, ya que representa el primer índice dentro de la cadena. Si se buscara por ejemplo "un" en el mismo texto devolvería un 8.
Ejemplo-lastIndexOf:
String texto;
texto = "esto es un texto de prueba";
texto.lastIndexOf("es");
El ejemplo es similar al ejemplo de indexOf, pero la búsqueda empieza por el final del string texto. El resultado será un 7.
Ejemplo-substring:
String nombre;
nombre = " Jorge Alvarez";
nombre.lastIndexOf("3,6");
Obtiene la subristra de nombre que empieza en la posición 3 y
acaba en la posición 6. El resultado es "ge A".
Las operaciones que se pueden efectuar con un StringBuffer son las siguientes:
Los StringBuffer se diferencian de los Strings en que los objetos del primer tipo pueden modificarse y se tratan como objetos puros. Ejemplo:
StringBuffer cadena = new StringBuffer ("hola");
Los objetos StringBuffer también reconocen los cinco métodos mencionados anteriormente para los Strings, pero al ser objetos que pueden variarse, también responden a métodos que alteran su estado. Los tres métodos más populares son: append( ), insert( ), y setCharAt( ).
Append( ):
Añade un carácter al final del string. Ejemplo:
StringBuffer cadena = new StringBuffer ("hol");
cadena.append('a');
El mensaje añade el carácter al final del string cadena. Si cadena estuviera vacía, entonces el string formado estaría compuesto por un sólo carácter 'a'.
Insert( ):
Lleva dos argumentos. Se añade el string que hay en el segundo argumento
al objeto destino en la posición indicada por el índice (primer argumento). Ejemplo:
StringBuffer fichero = new StringBuffer ("direcciones.txt");
fichero.insert(11,"2");
El resultado es que se añade el string "2" al string fichero en la posición 11. Por tanto el contenido de fichero se convierte en "direcciones2.txt".
SetcharAt( ):
Tiene dos parámetros. El primero es un carácter y el segundo es una posición dentro del string. La operación consiste en reemplazar el carácter de la posición indicada por el carácter del primer parámetro. Ejemplo:
StringBuffer texto = new StringBuffer ("nueva clave");
texto.setcharAt(9,'s');
Se sustituye el carácter de la posición 9, por el carácter
's'. Ahora el valor de texto es "nueva clase".
Un ejemplo de concatenación de cadenas de caracteres es el siguiente:
Short n�mero = 0;
String asignatura = new String ( );
...
/* se calculan las variables anteriores*/
System.out.println ("Hay" + n�mero + "alumnos
matriculados en " + asignatura);
El resultado de este código es la visualización de:
Hay 70 alumnos matriculados en An�lisis N�merico
Los comentarios se pueden escribir de dos formas.
Para escribir comentarios después de las sentencias se pueden utilizar los caracteres //, que indican que el comentario empieza a partir de dicho símbolo y termina en el final de la línea. Ejemplo:
contador = 0; //se inicializa el contador;
a = 7;
...
El segundo tipo de comentario se emplea cuando el texto del comentario se extiende a varias líneas, aunque se puede utilizar también en una sola línea. El texto en este caso debe ir entre los símbolos /* .... */. Ejemplo:
x = 0;
y = 0; /* Se inicializan las variables y a continuaci�n
empieza el cuerpo del programa con sus respectivas sentencias
que finalizan en ............ */
if (x >0) /* si x es mayor que cero */
...
Las acciones en Java terminan con el separador punto y coma. Una secuencia se escribiría así:
l�nea1;
l�nea2;
l�nea3;
Los bloques en Java van encerrados entre llaves.
La estructura if permite que secciones de código sean ejecutadas en función de si cierta condición es verdadera o falsa. La sintaxis es:
if (condici�n)
acciones-cond-verdadera( );
else
acciones-cond-falsa( );
Si la condición es verdadera se ejecuta el código de acciones-cond-verd( ) y si es falsa acciones-cond-falsa( ).
Se puede ejecutar una sola instrucción como en el ejemplo anterior, o bien, un conjunto de ellas, que tienen que ir englobadas entre llaves. Ejemplo:
if (contador < =5)
contador ++;
else
{
texto="el contador es mayor que 5";
x++;
y++;
}
En caso de que contador tenga un valor menor o igual que 5 se incrementa el contador, si es mayor se realizan tres acciones: asignar a texto la ristra de caracteres delimitada por "", e incrementar las variables x e y.
La condición del if puede estar compuesta por varias condiciones. Ejemplo:
if (cont < 10 && continuar)
cont++;
La acción de incrementar cont se hará si se cumple que
cont sea menor que 10 y que la variable booleana continuar sea verdadera.
Permite establecer una condición múltiple, de forma que después de evaluar un argumento se lleve a cabo la acción correspondiente a ese caso. El formato es el siguiente.
switch(argumento)
{
case uno: acci�n1;
case dos: acci�n2;
...
case n: acci�n n;
}
Si en las acciones correspondientes a cada caso no se incluye la instrucción break, se continúa con la ejecución del siguiente caso y así sucesivamente hasta encontrar dicha instrucción o el final del switch.
Ejemplo:
switch(variable_entera)
{
case (1): accion1( );
case(2): accion2( );
break;
case(3): accion3( );
default: accion_por_defecto( );
}
En este ejemplo si el valor examinado por el switch vale 1 (variable_entera
= 1) se ejecutan accion1( ) y accion2( ). Si el valor
examinado es distinto de 1, 2, y 3 se ejecuta la accion_por_defecto().
Todos los lenguajes de programación incluyen estructuras que
facilitan que secciones de código se ejecuten repetidamente, ya
sea un número fijo de veces o bien, hasta que se cumpla una determinada
condición.
La sintaxis es:
while (expresi�n)
acci�n;
En acción puede ir una sola acción o un grupo de ellas encerradas entre llaves.
La semántica es :
Mientras la expresión sea verdadera se ejecutan las acciones.
Ejemplo:
int i = 0, total = 0 ;
while (i < 5)
{
total+= valores[i];
i++;
}
Primero se inicializan las variables i y total. Entra en el bucle donde se suma el elemento iésimo del vector valores en total y se incrementa i en uno. El resultado es la suma de los cinco elementos del vector y el almacenamiento de ese valor en total.
Si se utiliza el break en una estructura repetitiva, al encontrar el intérprete de Java el break, transfiere el control a la acción que sigue al bucle en el que se encuentra encerrado el break.
Ejemplo:
acci�n;
while (expresi�n) {
acci�n1;
acci�n2;
acci�n3;
if (condici�n)
break;
acci�n4;
...
acci�nn;
}
otra_acci�n;
Si cuando se esté ejecutando el bucle, condición es verdadera, entonces el intérprete de Java cede el control a la acción siguiente al bucle, en este caso a otra_acción.
Otro ejemplo más concreto se muestra a continuación:
boolean encontrado= false;
String palabra = "hola";
int cont=0; �ndice;
while(cont > n) {
if (tabla[cont].equals (palabra)) {
encontrado=true;
�ndice= cont;
break;
}
cont++;
}
En este fragmento de código se realiza la búsqueda de la palabra "hola" en el vector de strings llamado tabla. El código asume que el vector tiene n elementos que son strings. Si encuentra la palabra en la tabla la variable encontrado toma el valor verdadero y en índice se guarda la posición que ocupa palabra dentro de la tabla.
Es similar al while, se repite un conjunto de acciones mientras cierta condición sea verdadera. La única diferencia es que, en el do-while se tiene la seguridad de pasar al menos una vez por el bucle.
La sintaxis es:
do{
acciones;
} while (expresi�n);
La semántica es:
ejecutar las acciones mientras la expresión de la tercera línea sea verdadera.
Ejemplo:
int i = -1;
do
i++;
while ( !nombres [i.equals (�ltimo_nombre));
Este código busca la string de la variable último_nombre
en el vector de strings nombres. Para ello en cada iteración
se incrementa la variable i hasta que se encuentra el nombre. Hay
que tener en cuenta que en este ejemplo el código asume que el nombre
está contenido en el array; si no fuera así, el bucle continuaría
sobrepasando los límites del vector y el intérprete de Java
daría un error en tiempo de ejecución.
La sintaxis es:
for (expresi�n1; expresi�n2; expresi�n3)
acciones;
La sintaxis es:
Las acciones se ejecutan continuamente. Existe una variable de control que viene dada en expresión1. En cada iteración, una vez ejecutadas las acciones, expresión3 define el nuevo valor de la variable de control. El bucle termina cuando la condición expresada en expresión2 se haga falsa.
Ejemplo:
for (int i = 0; i < 10; i++)
vector [i]=0;
Aquí se inicializan los elementos de un vector a 0. La variable de control ( i ) comienza con valor 0 y en cada iteración se incrementa su valor en 1. Cuando i toma el valor 10 el proceso ha concluido.
La sentencia for puede ser más compleja. Ejemplo:
for ( int i = a + b; i <= max; i += 2)
acciones;
Las acciones se ejecutarán repetidas veces, la variable de control i se inicializa con el valor de a+b, y se incrementa en 2 en cada iteración que se realiza. Finaliza cuando i sea mayor que el contenidode la variable max.
La sentencia for existe en un varios formatos, todos ellos equivalentes al especificado hasta ahora. Son:
for (int i = 0; i < 10; i++)
vector[i] = 0;
int i = 0;
for (; i > 10; i++)
vector[i] = 0;
for (int i = 0; i < 10; ){
vector[i] = 0;
i++;
};
El famoso goto no existe en Java. Pero hay otras instrucciones de salto: break, continue y return.
Break permite abandonar una iteración (if, while, do) o un switch, transfiriendo el control directamente después de la iteración.
Continue salta a la iteración en la etapa siguiente.
Ejemplo:
import java.io.*;
class bucles {
public static void main (String argv[ ) {
int i = 0;
for (i = 1; i <5; i++) {
System.out.println ("antes " + i );
if ( i == 2) continue;
if ( i == 3) break;
System.out.println ( "despu�s " + i );
}
}
}
Este ejemplo dará el resultado siguiente:
C:\programasJava\Gramatica\java Bucles
antes 1
despu�s 1
antes 2
antes 3
En la primera iteración (i = 1 ) no hay break, ni continue. Se escribe antes1 y después1.
En la segunda iteración se ejecuta el continue, con lo cual se pasa directamente al inicio del bucle, sin terminarlo.
En la tercera iteración se ejecuta el break y por tanto sale completamente del bucle.
Return permite salir de un método sin ejecutar el fin
de éste. Si se coloca el return en un bucle, se sale del
método en el que se encuentra el bucle, y no sólo del bucle.
Otras instrucciones que controlan el flujo de ejecución se ven en los siguientes apartados:
Syncronized, en el apartado sobre los THREADS
Cacth, Throw, Try y Finally, en el apartado sobre las EXCEPCIONES.