Clases e interfaces en Java

Cuando se escribe código en Java, se están escribiendo clases e interfaces. Dentro de dichas clases, los métodos y las variables, además de algunas otras pocas cosas. El cómo se declaran las clases, interfaces, métodos y variables afecta dramáticamente el comportamiento del código. Por ejemplo, un método marcado como público (public) puede ser accesado desde cualquier parte de la aplicación, no así cuando es privado (private). Analicemos entonces poco a poco la declaración de clases en Java.

Reglas para declarar archivos fuente::

Antes de infiltrarnos en el extenso mundo de las clases, veamos una serie de reglas importantes asociadas con la declaración de clases, sentencias import y package en un código fuente:

+ Sólo puede haber una clase pública por cada archivo fuente.
+ Los comentarios pueden aparecer en el principio o final de cualquier línea de código, son independientes de las reglas que se mencionan.
+ Si existe una clase pública en un archivo, el nombre del archivo debe de coincidir con el nombre de dicha clase.
+ Si una clase es parte de un paquete, la sentencia package debe de aparecer en la primera línea de código, antes de cualquier sentencia import o declaración de clases y métodos.
+ Si existen sentencias import, debe de aparecer después de la declaración del paquete (en caso de haber alguno) y antes de la declaración de la(s) clase(s). Si no hay una declaración de paquete, la sentencia import debe de ser la primera en aparecer en el código. Si no hay sentencias package o import, la declaración de la clase debe de aparecer primero.
+ Las declaraciones de paquete e import aplican para todas las clases nombradas en un archivo, no es posible tener varias clases en un archivo y que cada clase pertenezca a un paquete diferente o utilice diferentes import's.
+ Un archivo puede tener más de una clase NO pública.
+ Un archivo sin clases públicas puede tener cualquier nombre, aunque no coincida con el nombre de ninguna de sus clases.

Declaraciones de clases y modificadores::

La declaración general de una clase se hace de la siguiente manera:

class NombreDeMiClase { }

Además de lo anterior puedes agregar modificadores antes del nombre de la misma. Los tipos de modificadores (no todos aplicables a una clase) son:

1. Modificadores de acceso: public, protected, private.
2. Modificadores que no son de acceso: strictfp, final y abstract.

Los modificadores de acceso nos ayudan a restringir-permitir el acceso a una clase, métodos, variables, etc. que se ha creado. Existen 4 niveles de acceso pero solo 3 modificadores de acceso, el cuarto nivel de acceso que no está representado con ningún nombre de modificador es aquel que se obtiene cuando no estableces ningún modificador de acceso (llamado el acceso por defecto o default). En otras palabras, todas y cada una de las clases y componentes de las mismas en Java tienen control de acceso, independientemente si lo estableces manualmente o no.

Acceso a las clases::

Qué significa acceder a una clase? Cuando decimos que el código de una clase A tiene acceso a otra clase B, significa que A hizo una de tres cosas:

+ Creó una instancia de la clase B.
+ Extendió o heredó a la clase B (A es una subclase de B).
+ Accedió a ciertos métodos dentro de la clase B, dependiendo del control de acceso de dichos métodos y variables.

Acceso significa 'visibilidad'. Para que A pueda usar el código de B tiene que poder 'verlo', para ello son los modificadores de acceso que describiré a continuación:

Acceso por defecto (modificador default): Una clase con control de acceso por defecto significa una de dos cosas:

+ Se omitió la especificación de un modificador de acceso.
+ Se escribió la palabra default como modificador de acceso.

El control de acceso por defecto brinda un control a nivel de paquete, es decir, solo las clases dentro del mismo paquete podrán acceder a los métodos, variables y demás cuestiones definidas dentro de la clase. P. ej.: Si A está en el paquete Uno y B está en el paquete Dos, entonces no hay manera de que B sepa de la existencia de A cuando A tiene control de acceso por defecto. Si se trata de utilizar una A dentro de B, el compilador arrojará un error.

Acceso público (modificador public): Una declaración de una clase pública proporciona el acceso a todas las clases de todos los paquetes, todas las clases en el Universo Java (JU) tienen acceso a una clase pública. No debemos olvidar que, aunque se trate de una clase pública, aún necesitamos importar el paquete en el que se encuentra (en caso de que tratemos de acceder a ella desde un paquete distinto) para que podamos utilizarla. P. Ej.:

Código de la clase MiClaseA:---

package paqueteUno;

public class MiClaseA {
//métodos y comportamiento de la clase
}

Código de la clase MiClaseB:---

package paqueteDos;

import paqueteUno.MiClaseA;

public class MiClaseB{
//métodos y comportamiento de la clase
}

Es importante mencionar que en el código de MiClaseB podemos sustituir import paqueteUno.MiClaseA; por import paqueteUno.*; para poder así importar todas las clases dentro de paqueteUno.

Otros modificadores::

