Sun Certified Java Developer (SCJP) Sección 1 Declarations, Initialization and Scoping

Sun Certified Java Developer (SCJP)

Sección 1 Declarations, Initialization and Scoping

Objetivos

• Declaración de clases e interfaces.

• Implementación de interfaces y clases abstractas.

• Uso de primitivos, arrays, enums e identificadores legales.

• Uso de métodos estáticos, convenciones de nombres de JavaBeans y argumentos variables.

Identificadores legales

• Pueden empezar con una letra, un signo de dólar ($) o un subguión. No pueden empezar con un número.

• Después del primer caracter, pueden contener cualquier combinación de letras, símbolos especiales y números.

• En la práctica no hay límite para el número de caracteres que puede contener un identificador.

• No puede utilizarse un keyword de Java como identificador.

• Los identificadores son case sensitive.

Keywords

• Son palabras reservadas especiales que no pueden ser utilizadas como identificadores (nombres) para clases, métodos o variables.

• En Java existen dos palabras que son reservadas pero que no son utlizadas: const y goto.

• El uso de null, true y false como identificadores está prohibido a pesar de no ser consideradas palabras reservadas sino valores literales.

Keywords

Convenciones de código Java de Sun

• Los nombres de clases e interfaces deben empezar con una letra mayúscula. Por ejemplo: class Empleado { }

• Para nombres de clases o interfaces, usar el formato “camelCase”.

Por ejemplo: public interface RollableInterface { }

• Los nombres de las clases típicamente debe ser sustantivos, en tanto que los nombres de interfaces deberían ser generalmente adjetivos.

Convenciones de código Java de Sun (Continuación)

• Los nombres de métodos y variables deben empezar con una letra minúscula y luego seguir la convención del formato “camelCase”. Por ejemplo: public int buttonWidth = 100;

• Los nombres de métodos generalmente deben corresponder a pares verbo-sustantivo.

Por ejemplo: public int hacerCalculo() { }

• Las constantes son variables marcadas como static y final. Los nombres de constantes deben ser completamente en mayúsculas y deben usarse subguiones como separadores. Por ejemplo: public static final MIN_HEIGHT = 200;

Reglas de nombres para JavaBeans

• Si la propiedad no es un boolean el prefijo para los métodos getter debe ser get. Por ejemplo: getSize()

• Si la propiedad es un boolean, el prefijo para los métodos getter puede ser get o is. Por ejemplo: getStopped() o isStopped()

• El prefijo de los métodos setter deber ser set. Por ejemplo: setSize()

Reglas de nombres para JavaBeans (Continuación)

• Los métodos setter deben estar marcados como public, con un tipo de retorno void y un argumento que represente el tipo de propiedad. Por ejemplo: public void setWidth(int width)

• Los métodos getter deben estar marcados como public, no tener argumentos y retornar un tipo que se corresponda con el tipo de argumento del método setter para esa propiedad.

Por ejemplo: public int getWidth()

Reglas de nombres para Listeners de JavaBeans

• Los nombres de métodos utilizados para registrar un listener deben usar el prefijo add seguido del tipo de listener. Por ejemplo: addActionListener.

• Los nombres de métodos utilizados para remover un listener deben usar el prefijo remove seguido del tipo de listener. Por ejemplo: removeActionListener.

• El tipo de listener que será añadido o removido debe ser pasado como argumento del método.

Clases

Una clase es una plantilla que describe los tipos de estado (variables de instancia) y comportamiento (métodos) que los objetos de este tipo soportan.

Los valores asignados a las variables de instancia de un objeto definen su estado.

Los métodos almacenan la lógica de la clase y definen el comportamiento de los objetos de dicha clase.

Reglas de declaración de archivos fuente

• Sólo una clase pública por archivo de código fuente.

• Los comentarios pueden aparecer al inicio o al final de cualquier línea.

• Si se ha declarado una clase pública en un archivo, el nombre de éste debe corresponderse con el de dicha clase.

• Si la clase es parte de un paquete. La sentencia package debe ser la primera línea en el archivo, antes de cualquier sentencia import.

Reglas de declaración de archivos fuente (Continuación)

• Si hay sentencias import, éstas deben encontrarse entre la sentencia package (si existe) y la declaración de la clase.

• Las sentencias package e import aplican a todas las clases declaradas en el archivo de código fuente.

• Un archivo puede contener más de una clase no pública.

