pydoo5 (hasta aca parcial)

Universidad Nacional de Tierra del Fuego A.I.A.S

Lenguaje JavaInterfaces

La palabra interface lleva el concepto de clase abstracta un paso más adelante. Se la puede pensar como una clase abstracta “pura”.Permite al creador estaclecer la forma para la clase: nombres de métodos, listas de argumentos y tipos de retorno, pero no cuerpos de métodos.

Una interface puede contener campos, pero ellos son implícitamente static y final. La interface provee la forma, pero no la implementación.

La interface dice: “Así es como se verán las clases que implementen esta interface en particular”. La interface es usada para establecer un protocolo entre clases.Para crear una interface se usa la palabra clave interface en lugar de class y para hacer una clase de este tipo se utiliza la palabra implements.


Lenguaje Java


Lenguaje Java

Se puede elegir declarar explícitamente como públicos los métodos en una interface. Pero ellos son public aunque no se los declare. La interface no puede tener datos miembro variables. Todos se interpretan como ctes. y son interpretados como public, static y final. Deben ser inicializados. De manera que cuando se implemente una interface, los métodos desde la interface deben ser definidos como public.


Lenguaje Javaimport java.util.*

interface Instrumento {int i = 5; // static y final// los métodos son automáticamente públicosvoid play();String queSoy();void ajustar();

}class Viento implements Instrumento {

public void play() {System.out.println(“Wind.play()”);

}public String queSoy () { return “Wind”; }public void ajustar() { }

}


Lenguaje Javaclass Percusion implements Instrumento {

public void play() {System.out.println(“Percusion.play()”);

}public String queSoy () { return “Percusion”; }public void ajustar() { }

}class Cuerda implements Instrumento {

public void play() {System.out.println(“Cuerda.play()”);

}public String queSoy () { return “Cuerda”; }public void ajustar() { }

}


Lenguaje Javaclass Bronce extends Viento {

public void play() {System.out.println(“Bronce.play()”);

}public void ajustar() {

System.out.println(“Bronce.ajustar()”);}

}class Madera extends Viento {

public void play() {System.out.println(“Madera.play()”);

}public String queSoy() { return “Madera”; }

}


Lenguaje Javapublic class MusicaInterface {

static void tune(Instrumento i) {//.......i.play();

}static void tuneAll(Instrumento[ ] e) {

for (int i=0; i< e.length(); i++)tune(e[i]); }

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

Instrumento[] orquesta = new Instrumento[5];int i=0;// upcasting durante la adición al arregloorquesta[i++] = new Wind();orquesta[i++] = new Percusion();orquesta[i++] = new Cuerda();orquesta[i++] = new Bronce();orquesta[i++] = new Madera();tuneAll(orquesta);

}}


Lenguaje Java

El código funciona igual si se está haciendo “upcasting” a una clase regular, a una clase abstracta o a una interface, pero cada enfoque le da al programador diferente control sobre el modo en que los objetos son creados y usados.


Lenguaje JavaHerencia múltiple

Hemos visto cómo se puede modelar el mundo en objetos como un conjunto de clases interactuando. Las clases pueden relacionarse por una variedad de asociaciones, incluyendo tiene-un (composición), usa-un y crea-un.

Una de las asociaciones más utilizadas es la relación es-un en la cual como vimos, una clase es una especialización de otra.

La que vimos hasta ahora se llama herencia simple:


Lenguaje JavaA veces se encuentra que una clase pertenece a dos (o más) jerarquías de herencia. Por ejemplo, la calandria en aplicaciones de negocios de venta de mascotas, es un producto.

Algunos lenguajes, como C++, permiten implementar directamente la herencia múltiple. Si bien es una técnica muy potente, suele ser causa de problemas. Cómo hace Java para que un programador pueda utilizar el concepto de herencia múltiple? La solución es el uso de interfaces.


Lenguaje Java“Herencia Múltiple” en Java

El propósito del uso de interfaces en Java es proveer un mecanismo de herencia múltiple, ya que el lenguaje no posee la capacidad instalada para este concepto, como sí lo hace C++.

