Resumen OCP(SCJP): Capítulo 1. Declaraciones y Control de acceso

por | Junio 22, 2013

REGLAS DE DECLARACIÓN (OBJETIVO 1.1):

  • Un archivo puede contener más de una clase no pública.
  •  Archivos con ninguna clase pública pueden tener un nombre que no coincida con las clases que hay en el fichero

DECLARACIÓN DE CLASES Y MODIFICADORES

Los modificadores pueden dividirse en dos categorías:

  • Modificadores de acceso
  • Modificadores de no-acceso

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. Ej. Si la clase A tiene acceso por defecto, la clase B no podrá crear una instancia de la clase A, o declarar una variable o retornar una del tipo de la clase A.

MODIFICADORES DE CLASE (SIN ACCESO) (OBJETIVO 1.2):

  • strictfp
  • final
  • abstract
  • Una clase no puede ser final y abstract al mismo tiempo.
  • Una clase final NO PUEDE ser extendida.
  • Una clase abstract NO PUEDE ser instanciada.
  • Una clase abstracta PUEDE tener métodos abstractos y no abstractos.
  • Un metodo final no puede ser sobrescrito por su subclase Ej.
class SuperClass{
    public final void metodoFinal(){
        System.out.println("Hacer algo.");
    }
}
class SubClass extends SuperClass{
    public void metodoFinal(){ //Error de compilacion 
     //"Cannot override the final method from SuperClass"
        System.out.println("Hacer otra cosa");
    }
}

IMPLEMENTACIÓN DE INTERFACES (OBJETIVO 1.2):

  • 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.
  • Los métodos de una interface son por defecto públicos y abstractos, la declaración implícita de estos modificadores es opcional.
// ** Lo que nosotros declaramos
interface Bounceable {
    void bounce();
    void setBounceFactor(int bf);
}
// ** Lo que el compilador ve
interface Bounceable{
    public abstract void bounce();
    public abstract void setBounceFactor(int bf);
}
  • Los métodos de las Interface no pueden ser “static”.
  • Todas las variables definidas en una Interface deben ser public, static y final(estos modificadores están implícitos), en otras palabras, las Interface pueden declarar solo constantes, no variables de instancia. Ej:
/*public abstract*/ interface MiInterfaz {
	/*public static final*/String variable = "";
}
  • Una clase que implemente una interface también puede ser abstract y no necesita implementar los métodos de la misma.
  • Las interfaces PUEDEN EXTENDER de una o más interfaces.
interface OtraInterfaz extends InterfazUno, InterfezDos {

}
  • 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 pueden utilizar los cuatro niveles de acceso: public, protected, default y private.
  • Determinar la visibilidad de una clase, antes de determinar la visibilidad de sus miembros.
  • Los miembros privados no son visibles para las subclases, 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(a través de la herencia) pertenecientes a otros clases, incluso si la subclase está en un paquete diferente.

  • 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):

  • 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.
Visibilidad Public Protected Default Private
De una misma clase Si Si Si Si
De cualquier clase en el mismo paquete Si Si Si No
De una subclase en el mismo paquete Si Si Si No
De una subclase fuera del paquete Si Si No No
De una clase que no es subclase fuera del paquete Si No No No

OTROS MODIFICADORES DE MIEMBROS (OBJETIVO 1.3):

  • El modificador synchronized puede ser aplicado solo a métodos y a bloques de código.
  • 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):

  • 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 no pueden ser abstract, synchronized, native, o strictfp.
  • El modificador transient es aplicable solo a las variables de instancia.
  • El modificador volatile es aplicable solo a las variables de instancia.
  • Es legal declarar una variable local con el mismo nombre que una variable de instancia, esto se llama “Shadowing”.

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.

VARIABLES Y MÉTODOS ESTÁTICOS (OBJETIVO 1.4):

  • 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 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 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.

Declarando un ENUM fuera de la clase

enum CoffeeSize {
    BIG,
    HUGE,
    OVERWHELMING
}

class Coffee{
    CoffeeSize size;
}

public class CoffeeTest {

    public static void main (String[] args){
        Coffee drink = new Coffee();
        drink.size = CoffeeSize.BIG; //Enumeración fuera de la clase
    }
}

Declarando un ENUM dentro de una clase

class Coffee2{
    enum CoffeeSize {BIG,HUGE,OVERWHELMING}
    CoffeeSize size;
}

public class CoffeeTest2 {

    public static void main(String[] args) {
        Coffee2 drink = new Coffee2();

        //Se necesita el nombre de la clase para acceder al enum
        drink.size = Coffee2.CoffeeSize.BIG; 

        // la referencia no puede aceder al enum
        drink.size = drink.CoffeeSize.BIG;
    }

}

Y algo extraño en los enums Constant Specific Class Body
Escenario:

Queremos que la enumeración tenga 2 métodos, uno para las onzas y otro para el código de la tapa (Como un String). Ahora queremos que la mayoría de los tamaños de los cafés usen el mismo código de tapa, “B”, pero que OVERWHELMING use el tipo “A”.

enum CoffeeSize {
    BIG(8),
    HUGE(10),
    OVERWHELMING(16){
            //empieza un bloque de código que
            //define el cuerpo de esta constante
        public String getLidCode(){ //sustituye el método definido
                                    // en CoffeeSize
            return "A";
        }
    };

    CoffeeSize(int ounces){
        this.ounces = ounces;
    }

    private int ounces;

    public int getOunces(){
        return ounces;
    }

    public String getLidCode(){ //Este es el método sustituido
        return "B"; //El valor por defecto que se retorna
    }
}

.:EOF:.