Bueno aqui seguiremos con la parte de los operadores de Java, donde retomaremos los Relational Operators (Operadores relacionales) y los Logical Operator (Operadores lógicos). Ya en la tercera parte trataremos el tema de las cadenas de caracteres o String.
Dicho esto pongamonos manos a la obra con una introducción y profundizando un poco mas con ejemplos.
Relational Operators (Operadores relacionales)
Los operadores relacionales devuelven valores booleanos según la evaluación de los operandos a su izquierda y a su derecha. Existen 6 operandos que podremos encontrar en el examen, 4 de ellos están relacionados con las comparaciones “mayor que” y “menor que”. Los otros 2 estñan relacionados estrictamente a la igualdad como veremos al final de esta sección.
Basic Relational Operators
- < Less than (Menor que)
- <= Less than or equal (Menor o igual que)
- > Greater than (Mayor que)
- >= Greater than or equal (Mayor o igual que)
Los operadores “menor que”, “mayor que”, “menor o igual que” y “mayor o igual que” son usados para comparar integers, float y characters. Cuando la expresión usada con el operador es true, retorna true, sino, retorna false.
//Retorna true ya que 1 es menor que 2 boolean b1=1<2; //Retorna false ya que 3 no es menor que 2 boolean b2=3<2; //Retorna true ya que 3 es mayor que 2 boolean b3=3>2; //Retorna true ya que 2 es menor o igual que 2 boolean b4=2<=2; //Retorna false ya que 2 no es mayor o igual que 3 boolean b5=2>=3;
Hasta aquí hemos examinado comparaciones con datos de tipo int. Vamos a ver como pueden evaluarse el tipo char. Hay que recordar que estos caracteres aceptan enteros (con rango válido de 16 bit sin singo), hexadecimal, octal y caracteres literales. Cada literal de los siguientes ejemplos representan las letras “A” y “B” respectivamente. El operando de la izquierda será “A” y el de la derecha será “B”.
boolean b1='A'<'B'; //Caracter boolean b2='u0041'<'u0042'; //Unicode boolean b3=0x0041<0x0042; //Hexadecimal boolean b4=65<66; //Enteros boolean b5=0101<0102;//Octal boolean b6='A'<0102; //Caracter y Octal
También podemos ver y probar las relaciones con los tipo float:
boolean b1= 9.00D<9.50D; boolean b2= 9.00d<9.50d; boolean b3= 9.00F<9.50F; boolean b4= 9.0f<9.50f; boolean b5= (double)9< (double)10; boolean b6= (float)9= (float)10; boolean b7= 9<10; boolean b8= (9d<10f); boolean b9= (float)11<12;
Equality Operator (Operadores de igualdad)
Son operadores relacionales que comparan la igualdad entre 2 operandos de tipos de dato primitivos (numbers, characters, booleans).
- == Equal to (Igual que)
- != Not equal (Distinto de)
Comparar datos primitivos del mismo tipoe s sencillo. Si el operando de la derecha y de la izquierda son iguales, el operador retornará true, de lo contrario, retornará false.
int value=12;
System.out.println(true==true); //true
System.out.println('a' != 'a'); //false
System.out.println((byte)value==(byte)value); //true
System.out.println((short)value != (short)value); //false
System.out.println(value==value); //true
System.out.println(12F==12f); //true
System.out.println(12D != 12d); //false
Los valores de referencia de un objeto tambien pueden ser comparados:
Object a= new Object(); Object b= new Object(); object c=b;
La referencia a las variables son a, b y c. Como se muestra, a y b son únicas. C tiene como referencia la variable b, así que en propósitos de igualdad, son iguales.
//Con operador de "Igual que" o "Equal to" System.out.println(a==b); //false System.out.println(a==c); //false System.out.println(b==c); //true //Los siguientes usan el operador "Distinto de" o "Not Equal" System.out.println(a !=b); //true System.out.println(a !=c); //true System.out.println(b !=c); //false
Logical Operators (Operadores lógicos)
Los operadores lógicos o logical operators retornan valores booleanos. Hay 3 operadores lógicos en el examen de certificación, AND, OR y negación lógica o !.
Logical(Conditional) Operators
- && AND
- || OR
El operador AND evalúa los operandos de la derecha e izquierda. Si ambos valores tienen valor de true, entonces retornará true. Se considera que es un operador “short-circuits”. Estoe s debido a que si el operador evalúa el operando de la izquierda y este es falso, entonces no se comprueba el operando de la derecha, ya que ambos deben ser true para retornar true.
boolean and1=true && true; //true boolean and2=true && false; //false, se evalúa el operando de la derecha boolean and3=false && true; //false, no se evalúa el operando de la derecha boolean and4=false && false; //False, no se evalúa el operando de la derecha
EL operador lógico OR evalúa los operandos de la derecha y d ela izquierda. Si uno de los 2 operandos es verdadero, el operador OR retornará true:
boolean or1= true || true; //true boolean or2= true || false; //true boolean or3= false || true; //true boolean or4= false || false; //false
Logical Negation Operator (Operador de negación lógica)
El Logical Negation Operator es también conocido como operador de inversion o operador booleano invertido. Es un operador simple, pero no por ello debemos tomalo a la ligera.
- ! Logical Negation
System.out.println(!false); //true System.out.println(!true); //false System.out.println(!!true); //true System.out.println(!!!true); //false System.out.println(!!!!true); // true
Espera ver el operador de negación lógica usado en conjunción con algún método o expresión que retorna valores Booleanos.
- Expresiones con operadores erlacionales retornan valores Booleanos
- Expresiones con operadores lógicos retornan valores Booleanos
- El método equals de la clase Object retorna valor Booleano
- El método de String startsWith y endsWith retorna valor Booleano
Aqui veremos algunos ejemplos que incluyen el operador de negación:
// Ejemplo con expresión relacional
iVar1=0;
iVar2=1;
if(!(iVar1<=iVar2)){
}
// Ejemplo con expresiones lógicas
boolean bVar1=false;
boolean bVar2=true;
if(bVar1 && bVar2 || (!(bVar1 && bVar2))){
}
// Ejemplo con equals
if(!"Name".equals("NAME")){
}
//Ejemplo con la clase String
String s="Captain Jack";
System.out.println(!s.startsWith("Captain");
EL Negation Logical Operator no puede ser usado con valores que no sean booleanos!
Hasta aqui ya hemos tocado un poco todos los operandos que nos hacían falta y que mas usaremos, y que deberemos de dominar bien. En la siguiente parte zanajremos el Capitulo con métodos en la clase String, que es bastante interesante.
Cualquier ayuda, corrección o colaboración es bienvenida
Saludos!!!