A veces hace falta decir que “una x es una z y una b y una c” y esto se consigue combinando muchas interfaces.

Una interface se comporta como si fuera una clase abstracta en la cual cada método es abstracto. A diferencia de la clase abstracta, se puede agregar una interface a una clase que ya es parte de una diferente jerarquía de herencia. La implementación de los métodos estará en la clase y no en la interface.


Lenguaje JavaEn el ejemplo anterior, la clase Calandria hereda en la jerarquía de la clase Pájaro e implementa la interface Producto.

Public class Calandria extends Pajaro implements Producto {

////........}

En una clase derivada, se puede heredar sólo de una clase base abstracta o concreta. Si se necesitan características de otras clases, éstas deben ser interfaces.

Se colocan todos los nombres de interfaces después de la palabra implements y se los separa con comas. Se puede tener tantas interfaces como se quiera.


Lenguaje Java

import java.util.*

interface Peleador{void pelea();

}interface Nadador{

void nada();}interface Volador{

void vuela();}

class PersonajeAccion{public void pelea() {... };

}

class SuperHeroe extends PersonajeAccion

implements Peleador, Nadador, Volador{

public void nada() {...}public void vuela() {...}

}


Lenguaje Javapublic class Aventura {

static void a(Peleador x) { x.pelea(); }static void b(Nadador x) { x.nada(); }static void c(Volador x) { x.vuela(); }static void d(PersonajeAccion x) { x.pelea(); }public static void main(String[] args) {

SuperHeroe sh = new SuperHeroe();a(sh); // trata a sh como un Peleadorb(sh); // trata a sh como un Nadadorc(sh); // trata a sh como un Voladord(sh); // trata a sh como un PersonajeAccion

}}Se puede ver que la clase SuperHeroe combina la clase concreta PersonajeAccion con las interfaces Volador, Peleador, Nadador.

En la combinación, la clase concreta se coloca primero y después las interfaces.


Lenguaje JavaCuando se quiere crear un objeto de un nuevo tipo, heredando de una interface, éste debe ser de una clase que tenga todas las definiciones. Si falta alguna, es a su vez una interface y no se puede crear un objeto.

En el caso de SuperHeroe, aunque no se da la definición de pelea() en la clase, esta definición le es provista por PersonajeAccion y por esa razón se pueden crear objetos de SuperHeroe.

En la clase Aventura, hay cuatro métodos que toman como argumentos las clases interfaces y concretas.Cuando se crea un objeto SuperHeroe, puede ser pasado como argumento a cualquiera de estos métodos, lo cual significa que está siendo upcast a cada interface en turno.

Cuando se puede elegir entre usar clases abstractas o interfaces, conviene optar por éstas últimas, ya que proveen mayor funcionalidad.Se debe tratar de usar diferentes nombres de métodos en interfaces que serán combinadas.


Lenguaje JavaExtensión de una interface con herencia

Se puede agregar nuevas declaraciones de métodos a una interface usando herencia y se puede combinar muchas interfaces en una nueva interface con herencia. En ambos casos, se obtiene una nueva interface.

interface Monstruo {void amenaza();

}interface MonstruoPeligroso extends Monstruo {

void destruye();}interface Letal {

void asesina();}


Lenguaje Javaclass Dragon implements MonstruoPeligroso{

public void amenaza() { }public void destruye() { }

}interface Vampiro

extends MonstruoPeligroso, Letal {void bebeSangre();

}class ShowTerror {

static void u(Monstruo b) { b.amenaza(); }static void v(MonstruoPeligroso d) {

d.amenaza();d.destruye();

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

Dragon ef = new Dragon();u(ef);v(ef);

}}


Lenguaje Java

MonstruoPeligroso es una extensión de Monstruo que produce una nueva interface. Es implementada en Dragón.

La sintaxis usada en Vampiro trabaja solamente cuando se heredan interfaces.

Los campos definidos en las interfaces son automáticamente static y final.Pueden ser inicializados con expresiones no constantes.

La jerarquía de clases y la jerarquía de interfaces son completamente separadas. Las relaciones permitidas son: Una clase puede extender una clase, una interface puede extender una interface y una clase puede implementar una interface.

Notar que muchas veces se utilizan adjetivos, para nombrar las interfaces. Esto sucede cuando en realidad son distintas características o estados de la clase base.


Lenguaje Java

Ejemplo: Dada la siguiente Jerarquía de clases, qué clase sería abstracta, cuál concreta y cuál se puede implementar como interface?


Lenguaje Java

interface Producto {public short getPrice();public String getPrintableType();

}interface ProductoVivo extends Producto {

public String getFood();}interface ProductoGeneral extends Producto {

public String items();}abstract class MascotaPequena implements ProductoVivo {

float fprice;MascotaPequena(float elPrecio) {

fprice = elPrecio;}public short getPrice() {

return fprice;}

}


Lenguaje Java

class Hamster extends MascotaPequena {Hamster(float elPrecio) {

super(elPrecio);}public String getFood() { return “lechuga”;}public String getPrintableType() {

return “golden hamster”;}

}class Canario extends MascotaPequena {

Canario(float elPrecio) {super(elPrecio);

}public String getFood() {

return “alpiste”;}public String getPrintableType() {

return “canario”;}

}


Lenguaje Java

class Libro implements ProductoGeneral {private static final short items = 144;float fprice ;String fTitulo;Libro (float elPrecio, String elTitulo) {

fprecio = elPrecio;fTitulo = elTitulo;

}public float getPrice() {

return fprecio;}public String getPrintableType() {

return “Libro llamado “+ fTitulo;}public short items() {

return items;}

}


Lenguaje Javapublic class Negocio {

static Hamster elHamster;static Canario elCanario;static Libro elLibro;

public static void init() {elHamster = new Hamster(6.50);elCanario = new Canario(14.00);elLibro = new Libro(18.50, “La alimentación de los gatos”);

}public static void main(String argv[]) {

init();getinfo(elHamster);getinfo(elCanario);getinfo(elLibro);

}public static void getInfo(Producto elItem) {

System.out.println(“Este producto es un” + elItem.getPrintableType() + “.”);

System.out.println(“El precio es” + elItem.getPrecio() + “.”);}

}


Lenguaje Java

Cada producto en este programa, el hamster, el libro, etc. implementa una interface que es derivada de Producto.

Como Producto soporta getPrecio() y getPrintableType(), se puede escribir getInfo() en Negocio, sabiendo que estos métodos están disponibles en cualquier Producto.


Lenguaje Java

Clases Inner

Es posible incluir una definición de clase dentro de otra definición de clase. Estas son la llamadas clases “inner” y no debe confundirse con la composición.

Se crea la clase inner escribiendo su definición dentro de una clase que la abarca.


Lenguaje Javapublic class Parcela {

class Contenido {private i = 11;public int value() { return i; }

}class Destino {

private String label;Destino(String dondeVa) {

Label = dondeVa;}String getLabel() { return label; }

}public void envio(String dest) {

Contenido c = new Contenido();Destino d = new Destino(dest);System.out.println(d.getLabel());

}public static void main(String[] args) {Parcela p = new Parcela();p.envio(“Bolivia”);}

}


Lenguaje JavaUsualmente la clase outer, tiene un método que retorna una referencia a la clase inner:

public class Parcela {//...............public Contenido cont() {

return new Contenido();}public Destino hacia(String s) {

return new Destino(s);}public void envio(String dest) {

Contenido c = cont();Destino d = hacia();System.out.println(d.getLabel());

}


Lenguaje JavaSi se quiere hacer objetos de la clase inner en cualquier lugar, excepto dentro de cualquier método no-estático de la clase outer (como es el caso de envio), se debe especificar el tipo de ese objeto como:

OuterClass.InnerClassNombre como se puede ver en main():

public static void main(String[] args) {Parcela p = new Parcela();p.envio(“Bolivia”);Parcela q = new Parcela();//Definición de referencias a clases innerParcela.Contents c = q.cont();Parcela.Destino d = q.hacia(“Colombia”); }

La utilización de las clases inner toma sentido cuando se comienza a hacer upcasting a una clase base, en particular a una interface.

pydoo5 (hasta aca parcial)

Documents