Operadores logicos.

El examen cubre 6 operadores logicos (&,&&,|,||,^,!)
La mayoria de los operadores logicos trabaja con dos expresiones boleanas(excepto !)
Los operadores && y & deben regresar verdadero solo si ambas expresiones son verdaderas.
Los operadores || y | deben regresar verdadero si solo una de sus expresiones es verdadera.
Los operadores || y && son conocidos como operadores "short-circuit".
Si el operador || encuentra la primera expresion como verdaera ya no verifica la segunda por que a webos la expresion es verdadera.
Si el operador && encuentra la primera expresion como falsa ya no verifica la segunda por que a webos la expresion es falsa.
Los operadores & y | evaluan siempre las dos expresiones.
El operador "^" (XOR) toma la expresion como verdadera si SOLO una de ellas es verdadera.
El operador ! regresa el valor opuesto de la expresion.

Operador terciario :D

Regresa dos posibles valores dependiendo de si una empresion booleana es verdadera o falsa.
regresa la expresion despues de ? si la expresion es verdadera.
regresa la expresion despues de : si la expresion es falsa.

ejemplo:

String a = (x>7) ? "si" : "no";

Operadores de incremento/decremento

Los operadores "--" y "++" si se usan como prefijos se ejecutan antes de que la sentencia se lleve a cabo.
Los operadores "--" y "++" si se usan como sufijos se ejecutan despues de que la sentencia se lleve a cabo.
Ambos operadores son completamente evaluados antes de que el operador es aplicado.
Una variable final no puede usar los operadores "++" ni "--".

Operador de concatenacion de Strings

Si solo uno de los operadores es un string el operador "+" concatena el string.
Si todos los operadores son numeros el operador "+" suma los numeros.

Operadores Aritmeticos

Hay 4 operadores matematicos primarios, suma(+),resta(-), multiplicacion(*) y division(/).
El operador residuo (%), nos devuelve el residuo de una division.
Los operadores son analizados de izquierda a derecha, al menos que tengan paretesis o que existan algunos operadores que tengan una precedencia mas alta que otra.
Los operadores *,/,% tienen una precedencia mas alta que +,-.

Operador instanceOf

Instance of se usa solo con variables de referencia y verifica si objeto es de un tipo especifico.
El operador instanceOf solo lo podemos usar para checar objetos(o null(siempre falso)) que se encuetran dentro del mismo arbol jerarquico.
Por el lado de las interfaces, un objeto pasa el instanceOf de "x" interfaz si implementa "x" o si cualquiera de sus padre implementan "x".

Operadores relacionales

El resultado de los operadores relacionales siempre es un valor booleano (true o false).
Existen 6 operadores delacionales (<,<=,>,>=,==,!=), los ultimos dos son comunmente llamados operadores de igualda.
Cuando comparas caracteres, java utiliza el valor 'unicode' de los caracteres como un valor numerico.
hay dos operadores de igualdad (==, !=)
cuatro tipos de cosas pueden ser probadas usando los operadores relacioneles(numeros, booleanos, caracteres y referencias a variables)
Cuando comparas dos referencias a variables regresa "true" solo si las dos referencias refieren al mismo objeto.

Recolector de Basura. (Garbage Collector)

Java prove un manejo de memoria automatico mediante el recolector de basura(GC).
Solo la JVM es la que decide cuando llamar al GC, nosotros solo podemos sugerirle que lo haga.
No podemos estar seguros de cual es el algoritmo del GC
Los Objetos deben de ser considerados elegible antes de que sean "tirados" por el GC.
No podemos estar seguros de como funciona el algoritmo del GC
Un objeto es elegible cuando ningun hilo(Thread) vivo puede accesar a el.
Para alcanzar un objeto deben tener una referencia viva que apunte hacia ese objeto.
Las aplicaciones en java pueden quedarse sin memoria disponible.
Haces una peticion al garbage collector con System.gc(); (solo antes de java 6)
La clase objeto tiene un metodo finalize().
El metodo finalize() solamente se ejecuta una vez por objeto, solo una vez jeje por lo mucho.
El GC no garantiza que el metodo finalize de todos los objetos se ejecute, este puede no llamarce nunca.
Puede hacer que un metodo no sea elegible para el garbage collectos si usas el metodo finalize() y este no corre(recordemos que el metodo finalize, te hae caso cuando se le pega la gana).

