Asignaciones

lunes, 27 de julio de 2009 by Matías Emiliano Alvarez Durán

A continuación dejo el resumen del tercer capítulo (Assignments) del libro "Sun Certified Programmer for Java 6 Study Guide".

Stack y Heap:

Las variables locales (variables declaradas dentro de los métodos) se almacenan en el stack.
Los objetos y sus variables de instancia se almacenan en el heap.

Literales y conversión (casting) de tipos primitivos (Objetivo 1.3):

Los literales enteros pueden ser decimales, octales o hexadecimales.
Los literales octales comienzan siempre con un cero.
Los literales hexadecimales comienzan siempre con 0x ó 0X.
Los literales para los tipos long debe terminar con la letra L o l.
Los literales float deben terminar en F o f, los double con el dígito D, d o sin ningún sufijo (ya que son double por defecto).
Los literales boolean son true y false.
Los literales para el tipo char son un simple carácter dentro de comillas 'q' o el valor Unicode de una letra '\u004E' (la letra 'N').

Ámbito (Objetivos 1.3 y 7.6):

El ámbito se refiere al tiempo de vida de una variable.
Existen cuatro tipos básicos de ámbito:
- Variables estáticas viven durante el tiempo que sus clases se encuentran cargadas en la JVM.
- Variables de instancia viven durante el tiempo que viven sus objetos.
- Variables locales viven durante el tiempo en que su método es ejecutado, si su método invoca otro método, estas variables son temporalmente inaccesibles.
- Variables de bloque (for, if, while) viven hasta que el bloque de código se completa.

Asignaciones básicas (Objetivos 1.3 y 7.6):

Los literales de números enteros son implícitamente del tipo int.
Las expresiones y operaciones con valores enteros (de cualquier tipo entero) siempre retornan un valor de tipo int.
Los números de punto flotante son implícitamente del tipo double (64 bits).
La reducción de un tipo primitivo implica el truncamiento de los bits de orden más altos (bits de más a la izquierda).
Las asignaciones compuestas (+= ó -=), realizan una conversión automática.
Una variable de referencia almacena los bits que son utilizados para apuntar a un objeto.
Las variables de referencia pueden apuntar a subclases del tipo declarado, pero no a una superclase.
Cuando se crea un objeto nuevo, (Button b = new Button();) suceden tres cosas:
- Se crea el nombre de una variable de referencia (b) de un tipo (Button).
- Se crea una nueva instancia de una clase (de tipo Button).
- Se asigna el objeto instanciado (de tipo Button) a una variable de referencia (b).

Utilización de variables o elementos (de un arreglo) que no están inicializados y tampoco asignados (Objetivos 1.3 y 7.6):

Cuando un arreglo de objetos esta inicializado, los objetos que lo componen no se instancian automáticamente, pero todas las referencias poseen el valor por defecto null.
Cuando un arreglo de tipos primitivos se inicializa, se asignan a sus elementos los correspondientes valores por defecto.
Las variables de instancia siempre se inicializan con su valor por defecto.
Las variables locales (también denominadas automáticas o de métodos) nunca se inicializan por defecto. Si se intentan utilizar antes de ser inicializadas, se obtendrá un error de compilación.

Pasando variables hacia métodos (Objetivo 7.3):

Los métodos pueden tomar primitivas y/o referencias a objetos como argumentos.
Los argumentos de un método siempre son copias.
Los argumentos de un método nunca son objetos, si no referencias a estos.
Un argumento de tipo primitivo es una copia (desenlazada de la variable original) del valor de otra.
Un argumento de referencia es una copia del valor de referencia de otra variable.
El ocultamiento (o shadowing) ocurre cuando dos variables con diferente ámbito comparten el mismo nombre.

Declaración de arreglos, construcción e inicialización (Objetivo 1.3):

Los arreglos pueden contener primitivas u objetos, pero el arreglo en sí mismo es siempre un objeto.
Cuando se declara un arreglo, los corchetes pueden ir a la izquierda o derecha del nombre.
No se puede incluir el tamaño del arreglo, en la declaración del mismo.
Siempre se debe incluir el tamaño de un arreglo cuando se instancia (utilizando la palabra clave new), salvo que se esté creando un arreglo anónimo.
Los elementos de un arreglo de objetos no son instanciados automáticamente (contiene todas sus referencias en null), aunque un arreglo de tipo primitivo si proporciona los valores por defecto a sus elementos.
La excepción NullPointerException es lanzada si se intenta utilizar un elemento del arreglo que aún no haya sido asignado.
Los arreglos son indexados comenzando desde el valor cero.
La excepción ArrayIndexOutOfBoundsException es lanzada si se utiliza un valor de índice incorrecto.
Los arreglos poseen la variable length la cuál contiene el número de elementos del mismo.
El último índice al que se puede acceder es siempre uno menos que la cantidad de elementos del arreglo.
Los arreglos multidimensionales son arreglos de arreglos.
Las dimensiones en un arreglo multidimensional pueden tener diferentes tamaños.
Un arreglo de tipo primitivo puede aceptar cualquier valor que pueda ser promovido implícitamente al tipo del arreglo. (Por ejemplo un valor de tipo byte puede almacenarse en un arreglo de tipo int).
Un arreglo de objetos puede contener cualquier objeto que cumpla la relación ES-UN (o instanceof) con el tipo del arreglo. (Por ejemplo si Horse extiende de Animal, un arreglo de tipo Animal puede almacenar un objeto Horse).
Si se asigna un arreglo a una referencia ya declarada, el nuevo arreglo debe ser de la misma dimensión de la referencia del arreglo anterior.
Se puede asignar un arreglo de un tipo, a una referencia ya declarada de un arreglo de un supertipo. (Por ejemplo, si Honda extiende de Car, un arreglo de objetos Honda puede ser asignado a un arreglo declarado de tipo Car).

