PDF de programación - Interfaces y clases internas - Piensa en Java

8: Interfaces

y clases internas

Los interfaces y las clases internas proporcionan formas más sofisticadas de or-
ganizar y controlar los objetos de un sistema.

C++, por ejemplo, no contiene estos mecanismos, aunque un programador inteligente podría simu-
larlos. El hecho de que existan en Java indica que se consideraban lo suficientemente importantes
como para proporcionarles soporte directo en forma de palabras clave del lenguaje.

En el Capítulo 7, se aprendió lo relativo a la palabra clave abstract, que permite crear uno o más
métodos sin definición dentro de una clase -se proporciona parte de la interfaz sin proporcionar la
implementación correspondiente, que será creada por sus descendientes. La palabra clave interfa-
ce produce una clase completamente abstracta, que no tiene ningún tipo de implementación. Se
aprenderá que una interfaz es más que una clase abstracta llevada al extremo, pues permite llevar
a cabo una variación de la "herencia múltiple" de C++, creando una clase sobre la que se puede ha-
cer conversión hacia arriba a más de un tipo base.

Al principio, las clases internas parecen como un simple mecanismo de ocultación de código: se ubi-
can clases dentro de otras clases. Se aprenderá, sin embargo, que una clase interna hace más que
esto -conoce y puede comunicarse con las clases que le rodean- y el tipo de código que se pue-
de escribir con clases internas es más elegante y claro, aunque para la mayoría de personas consti-
tuye un concepto nuevo. Lleva algún tiempo habituarse al diseño haciendo uso de clases internas.

Interfaces

La palabra clave interfaz lleva el concepto de abstracción un paso más allá. Se podría pensar que
es una clase abstracta "pura". Permite al creador establecer la forma de una clase: nombres de mé-
todos, listas de parámetros, y tipos de retorno, pero no cuerpos de métodos. Una interfaz también
puede contener campos, pero éstos son implícitamente estáticos y constantes. Una interfaz pro-
porciona sólo la forma, pero no la implementación.

Una interfaz dice: "Ésta es la apariencia que tendrán todas las clases que implementen esta inter-
faz". Por consiguiente, cualquier código que use una interfaz particular sabe qué métodos deberí-
an ser invocados por esa interfaz, y eso es todo. Por tanto se usa la interfaz para establecer un "pro-
tocolo" entre clases. (Algunos lenguajes de programación orientada a objetos tienen la palabra clave
protocolo para hacer lo mismo.)

Para crear una interfaz, se usa la palabra clave interface en vez de la palabra clave class. Al igual
que una clase, se le puede anteponer la palabra public a interface (pero sólo si esa interfaz se de-
finió en un archivo con el mismo nombre), o dejar que se le dé el status de "amistoso" de forma que
sólo se podrá usar dentro del mismo paquete.

256

Piensa en Java

Para hacer una clase que se ajuste a una interfaz particular (o a un grupo de interfaces), se usa la
palabra clave implements. Se está diciendo "La interfaz contiene la apariencia, pero ahora voy a
decir cómo fZcncionaW. Por lo demás, es como la herencia. El diagrama del ejemplo de los instru-
mentos lo muestra:

1

interface instrumento 1
void tocar();
String que();
void ajustar();

1

Viento

1

void tocar()
String que()
void ajustar()

extends

1 Maderaviento 1
void tocar()
String que()

Cuerda

void tocar()
String que()
void ajustar()

void ajustar() 1

void tocar()
String que()

7 extends

void ajustar()

Una vez implementada una interfaz, esa implementación se convierte en una clase ordinaria que
puede extenderse de forma normal.

Se puede elegir manifestar explícitamente las declaraciones de métodos de una interfaz como pú-
blica. Pero son públicas incluso si no se dice. Por tanto, cuando se implementa una interfaz, de-
ben definirse como públicos los métodos de la interfaz. De otra forma, se pondrían por defecto a
"amistoso", y se estaría reduciendo la accesibilidad a un método durante la herencia, lo que no per-
mite el compilador de Java.

Se puede ver esto en la versión modificada del ejemplo Instrumento. Fíjese que todo método de la
interfaz es estrictamente una declaración, que es lo único que permite el compilador. Además, nin-
guno de los métodos de Instrumento se declara como público, pero son público automáti-
camente:

/ / : c08:musica5:Musica5.java
/ / Interf aces .
import java.util.*;

