Declaraciones y Control de acceso

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

A continuación dejo un link con los objetivos del exámen de certificación SCJP.

Actualmente estoy leyendo el libro "Sun Certified Programmer for Java 6 Study Guide" (el cuál puede ser descargado desde el proyecto de google o haciendo click aquí). Hoy termine de leer el primer capítulo el cuál tiene el mismo nombre que esta entrada (Declarations and Access Control). Lo bueno de este libro es que al final de cada capítulo hay un resumen con todos los items importantes a tener en cuenta a la hora de rendir el exámen. Esta sección se llama "TWO-MINUTE DRILL". También contiene un mini exámen para autoevaluarse con los tópicos tratados en el capítulo.

A continuación dejo el resumen del capítulo (traducido por mí) del libro. Espero que les sea de utilidad.

Identificadores (Objetivo 1.3):

Los identificadores pueden comenzar con una letra, un guión bajo o un carácter de moneda.
Luego del primer carácter, los identificadores pueden incluir dígitos.
Pueden ser de cualquier longitud.
La especificación JavaBeans establece que los métodos deben definirse utilizando camelCase, y dependiendo del propósito del método, deben comenzar con get, set, is, add o remove (estos últimos dos deben terminar con el sufijo Listener).

Reglas de declaración (Objetivo 1.1):

Un archivo de código fuente solo puede contener una clase pública.
Si el archivo contiene una clase pública, el nombre del mismo debe ser igual al nombre de esa clase pública.
Un archivo solo puede contener una declaración de package, pero múltiples declaraciones de imports.
Si existe la declaración package, esta debe estar en la primera línea (que no sea un comentario) del archivo.
Si existe la declaración de imports, deben estar luego de la declaración package y antes de la declaración de la clase.
Si no existe la declaración package, la declaración import debe estar en la primera línea (que no sea un comentario) del archivo.
Las declaraciones package y import, aplican a todas las clases del archivo.
Un archivo puede contener más de una clase no pública.
Los archivos sin ninguna clase pública no tienen restricciones de nombre.

Modificadores de acceso a clase (Objetivo 1.1):

Existen tres modificadores de acceso: public, protected y private.
Existen cuatro niveles de acceso: public, protected, default y private.
Las clases solo pueden ser declaradas con acceso public o default.
Una clase con acceso default solo puede ser vista por las clases dentro del mismo paquete.
Una clase con acceso public puede ser vista por todas las clases de todos los paquetes.
La visibilidad de clases consiste en si el código de una clase puede:
- Crear una instancia de otra clase.
- Extender otra clase (a través de la herencia).
- Acceder a métodos y variables de otra clase.

Modificadores de clase (Sin acceso) (Objetivo 1.2):

Las clases también pueden ser modificadas con final, abstract o strictfp.
Una clase no puede ser final y abstract.
Una clase final no puede ser extendida.
Una clase abstract no puede ser instanciada.
Un método abstracto dentro de una clase significa que la clase entera debe ser abstract.
Una clase abstracta puede tener métodos abstractos y no abstractos.
La primera clase concreta que extienda de una clase abstracta debe implementar todos los métodos abstractos.

Implementación de interfaces (Objetivo 1.2):

Las interfaces son contratos sobre lo que puede hacer una clase, pero no dicen nada acerca de cómo deben realizarlo.
Las interfaces pueden ser implementadas por cualquier clase, de cualquier árbol de herencia.
Una interface es como una clase abstracta al cien por ciento. Y es implícitamente abstracta más allá de que contenga o no el modificador abstract.
Una interface solo puede contener métodos abstractos.
Los métodos de una interface son por defecto públicos y abstractos, la declaración implícita de estos modificadores es opcional.
Las interfaces pueden contener constantes, las cuales siempre son public, static y final (la declaración implícita puede hacerse en cualquier orden).
Una clase concreta que implemente una interface tiene las siguientes propiedades:
- Provee implementaciones concretas para los métodos abstractos de la interface.
- Debe seguir todas las reglas de sobreescritura de los métodos que implementa.
- No debe añadir ninguna nueva excepción a los métodos implementados. (Solo las excepciones declaradas en la interface pueden ser lanzadas desde el método.)
- Debe mantener la misma signatura y tipo de retorno (también se permiten los tipos de retorno covariantes) de los métodos que implementa.
Una clase que implemente una interface también puede ser abstract.
Una clase abstracta que implemente una interface no necesita implementar los métodos de la misma (pero sí lo debe hacer la primer clase no abstracta que la extienda).
Una clase puede extender solo de una sola clase (no está permitida la herencia múltiple), pero si puede implementar muchas interfaces.
Las interfaces pueden extender de una o más interfaces.
Las interfaces no pueden extender una clase, o implementar una clase o interface.

Modificadores de acceso de miembros (Objetivo 1.3 y 1.4):