Overloading avanzado.

El "widening" de primitivos usa el metodo con el argumento mas pequeño que pueda ser usado.
Usados de forma individual el "boxing" y el "var-args" son compatibles con metodos sobrecargados.
No de puede hacer el widden, de una clase wrapeada a otra(la prueba IS-A falla).
No se puede hacer un "widen" y despues un "box"(un int no puede convertirse en Long).
Si se puede hacer el "box" y despues el "widen"(un int puede convertirse en Object)
No se puede convinar el var-args ni con "widening" ni con "boxing"

Boxing...

A aprtir de java 5 se puede convertir primitivos en "Wrapers" y "Wrapers" en primitivos automaticamente
usar "==" con "Wrapers" creados mediante "Boxing" es un poco tramposo, aquellos con los mismo valores que sean pequeños(tipicamente valores menores a 127) si son ==, los que son maoyres a estos nos son...

Uso de "Wrapers"

Las clases "Wraper" son equivalentes a los tipos primitivos
los "Wrapers" tienen dos funciones principales:

Envolver primitivos, para que puedan ser usados como objetos

Proveer varios metodos utiles para los primitivos

Existen tres metos principales para los "Wrappers"

xxxValue() no tiene argumento, regresa un primitivo

parseXxx(String st)tiene un String como argumento, regresa un primitivo

valueOf(String st) toma como argumento un String, regresa un "Wrapper"

Los costructores de "Wrapers" toman un String o un primitivo como argumento, excepto por el de Character, que toma solo un cha.
Radix se refiere a la base, normalmete diferente a 10 por ejemplo 8 o 16

Bloques de inicializacion.

Los bloques estaticos de inicializacion corren una vez, cuando la clase es cargada.
Los bloques de inicializacion de instancia corre cada vez que una instancia es creada. correan despues de todos los supercostructores ya antes de los constructores.
Si existen multiples bloques de inicializacion siguen las reglas de arriba, pero el criterio de desempate entre estos es el orden en el que esten.

Declaraccion, construccion e inicializacion de un arreglo

Los arreglos pueden contener datos primitivos u objetos, pero en si mismos ellos son un objeto.
cuando declaras un arreglo, los corchetes pueden estar a la derecha o a la izquierda del nombre del arreglo.
Nunca se puede inclir el tamaño del arreglo en la declaracion de este.
Debes de declarar el tamaño de este cuando llames al costructor con la palabra new, a menos que crees un arreglo anonimo.
Los elementos dentro de un arreglo no son creados automaticamente, aunque si el arreglo es de primitivos si se les pone el valor de default.
Obtienens un NullPointerException si tratas de acceder a un elemento que no no refiere a un objeto real.
El indice de los arreglos comienza con 0(cero,zero,xrous,zetsfvddfffnfjbsfdchjvdptm)
Un IndexOutOfBoundException ocurre cuando utilizas un indice incorrecto(como negativo o mayor o igual que el numero de elementos que contiene)
Los arreglos tienen una variable lenght que nos dice el numero de elemento que tiene el arreglo.
El ultimo index qque puedes accesar es uno menos que el valor del arreglo.
Arreglos multidimencionales son simplemente arreglos de arreglos.
Las dimenciones en un arreglo multidimencional pueden tener diferentes tamaños.
Un arreglo de primitivos puede aceptar cualquier valor que pueda ser automaticamente promovido al tipo de dato del arreglo.
Un arreglo de objetos puede acepara cualquier valor que pase la prueba IS-A con respecto a el tipo de daro del objeto.
Si asignas un arreglo a otro, ambos arreglos deben de tener las mismas dimensiones para que la asignacion sea exitosa.
Puedes asignar un arreglo a otro que sea un un supertipo del arreglo que estas asignando(por ejemplo puedes asignar un Honda[] a un Car[])