interface Instrumento {

8: lnterfaces y clases internas

257

/ / Tiempo de compilación constante:
int i = 5; / / estático y constante
/ / No puede tener definiciones de métodos:
void tocar ( ) ; / / Automáticamente public
String que ( ) ;
void ajustar ( ) ;

1

class Viento implements Instrumento {

public void tocar ( )

{

System. out .println ("Viento. tocar ( ) " ) ;

1
public String que() { return "Viento"; }
public void ajustar ( )

{ }

1

class Percusion implements Instrumento {

public void tocar ( )

{

System.out.println("Percusion.tocar()");

1
public String que() { return "Percusion"; }
public void ajustar ( )

{ }

class Cuerda implements Instrumento {

public void tocar ( )

{

System. out .println ("Cuerda. tocar ( ) " ) ;

1
public Cuerda que() { return "Cuerda"; ]
public void ajustar ( )

{ }

class Metal extends Viento {

public void tocar ( )

{

System.out .println ("Metal. tocar ( ) " ) ;

}
public void ajustar ( )

{

System.out .println (I1Metal.ajustar ( ) " ) ;

class Maderaviento extends Viento {

public void tocar ( )

{

System.out.println("Maderaviento.tocar()");

258

Piensa en Java

public String que() { return "Maderaviento"; }

public class Musica5 {

/ / No le importa el tipo por lo que los nuevos
/ / tipos que se aniadan al sistema seguirán funcionando bien:
static void afinar (Instrumento i) {

-

/ / -
i.tocar O ;

-



static void afinarTodo (Instrumento [] e) {

for(int i = O; i < e.length; it+)

afinar (e [i] ) ;

1
public static void main (String[] args) {

Instrumento [] orquesta = new Instrumento [5] ;
int i = 0;
/ / Haciendo conversión hacia arriba durante la inserción en el array:
orquesta [i++] = new Viento();
orquesta [itt] = new Percusion ( ) ;
orquesta [i++] = new Cuerda() ; '
orquesta [i++] = new Metal();
orquesta [i++] = new Maderaviento ( ) ;
afinarTodo (orquesta) ;

1

1 / / / : -

El resto del código funciona igual. No importa si se está haciendo un conversión hacia arriba a una
clase "regular" llamada Instrumento, una clase abstracta llamada Instrumento, o a una interfaz
denominada Instrumento. El comportamiento es el mismo. De hecho, se puede ver en el método
afinar( ) que no hay ninguna prueba de que Instrumento sea una clase "regular", una clase abs-
tracta o una interfaz. Esta es la intención: cada enfoque da al programador un control distinto so-
bre la forma de crear y utilizar los objetos.

"Herencia múltiple" en Java
La interfaz no es sólo una forma "más pura" de clase abstracta. Tiene un propósito mayor. Dado
que una interfaz no tiene implementación alguna -es decir, no hay espacio de almacenamiento aso-
ciado con una interfaz- no hay nada que evite que se combinen varias interfaces. Esto es muy va-
lioso, pues hay veces en las que es necesario decir "una x es una a y una b y una c". En C++, a este
acto de combinar múltiples interfaces de clases se le denomina herencia múltiple, y porta un equi-
paje bastante pegajoso porque puede que cada clase tenga una implementación. En Java, se puede
hacer lo mismo, pero sólo una de las clases puede tener una implementación, por lo que los pro-
blemas de C++ no ocurren en Java al combinar múltiples interfaces:

8: lnterfaces y clases internas

259

/

interfaz 1

1

interfaz 2

f

Funciones de la clase base

interfaz 1

interfaz 2

. ' 0 .

...

* m .

0 .

interfaz n

interfaz n

En una clase derivada, no hay obligación de tener una clase base que puede ser abstracta o "con-
creta" (aquélla sin métodos abstractos). Si se hereda desde una no-interfaz, se puede heredar sólo
de una. Todo el resto de elementos base deben ser interfaces. Se colocan todos los nombres de in-
terfaz después de la palabra clave implements, separados por comas. Se pueden tener tantas in-
terfaces como se desee - c a d a uno se convierte en un tipo independiente al que se puede hacer
conversión hacia arriba. El ejemplo siguiente muestra una clase concreta combinada con varias in-
terfaces para producir una nueva clase:

/ / : c08:Aventura.java
/ / Múltiples interfaces.
import java-util. *;

interface PuedeLuchar {

void luchar ( ) ;

1

interface PuedeNadar {

void nadar ( ) ;

1

interface PuedeVolar {

void volar ( ) ;

1

class Persona j eDeAccion {

public void luchar ( )

{ }

1

class Heroe extends PersonajeDeAccion

implements PuedeLuchar, PuedeNadar, PuedeVolar I

I 1
public void nadar 0
public void volar 0 { }

1

public class Aventura {

260

Piensa en Java

static void t (Puedeluchar x) { x. luchar ( ) ; }
static void u (PuedeNadar x) { x.nadar ( ) ; }
static void v(PuedeVo1ar x) { x.volar ( ) ; }
static void w (Personaj eDeAccion x) { x. luchar ( ) ; }
public static void main (String[] args) {

Heroe h = new Heroe ( ) ;
t ( h ) ; / / T r a t a r l o como un PuedeLuchar
u(h); / / T r a t a r l o c o m o u n P u e d e N a d a r
v(h); / / Tratarlo como un PuedeVolar
w (h) ; / / Tratarlo como un PersonajeDeAccion

Se puede ver que Héroe combina la clase concreta PersonajeDeAccion con las interface~
PuedeLuchar, PuedeNadar y PuedeVolar. Cuando se combina una clase concreta con interfaces
de esta manera, hay que