Los miembros son los métodos y variables de instancia.
Los miembros pueden utilizar los cuatro niveles de acceso: public, protected, default y private.
Los accesos a los miembros se pueden realizar de dos formas:
- Código en una clase que puede acceder a un miembro de otra clase.
- Una subclase que puede heredar un miembro de una superclase.
Si no se puede acceder a una clase, tampoco se podrá acceder a sus miembros.
Determinar la visibilidad de una clase, antes de determinar la visibilidad de sus miembros.
Los miembros públicos pueden accederse desde todas las demás clases, incluso en otros paquetes.
Si la superclase contiene un miembro público, la subclase lo hereda.
Los miembros accedidos sin el operador punto (.) deben pertenecer a la misma clase.
La palabra clave this siempre se refiere al objeto que se está ejecutando. Dentro de la misma clase this.unMetodo() es lo mismo que invocar unMetodo().
Los miembros privados solo pueden accederse desde el código de la misma clase.
Los miembros privados no son visibles para las subclases, o sea no pueden ser heredados.
Los miembros default y protected difieren solo en lo relacionado a las subclases:
- Miembros default pueden ser accedidos solo por las clases pertenecientes al mismo paquete.
- Miembros protected pueden ser accedidos por otras clases pertenecientes al mismo paquete, y además por las subclases pertenecientes a otros clases.
- Para las subclases fuera del paquete, los miembros protected solo pueden ser accedidos a través de la herencia. Una subclase fuera del paquete no puede acceder a los miembros protegidos a través de una referencia a una instancia de la superclase.

Variables locales (Objetivo 1.3):

Las declaraciones de variables locales no pueden tener modificadores de acceso.
El único modificador que se puede aplicar a las variables locales es final.
Las variables locales no poseen valores por default (a diferencia de las variables de instancia), por lo que deben ser inicializadas antes de utilizarlas.

Otros modificadores de miembros (Objetivo 1.3):

Los métodos final no pueden ser sobreescritos por las subclases.
Los métodos abstractos son declarados con una signatura, un tipo de retorno, opcionalmente se puede agregar la clausula throws, pero no están implementados.
Los métodos abstractos terminan con punto y coma, no con llaves.
La primera clase concreta que extienda a una clase abstracta debe implementar todos los métodos abstractos.
El modificador synchronized puede ser aplicado solo a métodos y a bloques de código.
Los métodos synchronized pueden tener cualquier control de acceso y también pueden ser final.
Los métodos abstractos deben ser implementados por las subclases, por este motivo:
- Los métodos abstract no pueden ser private.
- Los métodos abstract no pueden ser final.
El modificador native solo se puede aplicar a los métodos.
El modificador strictfp solo se puede aplicar a las clases y métodos.

Métodos con var-args (Objetivo 1.4):

Desde Java 5, los métodos pueden contener un parámetro que acepte desde cero a muchos argumentos, este tipo de parámetro se denomina var-arg.
Un parámetro var-arg es declarado con la sintaxis: doStuff(int… x) { }.
Un método solo puede contener un parámetro var-arg.
Un método con parámetros normales y uno var-arg, el var-arg debe ser el último parámetro.

Declaraciones de variables (Objetivo 1.3):

Las variables de instancia pueden:
- Tener cualquier control de acceso.
- Ser final o transient.
Las variables de instancia no pueden ser abstract, synchronized, native, o strictfp.
Es legal declarar una variable local con el mismo nombre que una variable de instancia, esto se llama “Shadowing”.
Las variables finales tienen las siguientes propiedades:
- No pueden ser reinicializadas una vez que ya se le ha asignado un valor.
- Las referencias finales no pueden apuntar a otro objeto, una vez que un objeto ya ha sido asignado.
- Las referencias finales deben ser inicializadas antes de completarse la ejecución del constructor.
Una referencia final a un objeto, no significa que el objeto no pueda cambiar su estado.
El modificador transient es aplicable solo a las variables de instancia.
El modificador volatile es aplicable solo a las variables de instancia.

Declaraciones de arreglos “Arrays” (Objetivo 1.3):

Los arreglos pueden contener tipos primitivos u objetos, pero el arreglo en sí mismo es siempre un objeto.
Cuando se declara un arreglo, los corchetes pueden ir antes o después del nombre de la variable.
No es legal incluir el tamaño del arreglo en la declaración del mismo. (Esto se puede hacer en la instanciación del mismo)
Un arreglo de objetos de un tipo puede contener cualquier objeto hijo de ese tipo.

Variables y métodos estáticos (Objetivo 1.4):

No se relacionan con ninguna instancia de clase.
No se necesitan instancias de clases para acceder a los miembros estáticos.
Solo existe una copia de las variables estáticas de una clase, y todas las instancias de la clase la comparten.
Los métodos estáticos no tienen acceso directo a los miembros no estáticos.

Enumeraciones “Enums” (Objetivo 1.3):

Un enum especifica una lista de valores constantes asignados a un tipo.
Un enum no es un objeto String, es un objeto de tipo enum.
Un enum puede ser declarado dentro o fuera de una clase, pero no en un método.
Un enum declarado fuera de una clase no puede ser static, final, abstract, protected o private.
Los enums pueden pueden contener constructores, métodos, variables, y cuerpos de clase constantes (constant class bodies).
Las constantes enums pueden enviar argumentos al constructor del enum, usando la sintaxis BIG(8), en donde el literal 8 es pasado al constructor como argumento.
Los constructores enum pueden tener argumentos y pueden ser sobrecargados.
Los constructores de enums no pueden ser invocados directamente. Estos son llamados automáticamente cuando un enum es inicializado.
El punto y coma final de la declararión de un enum es opcional.
El método MyEnum.values() retorna un arreglo con todos los valores del enum.