2.1.1.-PeA- Unos conceptos III- Java

2.1.1.- Programación en Android: Unos conceptos (III)

En este capítulo hablaremos un poco sobre los tipos de datos en Java y los operadores.

Tipos de datos en JAVA.

En Java nos podemos encontrar con dos categorias de tipos de datos, una son los tipos primitivos, y la otra los tipos referenciados.

Los tipos referenciados tienen este nombre porque el valor de la variable es una referencia o puntero hacia el valor real. Los tipos referenciados son los arrays, las clases y los interfaces, de algunos de ellos ya hablamos anteriormente.

Los tipos primitivos contienen un sólo valor, ah, y en java no existen los tipos unsigned (sin signo) como en C, y a diferencia también del C y otros lenguajes, el tamaño de los tipos está impuesto por el compilador y es estándar independientemente de la máquina que los ejecute. Si recordamos, en C el tamaño dependía de la plataforma de destino. Veamos cuáles son los tipos primitivos en java:

Tipo	Tamaño o Formato	Descripción
byte	8 bits complemento a 2	Entero de 1 Byte.
short	16 bits complemento a 2	Entero corto (2 Bytes)
int	32 bits complemento a 2	Entero (4 Bytes)
long	64 bits complemento a 2	Entero largo (8 Bytes)
float	32 bits IEEE-754	Coma flotante de precisión simple.
double	64 bits IEEE-754	Coma flotante de precisión doble.
char	16 bits (Caracter unicode)	Un único carácter.
boolean	true o false	Valor booleano, verdadero o falso.

Las variables se declaran de la siguiente manera:

// Declaración variables de tipos primitivos dentro de un método: // [final] [tipo] [nombrevariable]; // Declaración e inicialización: // [tipo] [nombrevariable]= [valor]; //Aqui sólo son declaradas. byte variable_byte; short variable_short; int variable_int; long variable_long; float variable_float; double variable_double; char variable_char; boolean variable_booleana; //Aquí son declaradas e inicializadas byte variable_byte1 = 10; short variable_short1 = 10; int variable_int1 = 22; long variable_long1 = 11; long variable_long1 = 11L; float variable_float1 = (float) 1024.12; float variable_float1 = 1024.12f; double variable_double1 = 2048.122; double variable_double1 = 2048.122d; char variable_char1 = 'p'; //Char se escribe con la comilla ' simple boolean variable_booleana1 = true; //La siguiente línea da ERROR por que es un int // y los valores permitidos son true o false boolean variable_booleana1 = 0; //Ahora una prueba de constante. //Con el modificador final, despues de inicializarla no puede tomar otro valor. final int constante = 10; final int constante2; //Aqui solo la declaramos. constante = 12; // DA ERROR constante2 = 20; //No da error ya que la inicializamos aqui. constante2 = 30; //DA ERROR, ya está inicializada. //Aqui mostrará por consola los valores mínimos y máximos. System.out.println("Valor máximo Byte: " + Byte.MAX_VALUE); System.out.println("Valor mínimo Byte: " + Byte.MIN_VALUE); System.out.println("Valor máximo Short: " + Short.MAX_VALUE); System.out.println("Valor mínimo Short: " + Short.MIN_VALUE); System.out.println("Valor máximo Int: " + Integer.MAX_VALUE); System.out.println("Valor mínimo Int: " + Integer.MIN_VALUE); System.out.println("Valor máximo Long: " + Long.MAX_VALUE); System.out.println("Valor mínimo Long: " + Long.MIN_VALUE); System.out.println("Valor máximo Float: " + Float.MAX_VALUE); System.out.println("Valor mínimo Float: " + Float.MIN_VALUE); System.out.println("Valor máximo Double: " + Double.MAX_VALUE); System.out.println("Valor mínimo Double: " + Double.MIN_VALUE); System.out.println("Valor máximo Char: " + Character.MAX_VALUE); System.out.println("Valor mínimo Char: " + Character.MIN_VALUE);

Hay que tener en cuenta que los nombres de las variables deben ser válidos.

Los nombres válidos están formados por un identificador legal de Java, formado por una serie de carácteres unicode. No pueden ser el mismo nombre que una palabra clave o el nombre de un valor booleano. No pueden tener el mismo nombre que otras variables que estén en el mismo ámbito, pero sí que pueden repetirse nombres en ámbitos distintos.

Por convención (que no obligación) los nombres de variables en Java comienzan por minúscula, y si el nombre de la variable está compuesta por varias palabras, se suele poner la siguiente comenzando por mayúscula: nombreDeUnaVariable.

Operadores

Los operadores realizan operaciones sobre los operandos.

