Las variables Java son un espacio de memoria en el que guardamos un determinado valor (o dato). Para definir una variable seguiremos la estructura:
[privacidad] tipo_variable identificador;
Java es un lenguaje de tipado estático. Por lo cual todas las variables tendrán un tipo de dato (ya sea un tipo de dato primitivo o una clase) y un nombre de identificador.
El tipo de dato se asignará a la hora de definir la variable. Además, en el caso de que las variables sean propiedades de objetos tendrán una privacidad.
Ejemplos de variables serían…
int numero = 2;
String cadena = "Hola";
long decimal = 2.4;
boolean flag = true;
Las variables son utilizadas como propiedades dentro de los objetos.
class Triangulo {
private long base;
private long altura;
}
No te preocupes por el concepto de objeto, ya que lo revisaremos más adelante cuando hablemos de la Programación Orientada a Objetos
Dentro de Java podemos encontrar los siguientes tipos de variables:
class Triangulo {
private long base;
private long altura;
}
class Triangulo {
static long lados = 3;
}
Si además queremos que el valor no pueda cambiar nunca la definiremos como final.
class Matematicas {
final static long PI = 3.14159;
}
int variable = 2;
public Triangulo(long base, long altura){...}
Cuando vayamos a dar un nombre a una variable deberemos de tener en cuenta una serie de normas. Es decir, no podemos poner el nombre que nos dé la gana a una variable.
Los identificadores son secuencias de texto unicode, sensibles a mayúsculas cuya primer carácter solo puede ser una letra, número, símbolo dolar $ o subrayado _ . Si bien es verdad que el símbolo dolar no es utilizado por convención.
Es recomendable que los nombres de los identificadores sean legibles y no acrónimos que no podamos leer. De tal manera que a la hora de verlos se auto-documenten por sí mismos. Además estos identificadores nunca podrán coincidir con las palabras reservadas.
Algunas reglas no escritas, pero que se han asumido por convención son:
Como ya hemos comentado Java es un lenguaje de tipado estático. Es decir, se define el tipo de dato de la variable a la hora de definir esta. Es por ello que todas las variables tendrán un tipo de dato asignado.
El lenguaje Java da de base una serie de tipos de datos primitivos.
Es importante saber que estos son tipos de datos del lenguaje y que no representan objetos. Cosa que sí sucede con el resto de elementos del lenguaje Java.
Representa un tipo de dato de 8 bits con signo. De tal manera que puede almacenar los valores numéricos de -128 a 127 (ambos inclusive).
Representa un tipo de dato de 16 bits con signo. De esta manera almacena valores numéricos de -32.768 a 32.767.
Es un tipo de dato de 32 bits con signo para almacenar valores numéricos. Cuyo valor mínimo es -231 y el valor máximo 231-1.
Es un tipo de dato de 64 bits con signo que almacena valores numéricos entre -263 a 263-1
Es un tipo dato para almacenar números en coma flotante con precisión simple de 32 bits.
Es un tipo de dato para almacenar números en coma flotante con doble precisión de 64 bits.
Sirve para definir tipos de datos booleanos. Es decir, aquellos que tienen un valor de true o false. Ocupa 1 bit de información.
Es un tipo de datos que representa a un carácter Unicode sencillo de 16 bits.
En el caso de que definamos una variable y no le demos ningún valor, por defecto llevarán los siguientes valores:
| Dato Primitivo | Valor por Defecto |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | ‘u0000’ |
| String (o cualquier objeto) | null |
| boolean | false |
Hay un tipo de dato String para el manejo de cadenas que no es en sí un tipo de dato primitivo. Con el tipo de dato String podemos manejar cadenas de caracteres separadas por dobles comillas.
El elemento String es un tipo de dato inmutable. Es decir, que una vez creado, su valor no puede ser cambiado.
El String no es un tipo de dato primitivo del lenguaje Java. Pero su uso es igual de importante que el de los tipos de datos revisados aquí. Veremos más en detalle el uso del tipo String.
]]>Cada una de las tecnologías de desarrollo del lenguaje Java contiene:
La aplicación se ejecuta dentro de la Java Virtual Machine (JVM) y tiene capacidad de accerder al API, que son las librerías con funcionalidades que nos ofrece Java.
Las tecnologías que existen en la plataforma Java son:
Java SE es la plataforma estándar y objetivo de este tutorial sobre Java en la cual se recogen todas las funcionalidades básicas del lenguaje.
Dentro de estas funcionalidades básicas de Java encontramos: el uso de colecciones, acceso a ficheros con Java IO y NIO y bases de datos con JDBC, librerías para el desarrollo de aplicaciones de escritorio o web como Swing o JavaFX, librerías para la fecha y hora, posibilidad de crear aplicaciones multi-hilo, capacidades para realizar conexiones en red, manejo de contenido XML… incluso incluye la base de datos Java DB para el uso en memoria.
Si estás empezando con Java lo más normal es que te bajes las librerías de Java SE.
Puedes consultar todo el contenido de Java SE.
Java EE se crea para poder realizar aplicaciones empresariales con Java. De esta forma se dota a Java EE con capacidades de desarrollo de aplicaciones de servidor con tecnologías como Servlets, JSP o EJB.
Java EE nos permite realizar el desarrollo de servicios, ya sean WSDL (con JAX-WS), REST (con JAX-RS), o la creación de websockets.
Además ofrece un API de persistencia de objetos con JPA, capacidades de mensajería con Java Message, de email con Java Mail o gestión de procesos batch.
Puedes consultar todo el contenido de Java EE.
Java ME es la implementación de Java que nace para la creación de aplicaciones móviles.
Si bien con el paso del tiempo se ha ido enfocando más para el desarrollo de dispositivos IoT (Internet of Things): televisiones, sensores, impresoras,…
Así, dentro de Java ME podemos encontrar:
Puedes encontrar más información sobre lo que es Java ME
Es la tecnología de Java que nos sirve para el desarrollo de aplicaciones que vayan a ir en tarjetas inteligentes, aquellas que llevan un chip y poca capacidad de procesamiento y memoria.
Puedes leer más sobre Java Cards y las capacidades que ofrece.
]]>Ya vimos que en la sentencia selectiva switch se utilizaba la sentencia break para salir de las evaluaciones y así solo ejecutar el bloque de la opción correspondiente. Si bien podemos utilizar la sentencia break con las sentencias repetitivas while, do-while y for. Esta es la que se conoce como sentencia break sin etiquetar.
Cuando utilicemos el break dentro de uno de estos bucles lo que se conseguirá es salirse de la ejecución del bucle hasta el siguiente bloque de sentencias. Mismo efecto que si la expresión de evaluación hubiese dado false.
Así podremos encontrarnos códigos como el siguiente:
while (expresion) {
sentencia(s);
break;
sentencias(s);
}
Al ejecutar la sentencia break ya no ejecutaremos las sentencias que vayan después.
El uso del break dentro de estructuras repetitivas suele aparecer cuando estamos realizando la búsqueda de un elemento por una estructura de datos y lo hemos encontrado.
Por ejemplo, si tenemos un array y queremos buscar un número dentro del array podríamos tener el siguiente código:
int[] numeros = {12,3,4,5,6,7,9,10};
int posicion = 0;
boolean encontrado = false;
while (posicion < numeros.length) {
if (numeros[posicion] == 5) {
encontrado = true;
break;
}
posicion++;
}
if (encontrado) {
System.out.println("El número está en la posición: " + posicion);
} else {
System.out.println("Número no encontrado");
}
Las sentencias break se pueden cambiar por variables bandera. Estas variables bandera actúan como cortocircuitos de las expresiones de validación y hacen que salgamos de los bucles.
En este caso podríamos haber utilizado la variable “encontrado” como variable bandera. Y podríamos reescribir el código de la siguiente forma:
int[] numeros = {12,3,4,5,6,7,9,10};
int posicion = -1;
boolean encontrado = false;
while ((!encontrado) && (posicion<numeros.length)) {
posicion++;
if (numeros[posicion] == 5) {
encontrado = true;
}
}
if (encontrado) {
System.out.println("El número está en la posición: " + posicion);
} else {
System.out.println("Número no encontrado");
}
Como podéis ver el código es muy parecido y solo aparece la condición de la variable bandera.
Una de las cosas que tenemos que tener en cuenta a la hora de utilizar las sentencias break sin etiquetar es que estas generan que se rompa la secuencia de ejecución de sentencias hasta el primer bloque anidado.
Pero, ¿qué sucedería si queremos salir de un conjunto de bucles anidados? Aunque podríamos utilizar múltiples break existe la posibilidad de utilizar sentencias break etiquetadas.
Las sentencias break etiquetadas funcionan igual que las break pero al ejecutarse se salen a la siguiente sentencia después del bloque etiquetado.
La sintaxis es:
break nombre_etiqueta;
Veamos como podría ser una estructura de uso de las sentencias break etiquetadas.
sentencia(s) iniciales;
etiqueta:
while (expresion) {
sentencia(s) bloque1;
while (expresion) {
sentencia(s) bloque2;
break etiqueta;
}
}
sentencias(s) finales;
Al ejecutarse se sale de todo el bloque etiquetado como etiqueta y ejecuta las sentencias finales.
Esto podemos encontrarlo si estamos recorriendo una matriz para buscar un elemento. Ya que para recorrer una matriz vamos a necesitar dos bucles anidados.
int[][] matriz = {
{1,2,3,4},
{5,6,7,8},
{9,10,11,12}
};
int numeroBuscado = 5;
busqueda:
for (int x=0; x < matriz.length; x++) {
for (int y=0; y < matriz[x].length; y++) {
if (matriz[x][y] = numeroBuscado) {
encontrado = true;
break busqueda;
}
}
}
if (encontrado) {
System.out.println(x + "," + y);
} else {
System.out.println("No encontrado");
}
Otra sentencia que podemos utilizar en los bucles es la sentencia continue. A ejecutar una La sentencia continue dejaremos de ejecutar las sentencias que quedan para acabar el bloque dentro de un bucle para volver a evaluar una expresión.
La estructura de unas sentencia continue sería:
while (expresion) {
sentencia(s) iniciales;
continue;
sentencias(s) finales;
}
Al ejecutarse la sentencia continue nunca se ejecutarán las sentencias finales.
De igual manera que sucedía con la sentencia break, podemos realizar continue etiquetados. En este caso la sentencia continue nos llevará directamente a la primera condición de evaluación del bloque.
La estructura en este caso sería la siguiente:
etiqueta:
while (expresion) {
sentencia(s) iniciales;
while (expresion) {
sentencia(s) iniciales;
continue etiqueta;
sentencia(s) finales;
}
sentencia(s) finales;
}
Las sentencias de decisión son: if-then-else y switch.
La estructura de las sentencias if-then-else es:
if (expresion) {
// Bloque then
} else {
// Bloque else
}
Se evalua la expresión indicada en la sentencia if. En el caso de que la expresión sea true se ejecutará el bloque de sentencias then y en el caso de que la expresión sea false se ejecutará el bloque de sentencias else.
La parte del else no tiene por qué existir. En este caso tendríamos una sentencia if-then.
if (expresion) {
// Bloque then
}
De esta forma podríamos tener el siguiente código fuente:
int valor = 4;
if (valor < 10) {
System.out.println("El número es menor de 10");
} else {
System.out.println("El número es mayor de 10");
}
Las sentencias if-then-else pueden estar anidadas y así nos encontraríamos con una sentencia if-then-elseif, la cual tendría la siguiente estructura:
if (expresion) {
// Bloque then
} else if {
// Bloque else
} else if {
// Bloque else
} else if {
// Bloque else
} ...
De esta forma podemos tener el siguiente código:
int valor = 14;
if (valor < 10) {
System.out.println("El valor es una unidad");
} else if (valor < 100) {
System.out.println("El valor es una decena");
} else if (valor < 1000) {
System.out.println("El valor es una centena");
} else if (valor < 10000) {
System.out.println("El valor es un millar");
} else {
System.out.println("Es un número grande");
}
Para los casos en los que se tienen muchas ramas o caminos de ejecución en una sentencia if tenemos la sentencia switch. La sentencia switch evalúa una expresión y ejecutará el bloque de sentencias que coincida con el valor de la expresión.
El valor de la expresión tiene que ser numérico. Aunque a partir de Java SE 7 ya se pueden utilizar expresiones cuya evaluación sean cadenas.
La estructura de la sentencia switch es:
switch (expresion) {
case valor1:
bloque1;
break;
case valor2:
bloque2;
break;
case valor3:
bloque3;
break;
...
default:
bloque_por_defecto;
}
Es importante ver que se utiliza la sentencia break. La sentencia break hace que se salga de la sentencia switch y por lo tanto no se evalúe el resto de sentencias. Por lo tanto su uso es obligatorio al final de cada uno de los bloques.
Un ejemplo claro en el que podemos utilizar la sentencia switch es para evaluar el valor de un mes en numérico y convertirlo a cadena. Este código quedaría de la siguiente forma:
int iMes = 3;
String sMes;
switch (iMes) {
case 1:
sMes = "Enero";
break;
case 2:
sMes = "Febrero";
break;
case 3:
sMes = "Marzo";
break;
case 4:
sMes = "Abril";
break;
case 5:
sMes = "Mayo";
break;
case 6:
sMes = "Junio";
break;
case 7:
sMes = "Julio";
break;
case 8:
sMes = "Agosto";
break;
case 9:
sMes = "Septiembre";
break;
case 10:
sMes = "Octubre";
break;
case 11:
sMes = "Noviembre";
break;
case 12:
sMes = "Diciembre";
break;
default:
sMes = "Mes incorrecto";
}
System.out.println(sMes);
Este mismo modelo lo podríamos haber implementado mediante una estructura if-then-else. Si bien, como podemos ver en el código queda más complejo
if (iMes == 1){
sMes = "Enero";
} else if (iMes == 2) {
sMes = "Febrero";
} else if (iMes == 3) {
sMes = "Marzo";
} else if (iMes == 4) {
sMes = "Abril";
} else if (iMes == 5) {
sMes = "Mayo";
} else if (iMes == 6) {
sMes = "Junio";
} else if (iMes == 7) {
sMes = "Julio";
} else if (iMes == 8) {
sMes = "Agosto";
} else if (iMes == 9) {
sMes = "Septiembre";
} else if (iMes == 10) {
sMes = "Octubre";
} else if (iMes == 11) {
sMes = "Noviembre";
} else if (iMes == 12) {
sMes = "Diciembre";
} else {
sMes = "Mes incorrecto";
}
System.out.println(sMes);
Otra cosa que tenemos que saber de la sentencia switch es que las evaluaciones case pueden ser múltiples. La estructura en este caso sería:
switch (expresion) {
case valor1: case valor2: case valor3:
bloque1;
break;
case valor4: case valor5: case valor6:
bloque2;
break;
...
default:
bloque_por_defecto;
}
Esto podemos utilizarlo para saber los días del mes. El código sería el siguiente:
int iMes = 3;
String sDias;
switch (iMes) {
case 1: case 3: case 5: case 7: case 8: case 10: case 12:
sDias = "El mes tiene 31 días";
break;
case 4: case 6: case 9: case 11:
sDias = "El mes tiene 30 días";
break;
case 2:
sDias = "El mes tiene 28 días (o 29 días si es año bisiesto)";
break;
default:
sDias = "Mes incorrecto";
}
Como vemos tenemos diferentes evaluaciones con la sentencia case.
Si bien existen las sentencias de control de flujo las cuales permiten alterar el fujo de ejecución para tomar decisiones o repetir sentencias.
Dentro de las sentencias de control de flujo tenemos las siguientes:
Son sentencias que nos permiten tomar una decisión para poder ejecutar un bloque de sentencias u otro.
Las sentencias de decisión son: if-then-else y switch.
Mediante if-then-else podremos evaluar una decisión y elegir por un bloque u otro.
if (expresion) {
// Bloque then
} else {
// Bloque else
}
Mientras que con switch podremos evaluar múltiples decisiones y ejecutar un bloque asociado a cada una de ellas.
switch (expresion) {
case valor1:
bloque1;
break;
case valor2:
bloque2;
break;
case valor3:
bloque3;
break;
…
default:
bloque_por_defecto;
}
Las sentencias de bucle nos van a permitir ejecutar un bloque de sentencias tantas veces como queramos, o tantas veces como se cumpla una condición.
En el momento que se cumpla esta condición será cuando salgamos del bucle.
Las sentencias de bucle en Java son: while, do-while y for.
En el caso de la sentencia while tenemos un bucle que se ejecuta mientas se cumple la condición, pero puede que no se llegue a ejecutar nunca, si no se cumple la condición la primera vez.
while (expresion) {
bloque_sentencias;
}
Por otro lado, si utilizamos do-while, lo que vamos a conseguir es que el bloque de sentencias se ejecute, al menos, una vez.
do {
bloque_sentencias;
} while (expresion)
La sentencia for nos permite escribir toda la estructura del bucle de una forma más acotada. Si bien, su cometido es el mismo.
for (sentencias_inicio;expresion;incremento) {
bloque_sentencias;
}
Las sentencias de ramificación son aquellas que nos permiten romper con la ejecución lineal de un programa.
El programa se va ejecutando de forma lineal, sentencia a sentencia. Si queremos romper esta linealidad tenemos las sentencias de ramificación.
Las sentencias de ramificación en Java son: break y continue.
En el caso de break nos sirve para salir de bloque de sentencias, mientras que continue sirve para ir directamente al siguiente bloque.
Las sentencias de bucle en Java son: while, do-while y for.
La estructura repetitiva while realiza una primera evaluación antes de ejecutar el bloque. Si la expresión es true pasa a ejecutar de forma repetida el bloque de sentencias.
Cada vez que termina de ejecutar el bloque de sentencias vuelve a evaluar la expresión. Si la expresión sigue siendo true vuelve a ejecutar el bloque. En el caso de que la expresión sea false se saldrá del bucle.
Es por ello que dentro del bloque de sentencias deberán de existir sentencias que modifiquen la evaluación de la expresión, ya que de no hacerse se podría entrar en un bucle infinito.
La estructura de la sentencia while es la siguiente:
while (expresion) {
bloque_sentencias;
}
Los casos de uso de una sentencia repetitiva while son variados, pero principalmente se utiliza para recorrer estructuras de datos o tener contadores.
Por ejemplo podemos realizar un contador de 1 a 10 de la siguiente forma:
int contador = 1;
while (contador <= 10) {
System.out.println(contador);
contador++;
}
En el caso de la estructura repetitiva do-while el funcionamiento es el mismo que el de while. Pero con una diferencia, primero se ejecuta el bloque de sentencias y luego se evalua la expresión. Por lo tanto siempre se ejecutará, al menos una vez, el bloque de sentencias.
La estructura de la sentencia do-while es:
do {
bloque_sentencias;
} while (expresion)
Al igual que anteriormente, en el bloque de sentencias deberemos de modificar alguna de las condiciones de la expresión para poder salir del bucle.
Un ejemplo claro del bucle do-while sería el ejemplo en el que le pedimos al usuario que introduzca números por teclado, los cuales mostraremos en forma de eco por pantalla, hasta que introduzca el cero. En ese caso saldremos del bucle.
Utilizaremos la estructura do-while en vez de la while ya que al menos vamos a pedirle al usuario un número.
El código sería el siguiente:
Scanner reader = new Scanner(System.in);
int iNumero;
do {
System.out.println("Introduce carácter por consola");
iNumero = reader.nextInt();
System.out.println(iNumero);
} while (iNumero <> 0);
En el caso de haberlo realizado con un bucle while tendríamos que repetir la captura y salida de datos. Veamos como quedaría para que puedas ver las diferencias.
Scanner reader = new Scanner(System.in);
int iNumero;
System.out.println("Introduce carácter por consola");
iNumero = reader.nextInt();
System.out.println(iNumero);
while (iNumero <> 0) {
System.out.println("Introduce carácter por consola");
iNumero = reader.nextInt();
System.out.println(iNumero);
}
Otra de las sentencias repetitivas que tenemos, a parte de los bucles while y do-while, es la sentencia for.
La sentencia for tiene la característica de que tiene bien definido el inicio del bloque, la evaluación de la expresión, el incremento de valor y el bloque de sentencias.
La estructura del bucle for es:
for (sentencias_inicio;expresion;incremento) {
bloque_sentencias;
}
Tanto las sentencias_inicio, expresión como incremento son opcionales y pueden estar o no. Aunque normalmente aparecerán en la estructura.
Esta estructura la podríamos reproducir mediante una sentencia while de la siguiente forma:
sentencias_inicio;
while (expresion) {
bloque_sentencias;
incremento;
}
Las funcionalidades en las que utilizaremos la sentencia for serán las mismas que las sentencias while y do-while, que serán contadores, recorrer estructuras,…
Si queremos definir un contador de 1 a 10 mediante una sentencia for utilizaremos el siguiente código:
for (int x=1;x<=10;x++=) {
System.out.println("Valor del contador: " + x);
}
En pantalla obtendremos el siguiente resultado:
Valor del contador: 1 Valor del contador: 2 Valor del contador: 3 Valor del contador: 4 Valor del contador: 5 Valor del contador: 6 Valor del contador: 7 Valor del contador: 8 Valor del contador: 9 Valor del contador: 10]]>
Los operadores unitarios que tenemos en Java son:
| Operador | Descripción |
|---|---|
| + | Operador unario suma. Indica un número positivo. |
| - | Operador unario resta. Niega una expresión. |
| ++ | Operador de incremento. Incrementa el valor en 1. |
| – | Operador de decremento. Decrementa el valor en 1. |
| ! | Operador de complemento lógico. Invierte el valor de un booleano |
Los operadores unitarios de suma o resta son muy sencillos de utilizar. En el caso del operador unitario suma su uso es redundante. Con el operador unitario resta podemos invertir un valor.
Por ejemplo podríamos tener el siguiente código:
int valor = 2;
System.out.println(-valor); // Imprimirá por pantalla un -2
Los operadores de incremento se pueden aplicar como prefijo o como sufijo.
++ variable;
variable ++;
-- variable;
variable --;
En todos los casos el valor de la variable acabará con una unidad más (para el operador de incremento) o con una unidad menos (para el operador de decremento).
Si bien si están participando en una asignación hay que tener cuidado en si utilizamos el operador como prefijo o como sufijo.
En el caso de utilizarlo como prefijo el valor de asignación será el valor del operando más el incremento de la unidad. Y si lo utilizamos como sufijo se asignará el valor del operador y luego se incrementará la unidad sobre el operando.
Es más sencillo verlo en código:
suma = ++vble1;
Sería lo mismo que poner
vble1 = vble1 + 1;
suma = vble1;
Mientras que si escribimos:
suma = vble1++;
Sería lo mismo que poner:
suma = vble1;
vble1 = vble1 + 1;
Exactamente lo mismo le sucede al operador de decremento, pero restando una unidad.
El operador de complemento lógico sirve para negar un valor lógico. Se suele utilizar delante de una operación de evaluación booleana. Normalmente en sentencias de decisión o bucles.
La estructura es:
! (expresion)
Si la expresión era un true la convierte en false y si era false la convierte en true.
Podemos verlo en el siguiente ejemplo:
int vble1 = 2;
int vble2 = 3;
if !(vble1 > vble2)
System.out.println("variable 1 es más pequeña que la variable 2");
Como podemos observar el valor de la expresión evaluada es convertido.
]]>El listado de operadores de igualdad y relacionales en Java es:
| Operador | Descripción |
|---|---|
| == | igual a |
| != | no igual a |
| > | mayor que |
| >= | mayor o igual que |
| < | menor que |
| <= | menor o igual que |
Mediante los operadores de igualdad podemos comprobar si dos valores son iguales (operador ==) o diferentes (operador !=).
La estructura de los operadores de igualdad es la siguiente:
vble1 == vble2
vble1 != vble2
Podemos utilizar estos operadores de igualdad en Java de la siguiente forma:
int vble1 = 5;
int vble2 = 3;
if (vble1 == vble2)
System.out.println("Las variables son iguales");
if (vble1 != vble2)
System.out.println("Las variables son distintas");
Permiten comprobar si un valor es mayor que (operador >), menor que (operador <), mayor o igual que (>=) y menor o igual que (<=).
Al final el operador lo valida entre dos valores o variables con la estructura:
vble1 > vble2
vble1 < vble2
vble1 >= vble2
vble1 <= vble2
De esta forma podemos tener un código fuente que nos ayude a realizar estas validaciones de relación:
int vble1 = 5;
int vble2 = 3;
if (vble1 > vble2)
System.out.println("La variable 1 es mayor que la variable 2");
if (vble1 < vble2)
System.out.println("La variable 1 es menor que la variable 2");
if (vble1 >= vble2)
System.out.println("La variable 1 es mayor o igual que la variable 2");
if (vble1 <= vble2)
System.out.println("La variable 1 es menor o igual que la variable 2");
Dentro de los operadores condicionales en Java tenemos:
| Operador | Descripción |
|---|---|
| && | Operador condicional AND |
| || | Operador condicional OR |
| ?: | Operador Ternario |
| instanceof | Operador instanceof |
La estructura de los operadores condicionales en Java es:
(expresion_booleana1 && expresion_booleana2)
(expresion_booleana1 || expresion_booleana2)
En el caso del operador condicional AND el resultado será true siempre y cuando las dos expresiones evaluadas sean true. Si una de las expresiones es false el resultado de la expresión condicional AND será false.
Para el operador condicional OR el resultado será true siempre que alguna de las dos expresiones sea true.
Los operadores booleanos funcionan mediante la evaluación por cortocircuito. Es decir, que dependiendo del valor de la expresión 1 puede que no sea necesario evaluar la expresión 2.
Para el caso del operador condicional AND, si la primera expresión es false ya devuelve false sin evaluar la segunda expresión. Y en el caso del operador condicional OR si la primera expresión es true ya devuelve true sin evaluar la segunda expresión.
Podríamos ver el uso de los operadores condicionales en el siguiente código:
int vble1 = 5;
int vble2 = 3;
if ((vble1 == 5) && (vble2 ==3))
System.out.println("Las dos variables mantienen sus valores iniciales");
if ((vble1 == 5) || (vble2 ==3))
System.out.println("Al menos una variable mantiene su valor inicial");
El operador ternario es otro de los operadores condicionales. Es una forma reducida de escribir un if-then-else. El operador ternario es representado mediante el símbolo ?:
La estructura del operador ternario es:
(expresion)?valor_true:valor_false;
En el caso de que la expresión tenga un valor de true se retorna el valor indicado después del cierre de interrogación (?) Y si la expresión tiene un valor de false se retorna el valor que esté después de los dos puntos (:).
El operador ternario se suele utilizar para decidir que valor asignar. Un ejemplo de código del operador ternario sería:
int vble1 = 5;
int vble2 = 4;
int mayor;
mayor = (vble1 > vble2)?vble1:vble2;
System.out.println("El mayor de los dos números es " + mayor);
Vemos que si la variable 1 es mayor que la variable 2 guardaremos el valor de la variable 1 en la variable mayor. En caso contrario se guardaría el valor de la variable 2, ya que en ese caso sería la mayor.
El operador instanceof es un operador especial para los objetos. Mediante el operador instanceof podemos comprobar si un objeto es de una clase concreta.
La estructura del operador instanceof es:
objeto instanceof clase
El operador instanceof devolverá true siempre y cuando el objeto sea del tipo clase o de alguna de las clases de las que herede.
Así podríamos definir una secuencia de clases:
class Poligono {}
interface Figura {}
class Triangulo extends Poligono implements Figura {}
Ahora definimos un par de objetos:
Poligono p = new Poligono();
Triangulo t = new Triangulo();
Podemos, mediante el uso del operador instanceof, comprobar que t es instancia de tipo Triangulo, Poligono y Figura. Mientras que p es instancia de tipo Polígono, pero no de Triangulo, ni Figura.
System.out.println("p es instancia de ");
if (p instanceof Poligono)
System.out.println("Poligono");
if (p instanceof Triangulo)
System.out.println("Triangulo");
if (p instanceof Figura)
System.out.println("Figura");
System.out.println("t es instancia de ");
if (t instanceof Poligono)
System.out.println("Poligono");
if (t instanceof Triangulo)
System.out.println("Triangulo");
if (t instanceof Figura)
System.out.println("Figura");