Pasar variables a metodos...

Los metodos pueden usar valores primitivos o referencia a objetos como argumentos.
Los argumentos de los metodos siempre son copias.
Los argumentos de los metodos nunca son Objetos, son referencias a objetos.
Un argumento primitivo es una copia del argumento original.
Un argumento de referencia es una copia de la referencia de otra variable de referencia.
Shadowing es cuando dos variable que estan en diferentes "scopes" tienen el mismo nombre, esto hace que la variable con el "scope" actual oculte al de scope mas amplio.

Usar una variable o un elemento de un Arreglo que no ha sido inicializada ni asignada

Cuando un arreglo de objetos es instanciado, los elementos del arreglo no son creados automaticamente, sin embargo todas la referencias obtienen el valor de null.
Cuando un arreglo de primitivos es instanciado de llena con los valores de default.
LAs variables de instancia son siempre inicializadas con sus valores de default.
LAs variables locales, tambien llamadas automaticas o de metodos nunca se inicializan con sus valores de default, por lo tanto si tratamos de usar una que no este inicializada nos manda un error el compilador.

Asignaciones Basicas.

Las literales enteros son implicitamente int.
Las expresiones con integer siempre regresan resultados de tamaño int, nunca menores.
Los puntos flotantes son explicitamente doubles.
Guardar un primitivo en un tipo de dato mas pequeño, siempre resulta en que se truncan los bits.
Las asignaciones compuestas(ej: +=) siempre resultan en un casting automatico.
Una variable de referencia guarda los bits que son usados para referir al objeto.
Las variables de referencia pueden referir a subclases del tipo de objeto que esta guardando pero nunca a superclases.
Cuando creas un nuevo objeto pasan 3 cosas(Ejemplo Button b = new Button() ).

Crea una variable de referencia llamada b, de tipo Button.

Crear un buvo objeto Button

Asignar la referencia b al recien creado objeto de tipo Button

Scope

El scope(alcanze), se refiere al tiempo de vida de las variables.
Ecisten basicamente 4 tipos de Scope

Las variables estaticas que viven tanto como vivan las clases

Las variables de instancia que viven el tiempo que sus objetos viven

Las variables locales viven el tiempo que su metodo este en el stack, aunquee si su metodo invoca a otro metodo, estas variable no estaran disponibles temporalmente

Las variables de bloque, existen el tiempo que su bloque tarde en terminarse

Casting Literal y Primitivo

Las literales de tipo Integer pueden ser octal (ej:019) o Exadecimal (ej 0X3A7)
Las literales para ong terminan en L o l.
Las literales float Terminan en F o f y las double terminan en D o d.
LAs literales para Boolean son "true" o "false"
Las literles para char deben de estar entre comilla simples (ej: 'c')

Stack y Heap

Las variables locales viven en el Stack.
Los objetos y sus variables de instancia viven en el Heap.

Notas Mentales(no es parte de el orden original)

xxxValue() //Regresa un primitivo de un objeto "wrapeado"
parseXxx(String st) //Regresa un primitivo de un objeto "wrapeado"
valueOf(String st) //Regresa un objeto de un dato primitivo.

El compilador escoge hacer un Widening antes de hacer unBoxing.

Una de las reglas mas importantes es que las cosas que ya existian(como en widening), sobre las nuevas caracteristicas de java 5(como el Boxing o el Var-args...)

Ninguna de las clases wrapeadas puede hacer el boxing, por que un Short is NOT a Integer.

Boxing --THEN----> Widening Esta BIEN.
Widdening --THEN-> Boxing Esta MAL

Un objeto es eligible para que lo mande a chingar a su madre el garbage collector cuando ningun hilo(Thread) vivo, puede accesar a el..