• Archivos que no contengan ninguna clase pública pueden tener un nombre que no se corresponda con el de ninguna de las clases declaradas en el mismo.

Declaraciones de Clase y Modificadores

Una clase puede declararse simplemente como:

class MiClase { }

Adicionalmente pueden añadirse modificadores antes de la declaración de la clase.

Modificadores

Los modificadores pueden caer en dos categorías:

• Modificadores de acceso: public, protected y private.

• Modificadores que no son de acceso: incluyendo strictfp, final y abstract.

Declaraciones de Clase y Modificadores (Continuación)

Java tiene 4 controles de acceso (niveles de acceso) pero sólo 3 modificadores de acceso (public, private y protected). El cuarto nivel de acceso llamado acceso default o package es el que se obtiene cuando no se utiliza ninguno de los tres modificadores de acceso anteriormente citados.

Una clase sólo puede ser declarada con acceso public o default. Los otros dos controles de acceso no tienen sentido para una clase.

Declaraciones de Clase y Modificadores ()

¿Cuál modificador de acceso nos da nivel de acceso package?

(a) public

(b) private

(c) protected

Respuesta: Ninguno de los anteriores. El acceso package o default se obtiene cuando no se utiliza ninguno de los tres modificadores de acceso definidos en Java.

Acceso a Clases

¿Qué significa accesar una clase?

Decir que una clase A tiene acceso a otra clase B, significa que la clase A puede hacer una de las tres cosas siguientes:

• Crear una instancia de la clase B.

• Extender la clase B (en otras palabras ser una subclase de B).

• Accesar ciertos métodos y variables dentro de la clase B, dependiendo del control de acceso de estos métodos y variables.

Acceso a Clases (Continuación)

Acceso significa visibilidad. Si la clase A no puede ver a la clase B, no importa el nivel de acceso de los métodos y variables dentro de B. La clase A no tendrá manera de acceder a éstos.

Acceso Default

class MiClase { }

• Una clase con acceso default no tiene modificador de acceso precediéndole en su declaración.

• Una clase con acceso default o package sólo puede ser vista (accesada) por otras clases dentro del mismo paquete.

Acceso a Clases ()

Si se tienen los dos archivos fuente siguientes:

Beverage.java Tea.javapackage cert; package exam.stuff;class Beverage { } import cert.Beverage;class Tea extends Beverage { }

¿Ambos archivos compilan bien o no? ¿Por qué?

Respuesta: Beverage.java compila bien pero Tea.java no, porque la clase Beverage tiene control de acceso default y ambas clases se encuentran en paquetes distintos.

Acceso a Clases (Tip)

Cuando veas en el examen una pregunta con lógica de programación compleja. Revisa primero los modificadores de acceso.

Si logras detectar una violación de acceso (por ejemplo una clase en el paquete A intentando acceder a una clase con acceso default en un paquete B), sabrás que el código no compilará y selecciona esta respuesta.

Acceso Public

public class MiClasePublica { }

• Una declaración de clase con el modificador de acceso public da a todas las clases de todos los paquetes acceso a la clase pública.

• En otras palabras, todas las clases en el Universo Java tienen acceso a MiClasePublica.

Si la clase pública a la que se intenta acceder se encuentra en un paquete distinto al de la clase que se está escribiendo, es necesario que la clase pública se importe.

Acceso a Clases ()


Beverage.java Tea.javapackage cert; package exam.stuff;public class Beverage { } import cert.Beverage;class Tea extends Beverage { }


Respuesta: Ambos archivos compilan bien, porque sí.

Otros modificadores de Clase

• Se puede modificar la declaración de una clase con las palabras reservadas: final, abstract y strictfp.

• Estos modificadores de no acceso pueden utilizarse junto con el control de acceso. Por ejemplo: Es válido declarar una clase como sigue: public final class MiClasePublicaFinal { }

• No siempre puede utilizarse en conjunto estos modificadores de no acceso. Por ejemplo: Es válido usar en combinación strictfp y final, pero no es correcto declarar una clase como abstract y final.

Otros modificadores de Clase (Continuación)

El conocimiento de cómo funciona strictfp no es necesario para la certificación. Para el examen lo único que se necesita recordar es que strictfp es una palabra reservada (keyword) y que puede ser utilizada para modificar una clase o método pero nunca para modificar una variable.

Clase Final