Si sólo requieren un operador se llaman operadores unarios, y en caso de necesitar dos operandos se llaman operadores binarios, además hay un operador ternario, ? . "++" Sería un operador unario que incrementaría el valor del operando en 1, mientras que "=" sería binario ya que asigna el valor del operando derecho al operando izquierdo.

Los operadores unarios en Java pueden ir como prefijo o sufijo, igual que en C.

Si son empleados como prefijo entonces afectan a la variable antes de evaluarla, y si por el contrario van como sufijo afectan a la variable después de evaluarla.

Los operadores binarios siempre aparecen entre los dos operandos, [operando1 operador operando2].

En el archivo que va de ejemplo a este capítulo se puede observar a que me refiero. Parte del código incluído allí es este:

private static void ejemploOperadoresAritmeticos() { int operador1 = 0; int operador2 = 0; int op1, op2, op3, op4; System.out.println("Operador1=" + operador1 + " Operador2=" + operador2); operador1 = 1; //Operador binario = System.out.println("Operador1=" + operador1 + " Operador2=" + operador2); operador2 = operador1; //Operador binario= System.out.println("Operador1=" + operador1 + " Operador2=" + operador2); operador1++; //Operador unario ++ en modo sufijo System.out.println("Operador1=" + operador1 + " Operador2=" + operador2); --operador2; // Operador unario -- en modo prefijo System.out .println("Operador1=" + operador1 + " Operador2=" + operador2); op1 = op2 = op3 = op4 = 0; //En esta línea vemos como todos son 0: System.out.println("Op1:"+op1+" Op2:"+op2+" Op3:" + op3 + " Op4:" + op4); //Diferencia entre sufijo y prefijo //En esta línea la salida que da es: Op1:0 Op2:1 Op3:0 Op4:0 // Porque el sufijo (++) op1++ lo incrementa despues de evaluarlo, // y el prefijo (++) ++op2 lo incrementa antes de evaluarlo. System.out.println("Op1:"+ op1++ +" Op2:"+ ++op2+" Op3:"+op3+"Op4:"+op4); // Ahora podemos observar que las variables ya tienen el valor. System.out.println("Op1:"+op1+" Op2:"+op2+" Op3:" + op3 + " Op4:" + op4); //Que valor dará la siguiente línea? (Sí es válida. ;) ) // En este momento op1=1 y op2=1 op4 = op1++ + ++op2; //Sin embargo aquí ya muestra op1=2 y op2=2, porque ya fueron evaluados. System.out.println("Op1:"+op1+"Op2:"+op2+" Op3:"+op3+ " Op4:" + op4); //Hemos utilizado el operador ++ pero también se aplica para -- //El operador + también sirve para unir cadenas System.out.println("Esto un" + "ido a Esto"); }

Los operadores pueden ser divididos en varias categorías: aritméticos, relacionales, condicionales, desplazamiento, lógicos y de asignación.

Operadores aritméticos: Realizan operaciones de aritmética básica. El tipo de datos que devuelven depende del tipo de datos de los operadores. Si sumamos dos int el valor devuelto será un int. Los operadores aritméticos utilizados en Java son los siguientes:

Operador	Descripción	Ejemplo
+	Suma. Realiza la suma de los operandos. Tambien sirve para convertir el número a entero en caso de ser byte, short o char.	resultado=varUno + varDos;
++	Incrementa en uno el operando.	++resultado;
+	Concatena. Une dos cadenas de texto.	resultado="Esto un" + "ido a Esto";
-	Resta. Le sustrae al primer operando el segundo.	resultado=varUno – varDos;
-	Utilizado como operador unario invierte el valor. (Si tiene el signo + pasa a – y si tiene el signo – pasa a +)	resultado= -varUno;
--	Decrementa en uno el operando.	resultado--;
*	Multiplicación. Multiplica los operandos.	resultado=varUno * varDos;
/	División. Divide el primer operando (dividendo) por el segundo (divisor).	resultado=varUno / varDos;
%	Módulo. Devuelve el resto de la división del primer operando (dividendo) por el segundo (divisor)	resultado=varUno % varDos;

Operadores relacionales: Los operadores relacionales se emplean para comparar valores y determinar su relación. El valor que devuelven puede ser true o false. Devuelven true siempre que se cumpla dicha relación, en caso de que la relación no se cumpla devuelven false.

Operador	Utilización	Descripción
>	op1 > op2	Mayor que. Devuelve true si op1 es mayor que op 2. Si no false.
>=	op1 >= op2	Mayor o igual que. Devuelve true si op1 es mayor o igual a op2.
<	op1 < op2	Menor que. Devuelve true si op1 es menor que op2.
<=	op1 <= op2	Menor o igual que. Devuelve true si op1 es menor o igual que op2.
==	op1 == op2	Igualdad. Devuelve true si op1 es igual a op2. NO CONFUNDIR CON = que es asignación.
!=	op1 != op2	Desigualdad. Devuelve true si op1 es distinto de op2.

A menudo los operadores relacionales se emplean junto a los operadores condicionales para construir expresiones más complejas.

Operadores condicionales: Realizan operaciones booleanas lógicas. No afectan a los valores, pero nos devuelven true o false en caso de cumplirse o no las expresiones.

Operador	Utilización	Descripción
&&	expr1 && expr2	Y (AND). Devuelve true si expr1 y expr2 son true (LOS DOS).
&	expr1 & expr2	Y (AND). Devuelve true si expr1 y expr2 son true (LOS DOS). En este caso AMBOS valores deben ser booleanos (expr1 y expr2)
||	expr1 || expr2	O (OR). Devuelve true si expr1 o expr2 es true. (CUALQUIERA DE LOS DOS)
|	expr1 | expr2	O (OR). Devuelve true si expr1 o expr2 es true. (CUALQUIERA DE LOS DOS). En este caso AMBOS valores deben ser booleanos.
!	! expr	NO (NOT). Devuelve true si expr es falso.

Operadores de desplazamiento: Desplazan los bits de los datos.

Operador	Utilización	Descripción	Ejemplo (Op1= 11001101 (205 decimal))
>>	op1 >> op2	Desplaza a la derecha op2 bits de op1, en caso de que el bit de signo (el de más a la izquierda) sea 1, al desplazar introduce un 1.	op1=op1>>1; (op1=01100110)
<<	op1 << op2	Desplaza a la izquierda op2 bits de op1	op1=op1<<2; (op1=00110100)
>>>	op1 >>> op2	Desplaza a la derecha op2 bits de op1 (sin signo). (En caso de que el bit de signo (el de más a la izquierda) sea 1, al desplazar introduce un 0.	op1=op1>>>2; (op1=00110011)

Operadores lógicos. Operadores para trabajar con bits.

Los operadores lógicos permiten manipular los bits de los datos. Un ejemplo de para que nos sirve esto es para "aislar" bits individuales, como cuándo trabajamos con flags. Las flags o banderas son valores en los que cada bit individual representa un estado asociado. Es como una asociación de valores de tipo bool.

También sirven para evaluar valores, ya que or se evalúa a true si alguno de los operandos es cierto, and se evalúa a true si ambos operandos son true, y xor es evaluado a true si ambos tienen el mismo valor.

Operador	Utilización	Descripción	Ejemplo (Op1= 11 binario, Op2=10 binario)
&	op1 & op2	AND lógico, a nivel de bits.	Op1 & op2 = 10
|	Op1 | op2	OR lógico, a nivel de bits.	Op1 | op2 = 11
^	Op1 ^ op2	XOR lógico. Or exclusivo a nivel de bits.	Op1 ^ op2 = 01
~	~op1	Complemento. Convierte lo true a false y viceversa. (Se introduce con alt+126)	~op1 = 00

Operadores de asignación.

En Java existen varios operadores de asignación que permiten realizar operaciones aritméticas, lógicas o de bits además de realizar la asignación al mismo tiempo.

Veamoslo en la siguiente tabla:

Operador	Utilización	Descripción y Equivalencia	Ejemplo
=	var = [valor]	Asigna el valor a variable.	J= 4;
+=	var+=[valor]	Var = var+ [valor]	var+=var2;
-=	var-=[valor]	var=var-[valor]	Var-=2;
*=	var*=[valor]	var=var*[valor]	Var*=3.14d;
/=	Var/=[valor]	var=var/[valor]	Var/=2;
%=	var%=[valor]	var=var % [valor]. Módulo.	Var%=2;
&=	var&=[valor]	var=var & [valor]. AND	Var&=2;
|=	var|=[valor]	var=var | [valor]. OR	Var|=2;
^=	Var ^=[valor]	var=var ^ [valor]. XOR	Var^=2;
<<=	var<<=[valor]	var=var << [valor]. Desplazamiento.	Var<<=1;
>>=	var>>=[valor]	var=var >> [valor]. Desplazamiento.	Var>>=2;
>>>=	var>>>=[valor]	var=var>>>[valor]. Desplazamiento sin signo.	Var>>>=2;

El operador ternario ?

En Java, al igual que en C, existe un operador ternario, el ? Que funciona como una versión reducida de la sentencia if-else.

Por ejemplo:

b = (a > c) ? 5 : 15; equivale a: if (a > c) b = 5; else b = 15;

Podeis descargaros un proyecto con los ejemplos de este capítulo aqui.

Ver. 1.0 – Revisión 23.1.2012