Resúmenes SCJP: Capítulo 1. Declaraciones y Control de acceso

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

LINK

Estos resúmenes se basan en el libro "Sun Certified Programmer for Java 6 Study Guide". Lo bueno que tiene este libro es que al final de cada capítulo hay un resumen con todos los puntos más importantes a tener en cuenta para la preparación del examen. Esta sección se llama "TWO-MINUTE DRILL". También contiene un mini examen para autoevaluarse sobre los puntos tratados en el capítulo.

A continuación dejo el resumen del capítulo (traducido por Matías) 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.