final class MiClaseFinal { }

• El keyword final en la declaración de una clase indica que dicha clase no puede ser extendida. Es decir que ninguna otra clase puede heredar de una clase declarada como final.

• ¿Por qué declarar una clase como final? Por seguridad. Simplemente para asegurarse de que nadie pueda sobreescribir métodos importantes de dicha clase.

• Marcar una clase como final implica incluso que nadie, que no posea el código fuente, pueda mejorar o especializar su funcionamiento.

Clase Final ()


Beverage.java Tea.javapackage cert; package exam.stuff;public final class Beverage { } import cert.Beverage;class Tea extends Beverage { }


Respuesta: Beverage.java compila bien, pero Tea.java no, debido a que el uso del modificador final en la declaración de la clase Beverage no permite que la clase Tea extienda Beverage.

Clase Abstract

abstract class MiClaseAbstracta { }

• Una clase abstracta NUNCA puede ser instanciada.

• El único propósito de una clase abstracta es ser extendida.

• ¿Por qué crear clases abstractas? Para generalizar estados y comportamientos, que en las subclases pueden ser especializados.

Clase Abstract (Continuación)

• La declaración de un solo método abstracto dentro de una clase obliga a declarar dicha clase como abstracta.

• Una clase abstracta puede declarar cualquier número de métodos no abstractos.

• Una subclase de una clase abstracta debe “implementar” todos los métodos abstractos de la superclase abstracta. No hacerlo implica que la subclase debe ser declarada como abstracta también.

Clase Abstract (Continuación)

