Clases contra Interfaces

Clases

Las clases son plantillas de objetos. Definen el tipo de objetos, que datos que contendrá y

los métodos para operar con esos datos. Un ejemplar de esa clase es la plantilla rellena con

los datos y las llamadas a los métodos-- el ejemplar (copia) es el objeto.

Podemos crear muchos ejemplares de la misma clase, creando muchos objetos de ese tipo.

Cada objeto tiene sus propios datos, y algunos objetos comparten datos específicos,

dependiendo de si han sido declarados datos static o instancias. Esto lo explique con el

ejemplo de valor y referencia para determinar la dimensión de una matriz.

Creación de varios ejemplares de clase, por medio de instancia. Donde los parámetros se

utilizan por valor.

En este caso se elabora clase abtrascta con datos static, donde se siempre se solicitan los

datos de la dimensión matriz y se almacenan en una referencia de memoria, no es necesario

instanciar.

Herencia

No tenemos que escribir una clase desde el principio. Si ya existe una clase que tiene

características similares a la que queremos crear, podemos usar la palabra clave extends

para heredar campos y métodos desde otra clase. Luego añadimos mas campos y métodos

para crear una clase más rica que la clase padre. Pero no tenemos que conformarnos con los

campos o métodos heredados. Podemos sobreescribir métodos(Polimorfismo), u ocultar

datos de las clases padre(Encapsulamineto) para cumplir con nuestras necesidades.

Cada vez que se tiene una clase que hereda un método de una superclase, se tiene la

oportunidad de sobreescribir el método (a menos que dicho método esté marcado como

final). El beneficio clave al sobreescribir un método heredado es la habilidad de definir un

comportamiento específico para los objetos de la subclase. Veamos un ejemplo de la

sobreescritura de un método heredado:

public class Animal {

public void comer () { System.out.println("Animal comiendo..."); }

} class Caballo extends Animal { public void comer() { System.out.println("Caballo comiendo..."); } }

Al momento de que Caballo hereda de la clase Animal obtiene el método comer() definido

en Animal, sin embargo, se desea especificar un poco más el comportamiento de Caballo

al momento de llamar a comer(), por lo tanto se define un método con el mismo nombre

dentro de la clase Caballo. Debido a que ambos métodos tienen el mismo nombre, para

saber qué método se invocará en tiempo de ejecución es necesario saber a qué objeto se está

refiriendo. P. ej.:

public static void main(String... args) { Animal a = new Animal(); Caballo c = new Caballo();

a.comer(); c.comer();

}

Esto es cierto para clases concretas, pero no para los interfaces.

Interfaces

Los interfaces declaran métodos, y posiblemente campos estáticos, pero no definen

métodos. En su lugar, los interfaces sólo declaran los métodos sin ninguna instrucción

dentro de ellos. En otras palabras, los interfaces son como plantillas que siempre serán

plantillas. No podemos ejemplarizar un interface para crear un objeto. Son como clases sin

implementación. ¿Entonces por qué existen?

Sirven para un propósito: para forzar al desarrollador a proporcionar esos métodos, con

detalles, en la clase que implements el interface. En otras palabras, implementar un

interface significa que estamos haciendo la promesa de usar ciertos métodos, pero nosotros,

los desarrolladores, definimos los detalles de esos métodos.

¿Por qué es esto útil o necesario?

Supongamos que tenemos un equipo de desarrolladores que están creando clases para hacer

diferentes tipos de objetos animales. Todos esos animales van a tener dos cosas en común:

Usan alguna foma de locomoción.

Comen alguna clase de comida.

La diferencia entre los animales está en cómo se mueven y qué y cómo comen. En otras

palabras, cada uno necesita tener los métodos locomotion() y eat() , pero cada individuo,

cada clase animal, define los detalles de esos métodos separadametne basándose en las

necesidades de las especies de animales.

Diseñamos un interface para asegurarnos de que cada objeto animal hace ciertas cosas, y

nuestro equipo desarrolla clases como ésta:

En el interface Animal, los métodos están declarados, pero no definidos. Observa que esos

métodos (en azul) están definidos en clases concretas Shark y Dog . En el ejemplo de

arriba, cada método imprime una línea de texto, indicando lo que come el animal y como se

mueve desde un lugar a otro. La última clase es una aplicación que inicializa las dos clases

concretas Shark y Dog , y llama a los métodos de esas clases, usando el operador punto.

Cuando compilamos y ejecutamos AnimalTest , obtenemos el siguiente resultado:

I swim. I hunt for seals. I run on four legs. I eat kibble.

Los juegos son otro ejemplo de cómo podríamos implementar interfaces. Por ejemplo,

podríamos diseñar los siguientes juegos: Water Pistol Wars, Asteroid Archery, Rubberband

Rally, y Cannon Craze. Todos implican armas de fuego, pero las armas y lo que disparan

son diferentes. Un interface se podría asegurar de que todo juego implemente un método

fire() , pero es cosa de cada diseñador del juego la forma de disparar y el tipo de munición

utilizada.