Transcript Operadores lógicos Short-Circuit

Sun Certified Java Programmer
(SCJP)
Capítulo 4: Operadores
Objetivo de certificacion
 Escribir código que use correctamente los
operadores incluyendo operadores de asignación
(=, +=, -=), operadores aritméticos (+, -, *, /, %, ++,
--), operadores relacionales (<, <=, >, >=, ==, !=), el
operador instanceof, operadores lógicos (&, |, ^, !,
&&, ||), y el operador condicional (? :), para
conseguir el resultado deseado.
 Escribir código que determine la igualdad de dos
objetos o dos datos primitivos.
Operadores de Asignación Compuestos
 Existen 11 operadores de asignación compuestos, pero
solo 4 son los más usados (+=, -=, *=, /=),
y = y - 6;
x = x + 2 * 5;
 Ahora, con operadores compuestos:
y -= 6;
x += 2 * 5;
Operadores de Asignación Compuestos
Relational Operators
 (<, <=, >, >=, ==, and !=).
 El resultado de evaluar un operador relacional
siempre es un valor booleano (true or false).
 Java tiene 4 operadores realcionales que pueden ser




utilizados para comparar cualquier combinación de integers,
floating-point numbers, o caracteres:
> mayor que
>= mayor que o igual a
< menor que
<= menor que o oigual a
Relational Operators
Cuando se compara un caracter con un caracter, o un caracter con un
número, Java usará el valor Unicode para la comparación.
Operadores de igualdad "Equality"
 == equals
 != not equals
 No se puede comparar tipos incompatibles.
 Hay 4 tipos diferentes de cosas que pueden ser comparadas:
 números
 caracteres
 booleanos
 Variables de referencia a Objetos
El operador == analiza el valor en la variable, en otras palabras ,el
patrón de bits.
Igualdad para variables de referencia
 JButton a = new JButton("Exit");
 JButton b = a;
 Después de correr este código las dos variables a y b
haran referencia al mismo objeto.
 Recuerda, el operador == busca los bits en la
variable, eso significa que si los bits de ambas
variables de referencia son idénticos entonces
ambos se referiran al mismo objeto.
Igualdad para enumeraciones
 Una vez que se ha declarado un enumeración esta no es
expandible.
 Durante la ejecución no hay manera de adicionar
constantes a la enumeración. Se puede usar el operador
== asi como el método equals() para determinar si dos
variables se refieren e a la misma constante de una
enumeración:
Comparación instanceof
 El operador instanceof es usado solo para variables de
referencia a objetos, y se puede utilizar para probar si
un objeto es de un tipo en particular. Por tipo se
conoce clase o tipo de interfaz—en otras palabras , si el
objeto referrido por la variable en el lado izquierdo del
operador pasa la prueba IS-A para la clase o interfaz
del lado derecho.
String s = new String("foo");
if (s instanceof String) {
System.out.print("s is a String");
}
Comparación instanceof
 Aún si el objeto que está siendo testeado no es una instancia del
tipo de clase, instanceof retornará verdadero si el objeto que esta
siendo comparado es compatible con el tipo del lado derecho.
 Ejemplo: probar un objeto para ver si este es una instancia de una
de sus subtipos, antes de intentar un "downcast":
 El uso de instanceof protégé al programa de intentar un
ilegal downcast.
 Se puede probar una referencia a un objeto contra su
propio tipo de clase, o cualquiera de sus superclases. Esto
significa que cualquier referencia a objeto será verdadero
si usa instanceof en comparación con Objejct:
 B b = new B();
 if (b instanceof Object) {
 System.out.print("b is definitely an Object");
}
 prints this: b is definitely an Object
Además es legal probar si null es una instancia de una clase.
Esto siempre será falso.
Operadores Aritméticos




+ addition
– subtraction
* multiplication
/ division
El operador Remainder (%)
Divide el lado operando izquierdo por el operando
derecho, y el resultado es el remanente:
int x = 15;
int y = x % 4;
The remainder is 3
Operador concatenación de String