abstract class Car {private double price;private String model;private String year;public abstract void goFast();public abstract void goUpHill();public abstract void impressNeighbors();// Additional, important, and serious code goes here}

Adviértase el hecho de que los métodos abstractos terminan con un punto y coma en lugar de llaves.

Clase Abstract (Tip)

Si la declaración de un método en una clase (no en una interface) termina con un punto y coma. Asegúrese de que tanto la clase como el método estén marcados como abstract.

Si no se desea marcar la clase como abstract, entonces se debe colocar un par de llaves al final de la declaración del método en lugar del punto y coma y declarar a dicho método como no abstracto.

Clase Abstract ()

Dado el siguiente código fuente:

Beverage.java package cert; public final abstract class Beverage { } ¿Es la declaración de la clase Beverage correcta o no? ¿Por qué?

Respuesta: No, porque una clase no puede ser declarada como abstract y final al mismo tiempo.

Correcto, pero pensemos un poco al respecto. ¿Hay una razón especial por la que esto no esté permitido?

Final vs. Abstract

Por definición una clase final no puede ser extendida. En tanto que una clase declarada como abstract sí.

Ambas definiciones son opuestas. Es esta la verdadera razón por la que es incorrecta una declaración del tipo:

public final abstract class MiClaseAbstractaFinal { }

Declaraciones de Interfaces

Una interface puede declararse como sigue:

public interface Rollable { }

Una interface es un contrato respecto a lo que una clase puede hacer, pero no de cómo lo hace.

public interface Mahuadable { // Sabemos lo que hay que hacer// Lo que no sabemos, es cómo hacerlo

public abstract Tiwintza vender(Patria ecuador);public abstract void congelar(float ahorros);public abstract byte dolarizar(short sucre);}

Declaraciones de Interfaces (Continuación)

• Una interface puede pensarse como una clase 100% abstracta. Todas las interfaces son implícitamente abstractas.

• A diferencia de una clase abstracta, una interface sólo puede declarar métodos abstractos.

• Cualquier clase que implemente una interface, debe escribir código para los métodos declarados en dicha interface.

• Las interfaces pueden ser implementadas por cualquier clase de cualquier árbol de herencia. Esto permite que clases radicalmente diferentes tengan características comunes.


• Todos los métodos de una interface son implícitamente public y abstract.

• Todas las variables definidas en una interface deben ser public, static y final (constantes). Es decir que en una interface no pueden declararse variables de instancia.

• Los métodos de interface no pueden ser static.

• Debido a que los métodos de interface son abstract, no pueden ser declarados como final, strictfp o native.


• Una interface puede extender una o más interfaces.

• Una interface no puede extender otra cosa que no sean interfaces.

• Una interface no puede implementar otras interfaces o clases.

• Una interface debe ser declarada con la palabra reservada (keyword) interface.

• Las interfaces pueden ser usadas polimórficamente.

Declaraciones de Interfaces ()

Dadas las siguientes sentencias de declaración de interfaces:

public abstract interface Rollable { }public interface Rollable { }¿Son ambas sentencias equivalentes o no? ¿Por qué?

Respuesta: Sí, ambas sentencias son equivalentes, porque toda interface es implícitamente abstracta. El uso del modificador abstract en la declaración de una interface es considerado redundante.


Dadas las siguientes declaraciones de interfaces con sus métodos:

public interface Rollable { public interface Rollable { public abstract void hacer(); void hacer();} }

¿Son ambos segmentos de código equivalentes o no? ¿Por qué?

Respuesta: Sí, son equivalentes, porque los métodos de interface son implícitamente públicos y abstractos. El uso de los modificadores public y abstract en la declaración de métodos de interface es considerado redundante.


Dadas las siguientes declaraciones de métodos de interface, ¿cuáles son correctas?:

private void fill();

void play();

public void drive();

final void parse();

abstract void jump();

static void encrypt();

public abstract find();

abstract public void load();

protected void set();

Métodos de interface siempre son public

Métodos de interface siempre son public

final y abstract no pueden usarse juntos

Interfaces definen métodos de instancia

abstract es implícito

Declaraciones de Constantes de Interfaces

• Está permitido declarar constantes en una interface.

• Todas las clases que implementen dicha interface tendrán acceso directamente a la misma constante como si de herencia se tratare.

• Sólo hay que recordar una regla clave en la declaración de constantes de interfaces. Éstas deben ser:

public static final

• Cualquier variable definida en una interface es implícitamente una constante pública.

Declaraciones de Constantes de Interfaces ()

Dados los siguientes archivos de código fuente:

Foo.java Zap.java

interface Foo { class Zap implements Foo { int BAR = 42; public void go() {void go(); BAR = 27; } } }¿Zap compilará sin problemas o no? ¿Por qué?

Respuesta: No se puede compilar. BAR es implícitamente una constante pública (public static final), por tanto es una variable de sólo lectura. La asignación BAR = 27 en Zap producirá un error de compilación.

Declaración de Miembros de Clase

• Los miembros de clase pueden usar los cuatro niveles de control de acceso definidos en Java, a diferencia de las clases que sólo podían usar dos.

• ¿Qué significa que una clase tenga acceso a los miembros (métodos y variables) de otra clase?

• Una vez más, acceso significa visibilidad. Si una clase A tiene acceso a un miembro de la clase B, significa que el miembro de la clase B es visible para la clase A.

Acceso a Miembros de Clase

Deben entenderse dos tipos de acceso a miembros de clase:

• Si un método de una clase puede o no acceder a un miembro de otra clase.

• Si una subclase puede heredar un miembro de su superclase.

• Gran parte de ambos tipos de acceso se centra en el hecho de si las clases involucradas se encuentran o no en el mismo paquete.

Acceso a Miembros de Clase (Continuación)

Es importante recordar que si una clase A no puede ser accesada por una clase B, ningún miembro dentro de la clase A podrá ser accesado desde la clase B, esto sin importar la visibilidad de los miembros de la clase A.

Acceso a Miembros de Clase ()


*class Zoo { *class Moo { public int value = 42; public void doSomething() {Zoo z = new Zoo();} z.value = 50;} }Considerando que ambas clases se encuentran en paquetes diferentes: ¿Compilarán ambas clases correctamente o no?* Las sentencias package e import se omitieron por cuestión de espacio.

Respuesta: Zoo compila correctamente, pero Moo no, debido a que la clase Zoo tiene control de acceso package y no puede ser accesada por la clase Moo que se encuentra en un paquete distinto. Por tanto, ningún miembro de la clase Zoo puede ser accesado por Moo, aunque estos sean públicos, como es el caso de value. ¿Dónde ocurre el primer error de compilación en Moo?

Miembros Public

• Un miembro public puede ser accesado por cualquier otra clase sin importar el paquete en que se encuentre. Esto asumiendo que la clase donde está declarado el miembro que se accesa sea visible.

Miembros Public ()


public class Zoo { class Moo extends Zoo { public void doIt() { public void doSomething() {// Esto hace algo doIt();} }} } Considerando que ambas clases se encuentran en paquetes diferentes: ¿Compilarán ambas clases correctamente o no?* Las sentencias package e import se omitieron por cuestión de espacio.

Respuesta: Sí, ambas clases compilan correctamente. Parece obvio porque Zoo compila bien. Moo por su parte, compila igualmente bien porque tanto Zoo y doIt() han sido declarados public, de tal forma que la invocación a doIt() en doSomething() es válida.

Uso de la referencia this

• this siempre hace referencia al objeto que actualmente se encuentre en ejecución, es decir el objeto ejecutando el código donde se halla la referencia.

• La referencia this es implícita.

• Se usa por cuestiones de legibilidad del código.

Miembros Private

• Un miembro marcado private no puede ser accesado por ninguna otra clase que no sea aquella donde fue declarado.

• Un miembro private es invisible para cualquier código externo a la clase propietaria del miembro.

• Un miembro private NO puede ser heredado por una subclase.

Miembros Private ()


public class Zoo { class Moo extends Zoo { private void doIt() { public void doSomething() {// Esto hace algo doIt();} }} } Considerando que ambas clases se encuentran en paquetes diferentes: ¿Compilarán ambas clases correctamente o no?* Las sentencias package e import se omitieron por cuestión de espacio.

Respuesta: Zoo compila sin problemas, pero Moo no. Aunque Moo puede accesar a Zoo pues su nivel de acceso es public, el método doSomething() en Moo no puede acceder a doIt() debido a que este es un miembro private de la clase Zoo. Moo no puede heredar doIt().

¿Overriding de Métodos Private?

¿Puede una subclase hacer un overriding de un método private de su superclase?

Técnicamente la respuesta es no, debido a que la subclase no puede ver al método private de su superclase, por tanto no puede heredar el método private. El término adecuado aquí sería matching no overriding. Overriding es dependiente de la herencia.

Miembros Protected y Default

• Los niveles de control de acceso protected y default son casi idénticos, excepto por una diferencia sustancial.

• Un miembro default puede ser accesado por otra clase, si y sólo si ambas clases se encuentran en el mismo paquete.

• Un miembro protected puede ser accesado por una subclase fuera del paquete únicamente por medio de herencia, no a través de una referencia.

Miembros Protected y Default ()


public class Zoo { class Moo { void doIt() { public void doSomething() {// Esto hace algo Zoo z = new Zoo();z.doIt();} }} } Considerando que ambas clases se encuentran en paquetes diferentes: ¿Compilarán ambas clases correctamente o no?* Las sentencias package e import se omitieron por cuestión de espacio.

Respuesta: Zoo compila sin problemas, pero Moo no. Aunque Moo puede accesar a Zoo pues su nivel de acceso es public, el método doSomething() en Moo no puede acceder a doIt() debido a que este es un miembro con acceso default en la clase Zoo. doIt() sólo puede ser visto por clases en el mismo paquete que Zoo.



public class Zoo { class Moo extends Zoo { protected int x=5; public void doSomething() {int y = x;}} } Considerando que ambas clases se encuentran en paquetes diferentes: ¿Compilarán ambas clases correctamente o no?* Las sentencias package e import se omitieron por cuestión de espacio.

Respuesta: Sí, ambas clases compilan bien. Moo hereda x que tiene control de acceso protected en Zoo, por tanto el código escrito en doSomething() es válido.



public class Zoo { class Moo extends Zoo { protected int x=5; public void doSomething() {Zoo z = new Zoo()int y = z.x;}} } Considerando que ambas clases se encuentran en paquetes diferentes: ¿Compilarán ambas clases correctamente o no?* Las sentencias package e import se omitieron por cuestión de espacio.

Respuesta: Zoo compila sin inconvenientes, pero Moo no. Miembro x que tiene control de acceso protected en Zoo, puede ser accesado en Moo exclusivamente a través de herencia. El acceso a través de una referencia no está permitido.

Miembros Protected: Un detalle más

¿Qué ocurriría si una clase X en el mismo paquete que una subclase Y que hereda un miembro protected de su superclase Z intenta acceder a éste miembro protected a través de una instancia de Y?

Paquete A

Clase Z

Paquete B

Clase Y

Clase X

Miembros Protected: Un detalle más (Continuación)

Una vez que Y hereda el miembro protected de Z, éste pasa a ser privado en Y. Por tanto puede ser accesado únicamente en Y. Cualquier intento de acceso a este miembro por parte de X no es válido.

Paquete A

Clase Z

Paquete B

Clase Y

Clase X

Miembros Protected: Un detalle más (Continuación)

Y si X es subclase de Y. ¿Podría ahora acceder al miembro protected de Z?

Paquete A

Clase Z

Paquete B

Clase Y

Clase X

No, puesto que X no hereda los miembros privados de Y.

Variable Locales y Modificadores de Acceso

• No existe un solo caso bajo el cual una variable local pueda ser declarada con un modificador de acceso.

• Cualquier intento de declarar una variable local con un modificador de acceso producirá un error de compilación.

• De hecho existe un solo modificador que puede ser aplicado a las variable locales: final.

Resumen Acceso a Miembros de Clases

Métodos Final

• El uso del modificador final en la declaración de un método impide hacer overriding al método .

• Provee seguridad, pero debe ser usado con precaución.

• El uso de final en la declaración de un método impide la extensibilidad a través del polimorfismo.

Argumentos Final

• Los argumentos de un método son esencialmente variables locales.

• Aplican todas las reglas aplicadas para las locales variables.

• Un argumento de un método puede ser declarado final. Por ejemplo:

public Record getRecord(int fileNumber, final int RecNumber) { }

Métodos Abstract

• Un método abstracto es un método que ha sido declarado (como abstract) pero que no ha sido implementado.

• La declaración de un método abstracto no incluye llaves sino un punto y coma.

• Se marca un método como abstract cuando se desea forzar a las subclases a que implementen dicho método.

Métodos Abstract (Continuación)

• Es ilegal declarar un método abstracto dentro de una clase que no ha sido declarada como abstracta de forma explícita.

• Cualquier clase que extienda de una clase abstracta debe implementar todos los métodos de la superclase abstracta, a menos que la subclase sea también abstracta.

• La primera subclase concreta de una clase abstracta debe implementar todos los métodos abstractos de la superclase.

Métodos Abstract ()

Dadas las siguientes declaraciones de clases:

public abstract class Zoo { class Moo extends Zoo { abstract void foo(); void foo(int i) { } } } ¿Ambas clases compilarán correctamente?

Respuesta: Zoo compila sin inconvenientes, pero Moo no, puesto que al ser Moo una subclase concreta de Zoo debe implementar el método abstracto foo() de Zoo. Adviértase que el método foo(int i) en Moo no es una implementación correcta de foo() sino una sobrecarga.

Por si aún quedan dudas

Un método NUNCA JAMÁS debe ser declarado como abstract y final, o como abstract y private al mismo tiempo.

Un método abstract debe ser implementado (overriding) por una subclase, sin embargo no puede hacerse overriding a métodos final o private.

Métodos Synchronized

• El modificador synchronized indica que un método puede ser accesado sólo por un hilo a la vez.

• Sólo puede ser aplicado a métodos, no así a variables ni clases.

• Puede ser utilizado con cualquiera de los cuatro niveles de acceso presentados anteriormente.

Métodos Native

• El modificador native indica que un método es implementado en código depediente de la plataforma, a menudo en C.

• Sólo puede ser aplicado a métodos, no así a variables ni clases.

• El cuerpo de un método native es un punto y coma, lo cual indica que la implementación es omitida.

Métodos Strictfp

• El modificador strictfp forza a que los puntos flotantes se adhieran al estándar IEEE 754, independiente de la plataforma sobre la cual corre la JVM.

• Puede ser utilizado para modificar la declaración de una clase o método, mas no para modificar una variable.

• Una variable nunca puede ser declarada como strictfp.

Métodos con Lista de Argumentos Variable (var-args)

• Se refiere a la capacidad de declarar métodos con un número variable de argumentos.

• Argumentos, son las cosas que se especifican entre paréntesis cuando se invoca un método.

• Parámetros, son las cosas en la firma del método que indican lo que el método debe recibir cuando se le invoca.

Reglas de declaración para var-args

• Tipo var-arg. Cuando se declara un parámetro var-arg debe especificarse el tipo del o los argumentos.

• Sintaxis básica. Seguido al tipo se escribirán tres puntos suspensivos (...), luego un espacio y el nombre del arreglo que contendrá los parámetros recibidos.

• Otros parámetros. Es legal tener otros parámetros en un método que use un var-arg.

• Límites var-args. Var-arg debe ser el último parámetro en la firma del método. Sólo se permite un var-arg en un método.

Dadas las siguientes declaraciones de métodos que utilizan var-args, ¿cuáles son correctas?:

void doStuff4(int x...) { }

void doStuff2(char c, int... x)

void doStuff(int... x) { }

void doStuff5(int... x, char... y) { }

void doStuff3(Animal... animal) { }

void doStuff6(String... s, byte b) { }

Métodos con Lista de Argumentos Variable (var-args) ()

Sintaxis equivocada

Demasiados var-args

Var-arg debe ser el último parámetro

Declaraciones de Constructores

• En Java los objetos son construidos.

• Cuando se hace un nuevo objeto, se invoca al menos a un constructor.

• Toda clase tiene un constructor. Si no se crea uno explícitamente, el compilador lo hará.

Declaraciones de Constructores (Continuación)

• Los contructores NUNCA JAMÁS tienen un tipo de retorno.

• La declaración de un constructor puede contener cualquiera de los modificadores de acceso antes presentados y pueden tomar argumentos (incluso var-args).

• Deben tener el mismo nombre que la clase en la cual se declaran.

• No pueden ser marcados como static, final o abstract.

Declaraciones de Constructores ()

¿Cuáles de los siguientes son constructores válidos para la clase Foo2?

void Foo2() { }

static Foo2(float f) { }

private Foo2(byte b) { }

Foo() { }

Foo2(short s);

Foo2() { }

Foo2(int... x, int t) { }

Es un método no un constructor

Sintaxis var-arg equivocada

No es ni un método ni un constructor

Luce como un método abstracto

Un constructor no puede ser static

Tipos de Variables (Primitivos)

• Primitivos. Puede ser uno de ocho tipos: char, boolean, byte, short, int, long, double o float.

• Una vez que un primitivo ha sido declarado, su tipo primitivo no puede ser cambiado.

• En la mayoría de los casos el valor de un primitivo puede variar.

Tipos de Variables (Primitivos) (Continuación)

• byte, short, int, long, conocidos como tipos integrales por no contener componente de punto flotante (parte decimal).

• float, double, tipos primitivos numéricos con componente de punto flotante.

• boolean, cuyo valor puede ser únicamente true o false.

• char, es un tipo de dato primitivo de 16 bits sin signo, que posibilita la representación de caracteres Unicode.

Declaración de Primitivos

• Las variables primitivas pueden ser declaradas como variables de clase o de instancia, o como parámetros de métodos o variables locales.

• Se pueden declarar varias variables del mismo tipo primitivo en una sola línea.

• Ejemplos:int a;double b,c;

Rangos de Primitivos

Tipos de Variables (De Referencia)

• Variables de referencia. Son usadas para referenciar o accesar a un objeto.

• Una vez que una variable de referencia ha sido declarada, su tipo no puede ser cambiado.

• Pueden ser usadas para referenciar cualquier objeto del tipo declarado o de un subtipo del tipo declarado.

Declaración de Variables de Referencia

• Las variables de referencia pueden ser declaradas como variables de clase o de instancia, o como parámetros de métodos o variables locales.

• Se pueden declarar una o más varias variables de referencia del mismo tipo en una sola línea.

• Ejemplos:Dog myNewDogReferenceVariable;String s1, s2, s3;

Variables de Instancia

• Son definidas al interior de la clase, pero fuera de cualquier método.

• Son inicializadas únicamente cuando la clase es instanciada.

• Son los campos que hacen único a cada objeto en particular.

Variables de Instancia (Continuación)

• Pueden usar cualquiera de los cuatro niveles de acceso definidos en Java.

• Pueden ser marcadas como final y transient.

• No pueden ser marcadas como abstract, synchronized, strictfp, native o static.

• Una variable marcada como static no es una variable de instancia sino de clase.

Uso de Modificadores en Variables y Métodos (Resumen)

Variables Locales

• Son declaradas e inicializadas dentro de un método.

• El ciclo de vida de las variables locales empieza con el método y termina cuando éste concluye.

• No pueden ser referenciadas fuera del método donde han sido declaradas.

• Las variables locales se encuentran en el stack no en el heap.

Variables Locales (Continuación)

• Las variables locales sólo pueden ser marcadas como final

• Las variables locales no tienen valores por defecto.

• Deben ser inicializadas antes de poder ser utilizadas.

• Pueden ser declaradas con el mismo nombre de una variable de instancia (shadowing).

Arrays

• Son objetos que sirven para almacenar múltiples variables del mismo tipo o que sean todas subclases del mismo tipo.

• Pueden almacenar primitivos o referencias a objetos.

• Los arrays siempre serán objetos en el heap, incluso si sirven para almacenar primitivos.

Declaraciones de Arrays

• Declaración de arrays de primitivos:

int[] key; // Recomendada

int key [];

• Declaración de arrays de referencias a objetos:

Thread[] threads; // Recomendada

Thread threads [];

Declaraciones de Arrays Multidimensionales

• Pueden declararse arrays multidimensionales (arrays de arrays), de la siguiente forma:

String[] [] [] occupantName;

String[] ManagerName [];

Declaraciones de Arrays

Es ilegal incluir el tamaño del array en su declaración.

La razón es que la JVM, no reserva espacio hasta que realmente se instancie el array de objetos.

Variables Final

• Una variable final no puede ser reinicializada una vez que ha sido inicializada explícitamente.

• Una variable de referencia marcada como final no puede ser reasignada para referir a un objeto diferente. Aunque el estado del objeto al cual referencia sí puede ser modificado.

• No hay objetos final sino únicamente referencias final.

Efecto de final en variables, métodos y clases (Resumen)

Variables Transient

• Las variables marcadas como transient son ignoradas cuando se intenta serializar el objeto que las contiene.

• La serialización permite guardar un objeto escribiendo su estado a un tipo especial de flujo de E/S.

• Con la serialización se puede guardar un objeto en un archivo o transportarlo hacia otra JVM donde se lo deserializa.

Variables Volatile

• La marca volatile le indica a la JVM que cualquier hilo que intente acceder a la variable debe sincronizar su copia privada de la variable con la copia maestra existente en memoria.

• Al igual que transient, el modificador volatile sólo puede ser aplicado a variables de instancia.

Métodos y Variables Static

• El modificador static sirve para crear variables y métodos que existirán independientemente de cualquier instancia de la clase.

• Los miembros static existen antes de cualquier instancia que se pudiera crear.

• Sólo existe una copia independientemente del número de instancias que existan.

• Todas las instancias de una misma clase comparten el mismo valor de una variable static (variable de clase).

Cosas que pueden marcarse como static

• Métodos.

• Variables.

• Clases anidadas dentro de otra clase pero no dentro de un método.

• Bloques de inicialización.

Cosas que JAMÁS deben marcarse como static

• Constructores.

• Clases (a menos que estén anidadas).

• Interfaces.

• Métodos locales de clases internas (inner classes).

• Variables de instancia y métodos de inner classes.

• Variables locales.

Declaración de Enums

enum Estado {ACTIVO, INACTIVO, ANULADO};

• El uso de enums permite restringir los valores que una variable dada puede tomar.

Estado e = Estado.ACTIVO;

• En el ejemplo e sólo puede tomar los valores de la lista enumerada declarada inicialmente: ACTIVO, INACTIVO, ANULADO.

Declaración de Enums (Continuación)

• Pueden ser declarados como una clase separada.

• Pueden ser declarados como miembros de clase.

• Jamás deben ser declarados dentro de un método.

Declaración de Enums al exterior de una clase

• enum's sólo pueden ser declarados como public o default.

Declaración de Enums al interior de una clase

• La sintaxis para acceder a los miembros de enum depende del lugar donde éste fue declarado.

Declaración ilegal de Enums

• La sintaxis para acceder a los miembros de enum depende del lugar donde éste fue declarado.

Declaración de Enums (Continuación)

• El punto y coma al final de la declaración de un enum es opcional.

• Los enums no son Strings o ints.

• Cada uno de los tipos enumerados CoffeeSize son en realidad instancias de CoffeeSize.

Ejemplo conceptual de cómo puede pensarse un Enum

Declaración de constructores, métodos y variables en un Enum

Constructores de Enums

• Nunca se puede invocar directamente al constructor de un enum.

• El constructor de un enum es invocado automáticamente con el argumento definido después del valor constante.

• Puede definirse más de un argumento para el constructor.

• Los constructores de enums pueden ser sobrecargados.

Cuerpo de Clase de una Constante Específica... (WHAT!!!!!)

THE END

Y que esto les quede de experiencia...!

Documents

Sun Certified Java Developer (SCJP) Sección 1 Declarations, Initialization and Scoping