Existen otros modificadores que no controlan el acceso a la clase pero sí el cómo es que esta se comporta al momento de ser extendida o instanciada. Estos modificadores son: final y abstract. Analicemos un poco la función de cada uno de ellos.

Nota: el modificador strictfp es utilizado muy pero muy poco y no es de suma utilidad, por lo cual no ahondaremos en describir su función.

Clases finales (modificador final): Cuando el modificador final es utilizado en la declaración de una clase, significa que dicha clase no puede ser heredada, es decir, que no puede haber subclases de dicha clase, y para utilizarla debemos de crear una instancia de la misma. Esto se utiliza normalmente cuando queremos que los métodos y función de nuestra clase se queden tal como están, sin que haya otra clase que herede el comportamiento de la que acabamos de definir ni pueda sobreescribir los métodos que contiene. Muchas clases en Java son finales, un ejemplo es la clase String que no puede ser heredada, imaginemos un poco la situación en caso de que pudieramos sobreescribir los métodos de la importantísima clase String, si lo hacemos de manera irresponsable estaríamos afectando el comportamiento tal vez no solo de una clase o una aplicación, sino de todas aquellas clases que utilicen los métodos definidos por String.

Clases abstractas (modificador abstract): Contrario al modificador final, abstract indica que una clase no puede ser instanciada sino que su única razón de existir es ser heredada. Un ejemplo de la utilidad de una clase abstracta podría ser la clase Carro, sabemos que todos los carros tienen características generales que los describen, sin embargo, existen ciertas cosas que distinguen a uno de otro, como la marca, modelo, número de vehículo, etc. Por ello, podríamos definir una clase abstracta Carro, que define métodos y variables que cualquier carro puede poseer pero que necesita de alguna otra información que distinga a un carro de otro.

En este punto es importante hablar un poco más a fondo de las interfaces, anteriormente he mencionado información general sobre ellas pero ahora que hemos tocado el modificador abstract es posible que las interfaces se vuelvan un poquito más fáciles de entender.

Interfaces::

Una interfaz es una plantilla que define métodos acerca de lo que puede o no hacer una clase, se puede definir meramente como una clase abstracta al 100%, por ejemplo, si definimos la interfaz Animal, podremos deducir que todos los animales pueden comer, respirar, etc. pero puede ser que cada uno lo haga de manera diferente, por ello, en la interfaz definimos el comportamiento que todos los animales pueden tener pero no el cómo hacen las cosas ya que cada animal lo realiza de manera diferente. En código se traduce así:

interface Animal{
void comer();
int respirar();
}

class Perro implements Animal{

public void comer(){
//definimos cómo come el perro
}

public int respirar(){
//definimos cómo respira el perro
}

public String ladrar(){
//definimos un método exclusivo del perro
}

}

Como podemos observar en el código anterior, en la interfaz existen un par de métodos que definen lo que cualquier animal puede hacer, pero no especificamos cómo es que lo hace, dentro de la clase Perro que implementa la interfaz Animal es que hemos sobreescrito los métodos que se definieron en la interfaz y le dimos un comportamiento un poco más específico de un perro, así mismo, creamos el método ladrar() en el cual se describe cómo es que un perro ladra, dicho método no fue definido en la interfaz Animal por que no todos los animales ladran.

Es importante mencionar algunos puntos importantes con respecto a las interfaces:

+ Todos los métodos de una interfaz son abstractos y deben de ser sobreescritos por la clase que implemente dicha interfaz, asimismo, todos los métodos de una interfaz son públicos, independientemente si se ha especificado manualmente o no con los modificadores public y abstract.

+ Todas las variables contenidas en una interfaz deben ser públicas, estáticas y finales, no existen variables de instancia dentro de una interfaz.
+ Los métodos de una interfaz NO deben ser estáticos.
+ Debido a que los métodos de una interfaz son abstractos, NO deben ser marcados finales.
+ Una interfaz puede extender una o más interfaces.
+ Una interfaz no puede extender o heredar nada que no sea una interfaz.
+ Una interfaz no puede implementar nada.
+ Una interfaz se define con la palabra interface.
+ Las interfaces pueden usadas polimórficamente.

Declarar constantes dentro de interfaces::

Es posible alojar constantes dentro de las interfaces, al hacerlo, se garantiza que todas las clases que implementen dicha interfaz tendrán acceso a la misma constante. Al momento de declarar una constante, esta implícitamente es pública, estática y final, aunque no se especifíque manualmente con los modificadores public, static y final, debido a lo anterior, es imposible cambiar el valor de una constante declarada dentro de una interfaz, al intentar hacerlo, el compilador arrojará un error. P. ej.:

interface MiInterfaz{
int CONST = 12;
void hacerAlgo();
}

class MiClase implements MiInterfaz{
public void hacerAlgo{
CONST = 14;//al llegar a esta línea aparecerá el error
}
}

Hasta aquí le dejamos en este artículo. ¿Alguna duda? Deja tu comentario.

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