Clases en Java parte 2

Declarar miembros de una clase::

Debido a que las variables y los métodos dentro de una clase utilizan el mismo control de acceso, se tratará a ambos de la misma manera cuando hablemos de los modificadores de acceso.

Mientras que una clase solamente puede utilizar 2 niveles de acceso (público y por defecto), los métodos y variables pueden usar los 4 que son:

+ público (modificador public)
+ por defecto (cuando se omite algún modificador)
+ protegido (modificador protected)
+ privado (modificador private)

Al hablar de que la clase A tiene acceso a un miembro de la clase B (independientemente si es una variable o método) decimos implícitamente que el miembro de B al que se está accesando es 'visible' para A. Cuando se trata de acceder a un miembro que no es visible, el compilador mandará un error y no se podrá ejecutar la aplicación. Para poder entender el comportamiento y acceso de ciertos miembros de una clase debemos entender 2 cosas:

+ Cuándo una clase puede acceder a un miembro de otra.
+ Cuándo una clase puede heredar a otra algún miembro.

Lo primero se refiere a cuando una clase puede acceder al miembro de otra clase por medio del operador punto (.), ya sea para invocar un método o retribuir el valor de una variable. P. ej.:

package paqueteUno;

public class ControlAcceso {

public static void main(String[] args)
{
MiembrosDeClase mdc = new MiembrosDeClase();

System.out.println("Default: "+ mdc.enteroPorDefecto);
System.out.println("Protected: "+ mdc.enteroProtegido);
System.out.println("Default: "+ mdc.enteroPublico);
System.out.println("Private: "+ mdc.enteroPrivado); //1
}
}

class MiembrosDeClase{
public int enteroPublico = 1;
protected int enteroProtegido = 2;
private int enteroPrivado = 3;
int enteroPorDefecto = 4;
}

Si compilamos el código anterior, al llegar a la línea 1, el compilador mandará un error debido a que se quiere acceder a una variable privada desde otra clase...

ControlAcceso.java:26: enteroPrivado has private access in paqueteUno.MiembrosDeClase
System.out.println("Private: "+ mdc.enteroPrivado);
1 error

Si quitamos el código que manda a llamar la variable enteroPrivado no aparecerán errores al momento de compilar y se imprimirán los valores de las variables sin problemas:

Default: 4
Protected: 2
Default: 1

En caso de querer ver el valor de las variables desde una clase fuera del paquete paqueteUno, solo podremos acceder a aquellas marcadas como públicas y protegidas, ya que el control de acceso por defecto solamente proporciona visibilidad a aquellas clases dentro del mismo paquete y los miembros privados solamente pueden ser accedidos desde la misma clase que los define, en pocas palabras:

+ Acceso público (modificador public): Cualquier clase dentro del universo de Java podrá tener acceso a un miembro público.

+ Acceso por defecto (cuando se omite algún modificador): Solamente se podrá acceder a dicho miembro si se pertenece al mismo paquete.

+ Acceso protegido (modificador protected): Solamente se podrá acceder a un miembro protegido cuando se está en el mismo paquete o a través de la herencia.

+ Acceso privado (modificador private): Solo se puede acceder dentro de la misma clase.

Acceso a variables locales::

Las variables locales son aquellas que están declaradas dentro de un método, las variables de instancia son aquellas dentro de la clase pero fuera de los métodos. P.ej.:

public class Variables{
int variableDeInstancia = 1;

public void verVariables(){
int variableLocal = 0;
}
}

Es importante tomar en cuenta que las variables de instancia pueden controlar su acceso con los modificadores que hemos visto anteriormente, sin embargo, las variables locales no, al intentar hacerlo el compilador mandará un error. P.ej.:

public class Variables{
private int variableDeInstancia = 1; //no hay problema

public void verVariables(){
protected int variableLocal = 0; //error!
}
}

El único modificador aplicable a una variable local es final.

Métodos y variables finales::

Anteriormente hemos mencionado cómo es que se comporta una clase marcada con el modificador final, ahora es el turno de los miembros de una clase.

Al marcar un método con el identificador final estamos indicando (al igual que en las clases) que dicho método no puede ser sobreescrito, sino que debe de quedarse tal cual se definió originalmente. P.ej.:

class SuperClase{

public final void metodoFinal(){
//hacer algo
}

}

class SubClase extends SuperClase{

public void metodoFinal(){
//hacer otra cosa
}

}

Al tratar de compilar el código anterior, aparecerá un error que indica que no se puede sobreescribir el método final...

FinalTest.java:5: The method void metodoFinal() declared in class
SubClase cannot override the final method of the same signature
declared in class SuperClase.
Final methods cannot be overridden.
public void metodoFinal() { }
1 error

Así como los métodos, las variables pueden utilizar el modificador final, en su caso, al declarar una variable final significa que no se puede cambiar su valor una vez que fue asignado. P. ej.:

class EjemploVariableFinal{

final int f = 4;

public void cambiarValor(){
f +=2; //error!
}

}

En el código anterior, se define y asigna un valor a la variable final f, posteriormente el método cambiarValor() intenta incrementar el valor de f, al momento de llegar a esta línea, el compilador arrojará un error indicando que no es posible reasignar un valor a una variable final.

Es importante mencionar que cuando se trata de una variable de instancia final(dentro de la clase pero fuera de un método), antes de compilar, se debe de definir su valor, de lo contrario, aparecerá un mensaje de error indicando que no ha sido inicializada, no así con las variables locales.

Métodos abstractos::

Un método abstracto es aquel que se define dentro de una clase pero no se especifica su comportamiento, en lugar de utilizar llaves para definir el código de su comportamiento de finaliza su declaración con un punto y coma (;). Se definen métodos abstractos cuando se quiere forzar a todas las clases que heredan de la clase que tiene dicho método a implementar cierto comportamiento. P. ej.:

public abstract void metodoAbstracto();

Cuando se define al menos un método abstracto dentro de una clase, la clase debe a su vez ser abstracta, de lo contrario el compilador arrojará un error. Asimismo, una clase abstracta podrá no tener ningún método abstracto. Una clase que herede a otra clase abstracta, debe de implementar todos los métodos abstractos de la clase heredada, a menos de que la clase que está heredando sea a su vez abstracta. La regla es la siguiente:

"La primera clase no abstracta que herede a una clase abstracta deberá definir todos los métodos abstractos que le han sido heredados".

En caso de que una clase no abstracta no implemente los métodos abstractos definidos en su superclase habrá un error de compilación.

Por último, nunca se debe de utilizar el modificador abstract con el modificador static...

abstract static void metodo();

...ya que de igual manera habrá un error al momento de compilar.

Hasta aquí le dejamos con este tema. ¿Alguna duda? deja tu comentario.

Más sobre programación en Java aquí.