Módulo 8: INTERFACES

Transcripción

1 Módulo 8: INTERFACES 8-1

2 SUMARIO INTERFACES 1 SUMARIO INTRODUCCIÓN A LOS INTERFACES EN JAVA UTILIZACIÓN DE INTERFACES EN JAVA COMBINACIÓN DE INTERFACES: HERENCIA MÚLTIPLE EN JAVA5 8.4 INTERFACES Y HERENCIA 8 F. Liberal Malaina 8-2

3 8.1 INTRODUCCIÓN A LOS INTERFACES EN JAVA En el capítulo relativo a la herencia se describió cómo la utilización de clases abstractas permitía definir el comportamiento común de una jerarquía de clases. Esto se conseguía al tener que implementar los métodos abstractos en las subclases y dotarles así de un comportamiento específico, al mismo tiempo que se respetaba el formato común (nombre del método, argumentos, etc.). Definiendo métodos abstractos o incompletos en una clase abstracta, y dejando su implementación para sus descendientes se forzaban en definitiva una serie de características comunes a todas las subclases de la jerarquía. De una forma análoga a las clases abstractas, un interfaz en Java define un protocolo o modelo de comportamiento. Para ello, una vez más, se definirán una serie de métodos pero no su implementación. De hecho básicamente un interfaz en Java (según la propia definición dada por Sun) consiste en un conjunto de definiciones de métodos sin implementación al que se asigna un nombre concreto. Dado que en esencia un interfaz consiste en una serie de métodos sin implementación, esto es, abstractos; cuáles son entonces las diferencias entre la utilización de interfaces y de clases abstractas?. Para responder esa pregunta cabe pensar cuáles son las carencias que obligaron a introducir el concepto de interfaces al definir el lenguaje Java, un concepto que, por otra parte, no aparece en otros lenguajes orientados a objetos: El comportamiento asociado a una clase abstracta únicamente se transmite por el mecanismo de herencia. Es decir, para que una clase comparta un determinado comportamiento debe ser necesariamente una subclase de la clase abstracta que define el comportamiento (debe encontrarse en la misma jerarquía de clases). Esto obliga a que las clases que deseen presentar un comportamiento común deban ser clases muy relacionadas (parientes). La carencia anterior se ve agravada por el hecho de que la herencia en Java es simple, con lo cual solamente se puede heredar un comportamiento, el de la superclase (o sus ancestros). Frente a esas carencias, un interfaz permite definir un comportamiento que puede ser implementado por cualquier clase, independientemente de la jerarquía a la que pertenezca ya que NO es la herencia el mecanismo de transmisión del comportamiento. Esto permite que clases con poca relación entre sí (no pertenecientes a una jerarquía común) puedan compartir parte de dicho comportamiento. Además, una clase puede implementar varios interfaces, lo cual soluciona el agravante que introducía la herencia simple de java a la utilización de clases abstractas. Por el contrario, aparecen nuevos condicionantes: en un interfaz no se puede implementar ningún método, al contrario que sucedía en las clases abstractas y aunque pueden contener datos miembro, éstos deben ser estáticos y constantes. F. Liberal Malaina 8-3

4 8.2 UTILIZACIÓN DE INTERFACES EN JAVA Para definir un interfaz en Java se utiliza la palabra reservada interface. A interface se le suele añadir el modificador public para permitir que lo utilicen clases fuera del paquete. De forma paralela, para indicar que una clase va a soportar o ajustarse a un determinado interfaz se utiliza la palabra reservada implements seguida del nombre del interfaz en la definición de la clase. En el código que se muestra a continuación se va a utilizar el concepto de interfaz para definir el comportamiento relacionado con un Vehículo. A continuación, se definirán una serie de clases que proporcionen ese interfaz. //<Vehiculo.java> public interface Vehiculo { int ARRANCADO=0; int PARADO=1; DATOS CONSTANTES A PESAR DE QUE NO SE DECLAREN EXPLÍCITAMENTE COMO TALES public void arrancar(); public void acelerar(float incremento); public void frenar(float decremento); public float obtenervelocidadactual(); public void parar(); TODOS LOS MÉTODOS DEFINIDOS PERO SIN IMPLEMENTACIÓN A continuación dos clases que implementan el interfaz Vehículo: Avion y Motocicleta. Se pueden observar las distintas implementaciones de los métodos en función de las características propias de cada tipo. F. Liberal Malaina 8-4