String a = "String";
int b = 3;
int c = 7;
System.out.println(a + b + c);
String10 ?
String37 ?
Sin embargo, si se coloca parentesis alrededor de las dos
variables:
System.out.println(a + (b + c));
you'll get this: String10
Operador concatenación de String
 La regla para recordar es:
 Si uno de los operandos es un String, el operador + llega
a ser un operador de concatenación de String. Si ambos
operandos son números, el operador + será de adición.
 Finalmete, es legal utilizar el operador compuesto (+=)
con Strings:
 String s = "123";
 s += "45";
 s += 67;
 System.out.println(s);
Operadores de incremento y decremento
 ++ increment (prefix and postfix)
 -- decrement (prefix and postfix)
Nota que en la cuarta línea del programa el operador de incremento está después de
la variable players. Eso significa que se está utilizando el operador de incremento
postfix, el cual causa que la variable players se incremente por uno ,pero solo
después de que el valor de player se use en la expresión. Está será la salida del
programa:
players online: 0
The value of players is 1
The value of players is now 2
Operadores de incremento y decremento
"If 3 is equal to 2 OR 3 < 4"
Este código imprime: x = 3 y = 4
Conditional Operator
 El operador condicional es un operador ternario y es
usado para evaluar expresiones booleanas.
 x = (expresión booleana) ? valor asignado si es
verdadero: valor asignado si es falso
Operadores lógicos
 (&, |, ^, !, &&, and ||).
Bitwise Operators (Not on the Exam!)
byte b1 = 6 & 8;
byte b2 = 7 | 9;
byte b3 = 5 ^ 4;
System.out.println(b1 + " " + b2 + " " + b3);
Bitwise operators compara dos variables bit por bit, and return
variable whose bits have been set based on whether the two
variables being compared had respective bits that were either both
"on" (&), one or the other "on" (|), or exactly one "on" (^). By the
way, when we run the preceding code, we get 0 15 1
Short-Circuit Logical Operators
 && short-circuit AND
 || short-circuit OR
Estos son usados para enlazar pequeñas expresiones
booleanas con el fin de construir expresiones booleanas
más grandes.
Los operadores && y || evaluan solo valores booleanos.
Para que una expresión (&&) sea verdadera, ambos
operandos deben ser verdaderos.
Operadores lógicos Short-Circuit
 Un short-circuit && evalua primero el lado
izquierdo (operando uno), y si éste es falso, el
operador && no se molesta en analizar el lado
derecho de la expresión (operando dos) porque el
operando && ya conoce que no es posible que la
expresión completa sea verdadera.
Operadores lógicos Short-Circuit
 Si el primer operando en una operación OR es
verdadera, el resultado será verdadero, así el shortcircuit || no gasta tiempo en averiguar el lado
derecho de la operación. Si el primer operando es
falso, el short-circuit || debe evaluar el segundo
operando para ver si el resultado de la operación OR
será veradera o falsa.
 Presta atención al siguiente ejemplo:
Operadores lógicos (Not Short-Circuit)
 & non-short-circuit AND
 | non-short-circuit OR
 Estos operadores lógicos son usados al igual que
&& y ||, pero no son short-circuit porque evaluan
ambos lados de las expresiones siempre. Ellos son
ineficientes.
Operadores lógicos ^ and !
 ^ exclusive-OR (XOR)
 ! boolean invert
 El operador ^ (exclusive-OR) evalúa solo valores
booleanos. Revisa siempre ambos lados de la
operación.
 Para que una expresión que usa el operador
exclusive-OR (^) sea verdadera, exactamente un
operando debe ser verdadero—por ejemplo,
 System.out.println("xor " + ((2<3) ^ (4>3)));
produce la salida: xor false
Operadores lógicos ^ and !
El operador ! (boolean invert) retorna el valor
booleano opuesto al actual:
• if(!(7 == 5)) { System.out.println("not equal"); }
Puede ser leído "if it's not true that 7 == 5," y produce
la salida: not equal