Bloques de inicialización (Objetivo 1.3 y 7.6):

Los bloques de inicialización estática se ejecutan solo una vez, cuando la declaración de la clase es cargada.
Los bloques de inicialización de instancia se ejecutan cada vez que se crea un nuevo objeto. Se ejecutan luego de los constructores de las clases padres y antes del constructor de la clase actual.
Si en una clase existen múltiples bloques de inicialización, estos se ejecutan en el orden en el que aparecen en el código fuente.

Utilizando envoltorios (Wrappers) (Objetivo 3.1):

Las clases envoltorio (wrapper) están correlacionadas con los tipos primitivos.
Los wrappers tienen dos funciones principales:
- Envolver a los tipos primitivos, para que puedan ser manejados como objetos.
- Para proveer métodos de utilidad para los tipos primitivos (generalmente conversiones).
Las tres familias de métodos más importantes son:
- xxxValues(): No toma argumentos, devuelve el primitivo.
- parseXxx(): Toma un String, retorna el primitivo, y puede lanzar la excepción NumberFormatException.
- valueOf(): Toma un String, retorna el objeto envoltorio, y puede lanzar la excepción NumberFormatException.
Los constructores de las clases envoltorio pueden tomar como argumento un tipo String o un primitivo, salvo Character, el cual solo puede tomar el tipo primitivo char.
El parámetro opcional Radix se refiere a las bases de los números (por defecto es decimal = 10), pueden ser octal = 8, hexadecimal = 16, etc.

Boxing (Objetivo 3.1):

El mecanismo boxing permite convertir tipos primitivos a envoltorios y envoltorios a primitivos automáticamente.
Para los tipos de envoltorio Boolean, Byte, Character, Short e Integer el operador == sirve para comparar sus valores. Esto se debe a que se realizan las conversiones automaticamente a los tipos primitivos para realizar las comparaciones.
Para los demás tipos de envoltorios (Long, Float y Double) el operador == se utiliza para comparar las referencias a objetos. Para comparar sus valores, se debe utilizar el método equals().

Sobrecarga avanzada (Objetivos 1.5 y 5.4):

"Widening conversion" es el mecanismo de almacenar un dato pequeño en un contenedor más grande.
Para métodos sobrecargados utilizar el mecanismo widening sobre primitivos se traduce en invocar el método con argumento “más chico”.
Utilizados individualmente, tanto el mecanismo boxing como el var-arg son compatibles con la sobrecarga.
No se puede utilizar el mecanismo widening de un tipo wrapper a otro (estos son objetos y no se cumple con la relación ES-UN).
No se puede utilizar el mecanismo widening y luego el boxing. (Un valor de tipo int no se puede convertir en un Long).
Se puede utilizar el mecanismo boxing y luego el widening. (Un valor de tipo int se puede convertir en un Object, a través del tipo Integer).
Se puede combinar el mecanismo var-arg tanto con widening como con boxing.
Cuando se invocan métodos sobrecargados ciertos mecanismos se sobreponen ante otros:
- Widening (Ver ejemplo)
- Boxing (Ver ejemplo)
- Var-arg (Ver ejemplo)

Garbage Collection (Objetivo 7.4):

Provee una administración automática de la memoria.
El propósito del GC es eliminar los objetos que no pueden ser alcanzados (que ninguna variable de referencia los apunta).
La JVM es la que decide cuando se ejecutará el GC, el programador solo puede sugerirlo.
No se puede conocer el algoritmo del GC.
Los objetos deben ser considerados ilegibles antes de que el GC pueda eliminarlos.
Un objeto es ilegible cuando ningún hilo vivo puede alcanzarlo.
Para alcanzar un objeto, debe existir un hilo vivo que contenga una referencia al objeto.
Si existen objetos ilegibles pero con referencias cruzadas entre ellos, estos pueden ser eliminados por el GC. (Island of objects).
La clase Object tiene un método finalize().
El método finalize() se ejecuta solo una vez, y esto se da antes de que el GC elimine el objeto.
El mecanismo GC no garantiza que el método finalize() se ejecutará.