Sun Certified Java Programmer (SCJP)

Capítulo 4: Operadores

Objetivo de certificacionEscribir 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 CompuestosExisten 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

Cuando se compara un caracter con un caracter, o un caracter con un número, Java usará el valor Unicode para la comparación.

Relational Operators

Operadores de igualdad "Equality" == equals != not equalsNo se puede comparar tipos incompatibles.Hay 4 tipos diferentes de cosas que pueden ser

comparadas: números caracteresbooleanos 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 referenciaJButton 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 enumeracionesUna 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 instanceofEl 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");}

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":

Comparación instanceof

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 StringString 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

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);

Operador concatenación de String

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: 0The value of players is 1The value of players is now 2

"If 3 is equal to 2 OR 3 < 4"Este código imprime: x = 3 y = 4

Operadores de incremento y decremento

Conditional OperatorEl 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-CircuitUn 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.

Si el primer operando en una operación OR es verdadera, el resultado será verdadero, así el short-circuit || 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 Short-Circuit

Operadores lógicos (Not Short-Circuit)& non-short-circuit AND | non-short-circuit OREstos 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 invertEl 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

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

Operadores lógicos ^ and !