5 //<Motocicleta.java> public class Motocicleta implements Vehiculo { public static float CONSTANTE_FRENADA=2.123f; public static float CONSTANTE_ACELERACION=3.42f; protected int estado=parado; protected float velocidadactual=0; public int numruedas=2; public int potencia=200; //en CV public int cilindrada=500; //en cc protected int marchaactual=0; public void arrancar(){ cambiarmarcha(1); acelerar(10); estado=arrancado; velocidadactual=10; public void acelerar(float incremento){ giraracelerador(incremento/constante_aceleracion); velocidadactual+=incremento; public void frenar(float decremento){ apretarfrenosdisco(decremento/constante_frenada); velocidadactual-=decremento; public float obtenervelocidadactual(){ return velocidadactual; public void parar(){ frenar(obtenervelocidadactual()); estado=parado; protected void giraracelerador(float angulo){ //operaciones para girar acelerador protected void apretarfrenosdisco(float presion){ //operaciones para apretarfrenos protected void cambiarmarcha(int marcha){ //operaciones para cambio de marcha marchaactual=marcha; //<Avion.java> public class Avion implements Vehiculo{ public static float CONSTANTE_FRENADA=12.1f; public static float CONSTANTE_ACELERACION=12.1f; public static float ARRANQUE_INICIAL=123.12f; public static int NUM_MAX_MOTORES=6; protected int estado=parado; protected float velocidadactual=0; public int nummotores=2; public long potencia=120000; //en CV public long rpmactual[]; public Avion(){ rpmactual=new long [Avion.NUM_MAX_MOTORES]; public Avion(int motores){ nummotores=motores; rpmactual=new long [motores]; public void arrancar(){ for(int i=0; i <nummotores;i++){ empujarpalancamotor(i,arranque_inicial); estado=arrancado; velocidadactual=0; public void acelerar(float incremento){ for(int i=0; i <nummotores;i++){ empujarpalancamotor(i,incremento/constante_aceleracion); velocidadactual+=incremento; public void frenar(float decremento){ for(int i=0; i <nummotores;i++){ empujarpalancamotor(i,-(decremento/constante_frenada)); velocidadactual-=decremento; public float obtenervelocidadactual(){ return velocidadactual; public void parar(){ // Maniobra de acercamiento, sacar FLAPS..., estado=parado; protected void apretaracelerador(float presion){ //operaciones para girar acelerador protected void empujarpalancamotor(int nummotor,float desplamiento){ //Operaciones para empujar palanca 8.3 COMBINACIÓN DE INTERFACES: HERENCIA MÚLTIPLE EN JAVA Como se ha comentado en la introducción de este capítulo, los interfaces se introducen en Java, en parte, para suplir las carencias de la herencia simple. Dado que puede resultar útil que una clase presente varios comportamientos pero no se puede conseguir directamente con clases abstractas (al transmitirse el comportamiento a través de la herencia) aparece el mecanismo de combinación de interfaces. Imaginemos por un momento que estamos diseñando un videojuego de estrategia en tiempo real en el que podemos manejar diferentes Vehículos. La mayoría de los vehículos se utilizan para el transporte de equipamiento, el soporte a las tropas etc (Coche, Motocicleta, Avion ) Alguna de las fases del juego permiten que el jugador controle ciertas armas para defender a su ejército virtual (Cañones, Ametralladoras, ). Para unificar el manejo de las distintas armas se define un nuevo interfaz Armas, con las operaciones más comunes (apuntar, disparar, cargar ). F. Liberal Malaina 8-5

6 //<Arma.java> package armas; public interface Arma { public void cargar(); public void apuntar(float param1, float param2, float param3); public void disparar(int numproyectiles, int tipoproyectil); public void descargar(); En ciertas fases de la campaña militar, el usuario puede utilizar aviones de combate. Nos encontramos entonces ante el dilema de cómo gestionar dichos elementos. Por una parte se trata de un vehículo y cómo tal debe mantener el interfaz proporcionado por Vehículo, puesto que el jugador ya lo ha utilizado para el manejo de aviones de transporte. Por otro lado debe ser capaz de utilizar el interfaz Arma ya que es el interfaz definido para ese tipo de objetos. Sin embargo, no tiene sentido definir una clase abstracta con los dos comportamientos puesto que en principio son comportamientos que tienen poco que ver, únicamente sería por tanto válido para unas pocas clases concretas como AvionCombate, Tanque. La solución es declarar una nueva clase AvionCombate que proporcione ambos interfaces. F. Liberal Malaina 8-6

