(OCA Objectives 3.1, 3.2, and 3.3)

En el capitulo 3 ya se cubrió la mayor parte de la funcionalidad del operador de asignación (=). Para resumir:

• Cuando se asignan valores a un primitivos, los tamaños deben coincidir. Asegúrate de que sabes donde tiene lugar un casting implícito, donde es necesario un casting explicito y donde se va a producir truncamiento.
• Recuerda que las variable de referencia no son objetos, es la forma de obtener un objeto.
• Cuando asignes un valor a una variable de referencia, los tipos deben coincidir. Recuerda las reglas para los supertipos, subtipos y arrays.

Existen 11 pero solo 4 son las mas usados en el examen (+=, -=, *=, y /=)

y -= 6;
x += 2 * 5;

Siempre que se use un operador de asignación compuesto los cálculos para obtener su total se hará de derecha a izquierda es decir, primero se realizarán los cálculos a la derecha del símbolo = y luego el calculo del operador compuesto, por ejemplo:

x *= 2 + 5; no es igual a esto x = (x * 2) + 5; su calculo correcto es x = x * (2 + 5);

Se cubrirán seis operadores relaccionales (<, <=, >, >=, ==, y !=). El resultado de estos operadores siempre es un valor boolean (true o false) .

Java tiene cuatro operadores que pueden ser usados para comparar combinaciones de enteros, números en punto flotante y characters:

• Greater than >
• Greater than or equal to >=
• Less than <
• Less than or equal to <=

Cuando se comparen un caracteres entre si o un carácter con un numero, java usara su valor unicode para ello.

Java tiene dos operadores relacionales (también llamados operadores de igualdad) que comparan dos cosas similares y devuelven un blooean true si son iguales. Estos son:

• == Equal (also known as equal to)
• != Not equal (also known as not equal to)

Dichos operadores actúan sobre:

• Numbers
• Characters
• Boolean primitives
• Object reference variables

Qué evalúan exactamente estos operadores? El valor de la variable bit a bit.

class ComparePrimitives {
  public static void main(String[] args) {
    System.out.println("char 'a' == 'a'? " + ('a' == 'a'));
    System.out.println("char 'a' == 'b'? " + ('a' == 'b'));
    System.out.println("5 != 6? " + (5 != 6));
    System.out.println("5.0 == 5L? " + (5.0 == 5L));
    System.out.println("true == false? " + (true == false));
  }
}

char 'a' == 'a'? true
char 'a' == 'b'? false
5 != 6? true
5.0 == 5L? true
true == false? false

NOTA: El resultado de una asignación boolena es siempre el valor boleano asignado

11. boolean b = false;
12. if (b = true) { System.out.println("b is true");
13. } else { System.out.println("b is false");  }
.......
15. boolean b1 = false; int i1 = 2; int i2 = 3;
16. if (b1 = i1 == i2){ System.out.println("true"); } 
17. else{    System.out.println("false"); }

Para el primer bloque if, su salida será: "b is true", ya que se produce la asignación de la variable y posteriormente la lectura de ella. Para el segunfo bloque if, se mostrará por pantalla "false" ya que se evaluará como b1 = (i1 == i2) dado que el operador == tiene precedendia sobre =

Recuerda que == compara bit a bit el valor de las variables por tanto dado el siguiente código:

JButton a = new JButton("Exit");
JButton b = new JButton("Exit");
JButton c = a;
System.out.println("Is reference a == b? " + (a == b));
System.out.println("Is reference a == c? " + (a == c))

Obtendremos como resultado:

Is reference a == b? false
Is reference a == c? true

Podemos ver que A y C tiene la misma referencia, por tanto, son iguales, == no comprueba si dos objetos con equivalentes ( de eso se encarga equals())

Utilizamos == para determinar si dos variables de referencia se refieren al mismo objeto. Dado que los objetos son el centro de Java, todas las clases en Java heredan un método de la clase Object que comprueba si dos objetos son "iguales". El método es equals(). El método equals es usado para determinar si dos objetos de la misma clase son significativamente equivalente. Para las clases que se crean existe la posibilidad de sobreescribir el método equals() que heredan las nuevas clases y crear tu propia implementacion de equals para las instancias de las nuevas clases.

El método equals en la clase objetc funciona de la misma manera que el operador ==. Si dos referencias apuntan al mismo objeto, el método equals devuelve true. Si dos apuntan a diferentes objetos, aunque ellos tengan los mismos valores, el método devolverá false.

El método equals en la clase String esta sobreescrito. Cuando se usa el método equals para comparar dos String, este devuelve true si los dos strings tienen el mismo valor o false si tienen diferentes valores. El método equals en String es case sensitive.

Metafora: Meet Jourman

Una vez declarado un enum, este no es ampliable. En tiempo de ejecución, no hay manera de añadir constantes adicionales a la enumeración. Para comparar enums se puede usar tanto == como el método equals para determinar si dos variables distintas se refieren a la misma constante de la enumeración, por tanto, para el siguiente fragmento de código, la respuesta es true a las dos comparaciones:

Color c1 = Color.RED;  Color c2 = Color.RED;
if(c1 == c2) { System.out.println("=="); }
if(c1.equals(c2)) { System.out.println("dot equals"); }

El operador instanceof es usado solo para variables de referencia de objetos, y se usa para comprobar si un objeto es de un tipo particular. Entendiendo como tipo, la clase o la interfaz, en otras palabras comprobamos si la varable en el lado izquierdo pasa el test IS-A para la clase o interfaz del lado derecho. Ejemplo de uso:

String s = new String("foo");
if (s instanceof String) {
   System.out.print("s is a String");
}

Incluso si el objeto a comprobar no es una instancia del tipo de de la clase del lado derecho, instanceof devolverá true si el objeto con el que estamos comparando es compatible con el tipo de la derecha. Es decir, comprueba supertipos del objeto con el tipo de la clase del lado derecho del operador. Esto se puede usar para proteger a nuestro programa de downcast que pueden romper el hilo de ejecución.

tambien devuelve true en caso de implemenaciones de interfaces indirectamente:

interface Foo { }
class A implements Foo { }
class B extends A { }
...
A a = new A();
B b = new B();
// the following are true
a instanceof Foo 
b instanceof A
b instanceof Foo  // implemented indirectly

Tambien es posible usar el valor null junto con el operador instanceof, y siempre devolverá false, por ejemplo:

class InstanceTest {
   public static void main(String [] args) {
      String a = null;
      boolean b = null instanceof String;
      boolean c = a instanceof String;
      System.out.println(b + " " + c);
   }
}

Salida: false false

No se puede utilizar el operador instanceof para comprobar dos jerarquias de clases distintas. El siguiente codigo fallará al compilarlo:

Dog d = new Dog();
System.out.println(d instanceof Cat);

###Resumen: Dadas las siguientes clases e interfaz.

interface Face { }
class Bar implements Face{ }
class Foo extends Bar { }

Los operadores aritméticos son: +, -, *, /

%, realiza la operacion de división entre los dos operandos y devuelve el resto de la división.

El signo de mas +, puede usarse también para concatenar dos String animal = "Gray " + "elephant";

Consideranciones al concatener String e int:

• Al concatenar "String" + 3 + 7, la salida será -> String37. Los valores int se considerean characteres simplemente.
• Si usamos los parentesis podemos alterar el resultado, "String" + (3 + 7), la salida será -> String10, primero se realiza la operacion entre parentesis y luego se concatena con el String
• Si cambiamos el orden, y avanzamos los int, estos se sumaran y luego se concatenaran al string, 3 + 7 + "String" -> 10String

Java tiene dos operadores que incrementan y decrementan la variable en una unidad exactamente, estos son ++ y --. Estos operadores se pueden usar tanto de prefijo como de sufijo. Usarlos de sufijo o prefijo varia el resultado:

• Sufijo x++ : se usa el valor de x y luego se incrementa su valor en uno.
• Prefijo ++x: incrementara su valor en una unidad antes de ser usado.

NOTA: no se puede usar cualquiera de estos operadores con una variable final, final int x = 1; ya que la variable es final y no puede cambiar su valor, si lo hacemos el código no compilará.

El operador condicional es un operador ternario (tiene tres operando) y se utiliza para evaluar expresiones booleanas, al igual que una sentencia if, excepto que en lugar de ejecutar un bloque de código, si la evaluación es true se asignará un valor a una variable. Este operador se construye usando ? y : de la siguiente forma: x = (boolean expression) ? value to assign if true : value to assign if false

Los objetivos del examen especifican seis operadores lógicos (&, |, ^, !, &&, y || ). Tres de ellos no se evalúan para el examen de Java 6 y Java 7, (&, |, ^)

cinco son los operadores que se usan en el examen para evaluar los estados de una expresión boleana. Los dos mas comunes son los operadores lógicos de short-circuit.

• && Short-circuit AND
• || Short-circuit OR

Se utilizan para enlazar pequeñas expresiones booleanas. Evalúan solo valores boleanos. Los Short-Circuit se conoces así porque no continúan evaluando si la primera condición no se cumple, es decir, para un AND (&&), si el resultado de la primera evaluación es false, no se comprueba el lado derecho de la expresión, ya que no importa su valor porque el resultado de la expresión global va a ser false. Por ejemplo, para boolean b3 = (false == true) && (b2 = true); nunca se comprobara (b2 = true).

Para el operador OR (||) ocurre algo similar, si el primer resultado del operando de la izquierda es TRUE, no se continua evaluando ya que el resultado global va a ser true.

Existen dos operadores lógicos no short-circuit:

• & Non-short-circuit AND
• | Non-short-circuit Estos operadores se usan de igual forma que los anteriores, pero al contrario que estos, los operadores lógicos not short-circuit siempre evalúan ambos lados de la expresión.

• ^ Exclusive-OR (XOR)
• ! Boolean inver

El operador ^(exclusive or) evalúa solo valores bolenanos, esta relacionado con los operadores not short-circuit. Un XOR será true su valor siempre que, exactamente un operando sea true.

El operador !, (inversión boleana) devuelve el valor opuesto al actual valor boleano.