7 //<AvionCombate.java> import armas.*; public class AvionCombate implements Vehiculo,Arma{ public static float CONSTANTE_FRENADA=12.1f; public static float CONSTANTE_ACELERACION=12.1f; public static float ARRANQUE_INICIAL=123.12f; public static int NUM_MAX_MOTORES=6; protected int estado=parado; protected float velocidadactual=0; public int nummotores=2; public long potencia=120000; //en CV public long rpmactual[]; public void arrancar(){ public void acelerar(float incremento){ public void frenar(float decremento){ public float obtenervelocidadactual(){ return 0; public void parar(){ public void cargar(){ //cogermisildeposito(); //insertarmisirconducto(); public void apuntar(float param1, float param2, float param3){ //moverlocalizadorlaser(param1,param2,param3); //programarmisil(); public void disparar(int numproyectiles, int tipoproyectil){ //mandarordendisparo(numproyectiles,tipoproyectil); //actualizarcontadorproyectiles,tipoproyectil); public void descargar(){ //retirarresiduosmisil(); //actualizarcontadorproyectiles,tipoproyectil); La clase AvionCombate permite ilustrar cómo se pueden utilizar varios interfaces para combinar comportamientos. Sin embargo, si comparamos esa clase con Avion vemos como ha sido necesario reimplementar los métodos relativos al interfaz Vehículo. Evidentemente, esa duplicación de código no es admisible más que a modo de ejemplo. Una solución mucho más elegante y que ilustra la utilización conjunta de herencia e interfaces consistiría en crear una clase AvionCombateHeredado que herede de Avion (con lo cual hereda los métodos que se mantienen igual) y que añada las características del interfaz Arma. F. Liberal Malaina 8-7

8 //<AvionCombateHeredado.java> import armas.*; public class AvionCombateHeredado extends Avion implements Arma{ public AvionCombateHeredado() { super(); public AvionCombateHeredado(int motores) { super(motores); public void cargar(){ //cogermisildeposito(); //insertarmisirconducto(); public void apuntar(float param1, float param2, float param3){ //moverlocalizadorlaser(param1,param2,param3); //programarmisil(); public void disparar(int numproyectiles, int tipoproyectil){ //mandarordendisparo(numproyectiles,tipoproyectil); //actualizarcontadorproyectiles,tipoproyectil); public void descargar(){ //retirarresiduosmisil(); //actualizarcontadorproyectiles,tipoproyectil); 8.4 INTERFACES Y HERENCIA Los interfaces se comportan de forma similar a las clases a la hora de realizar operaciones de herencia. Cada nuevo método que incorpore cada subinterfaz deberá ser añadido a los del superinterfaz e implementados por toda clase que lo implemente. Vemos en el código cómo desde cada método se puede acceder a cualquier variable (realmente constantes) definidas en los superinterfaces, puesto que la clase al implementar el subinterfaz de más bajo nivel ya conoce todas ellas. El resultado del código de la página siguiente es el que se muestra en la figura: F. Liberal Malaina 8-8

9 //<SuperInterfaz.java> package interfaces; public interface SuperInterfaz { int variablesuperinterfaz=0; public void metodosuperinterfaz(); //<SubInterfaz.java> package interfaces; public interface SubInterfaz extends SuperInterfaz { int variablesubinterfaz=1; public void metodosubinterfaz(); //<SubSubInterfaz.java> package interfaces; public interface SubSubInterfaz extends SubInterfaz { int variablesubsubinterfaz=2; public void metodosubsubinterfaz(); //<LanzadorInterfaces.java> package interfaces; public class LanzadorInterfaces implements SubSubInterfaz { public void metodosuperinterfaz(){ System.out.println(" SuperInterfaz: Variable SuperInterfaz: "+variablesuperinterfaz); System.out.println(" SuperInterfaz: Variable SubInterfaz: "+variablesubinterfaz); System.out.println(" SuperInterfaz: Variable SubSubInterfaz: "+variablesubsubinterfaz); public void metodosubinterfaz(){ System.out.println(" SubInterfaz: Variable SuperInterfaz: "+variablesuperinterfaz); System.out.println(" SubInterfaz: Variable SubInterfaz: "+variablesubinterfaz); System.out.println(" SubInterfaz: Variable SubSubInterfaz: "+variablesubsubinterfaz); public void metodosubsubinterfaz(){ System.out.println(" SubSubInterfaz: Variable SuperInterfaz: "+variablesuperinterfaz); System.out.println(" SubSubInterfaz: Variable SubInterfaz: "+variablesubinterfaz); System.out.println(" SubSubInterfaz: Variable SubSubInterfaz: "+variablesubsubinterfaz); public static void main(string[] args) { LanzadorInterfaces arrancar=new LanzadorInterfaces(); arrancar.metodosuperinterfaz(); arrancar.metodosubinterfaz(); arrancar.metodosubsubinterfaz(); F. Liberal Malaina 8-9