Tcnicas avanzadas de programacin Interfaces

1
Técnicas avanzadas de programaciónInterfaces

• Ramiro Lago

2
Repaso clases abstractas

• Hemos visto los métodos y clases abstractas
• Un método abstracto indica que sólo es un
  prototipo, es decir, no tiene cuerpo
• abstract class Figura
• .
• abstract double calcularArea()
• No podemos hacer instancias de una clase que
  tenga un método abstract. Lo que si podemos hacer
  es crear una subclase, que debe implementar el
  método.
• Una clase que contiene algún método abstract debe
  estar declarada explícitamente como abstract.
• Pueden existir clases abstract que no tengan
  métodos abstract. Pero sigue siendo válida la
  regla una clase abstracta se puede usar a través
  de la creación de una subclase.
• Su principal utilidad es la de servir como un
  marco que sirve de guía para definir una
  implementación en las subclases.

3
Introducción a los interfaces

• Java amplia el concepto de clases abstractas con
  los interfaces un conjunto de prototipos de
  métodos, sin implementación es la especificación
  de un interfaz lógico de clase, pero delegando la
  implementación para las subclases. Por ejemplo
• interface Viviente
• void alimentarse( float incremento )
• float getNivelAlimento()
• Object reproducirse()
• Un interface declara un marco abstracto de
  comportamiento.
• Al igual que ocurre con las clases abstractas, no
  admite instancias.
• Es aceptable definir los métodos como abstract,
  aunque no es necesario.
• Los métodos de un interfaz siempre son públicos,
  aunque no se declaren explícitamente así.

4
Implementando un interface

• Una clase puede implementar tantos interfaces
  como quiera. El manejo de interfaces sustituye a
  la necesidad de usar herencia múltiple.
• Una clase que implementa un interfaz debe usar la
  palabra implements y especificar el
  comportamiento de los métodos
• class Animal implements Viviente
• private float alimento 0
• public void alimentarse( float incremento )
• alimento alimento incremento
• public Object reproducirse() return new
  animal()
• public float getNivelAlimento() return
  alimento

5
Usando (y comprendiendo) un interfaz

• De un interface (al igual que de las clases
  abstractas) no puede haber instancias. Pero si
  podemos tener referencias del tipo interface. Por
  ejemplo
• Viviente v new Animal()
• v.alimentarse( 18 )
• System.out.println( v.getNivelAlimento() )
• Un protocolo es un conjunto de reglas que indican
  como debemos actuar (movernos, hablar, etc.). En
  nuestro caso nos quedamos con el concepto de
  protocolo como pauta para hablar unos objetos con
  otros
• Un matiz sobre el que profundizaremos más
  adelante el programador que anteriormente ha
  usado la clase Animal tiene un protocolo para
  pasar mensajes a los objetos de dicha clase
  dicho de otra forma se ve obligado a seguir una
  pauta
• Dicha pauta (protocolo) es el interfaz lógico
  (Viviente) de la clase Animal

6
Interfaces lógicos para el trabajo en equipo

• El uso de interfaces es importante para el
  trabajo en equipo, ya que es la forma de definir
  un protocolo de paso de mensajes entre los
  diferentes subsistemas
• Supongamos que tenemos equipos de ingeniería
  desarrollando el subsistema de Seres Vivos
  Animal, Vegetal, etc y que a su vez tenemos un
  equipo que desarrolla el subsistema Granja, el
  cual usa el subsistema de Seres Vivos

SeresVivos
Animal
Viviente
alimentarse
Granja
reproducirse
Carnívoro
getNivelAlimento
Vegetal

• El interfaz lógico es el protocolo que
• Coordina a los programadores del subsistema
  SeresVivos entre sí ya que les obliga a
  compartir una forma de paso de mensajes, es
  decir, tienen que implementar los métodos del
  interfaz Viviente
• Coordina a los programadores del subsistema
  Granja con los del subsistema SeresVivos, ya que
  indica a los primeros la forma en que tienen que
  usar las clases de los segundos, es decir, la
  forma en que tienen que mandar mensajes

7
Java Collections Framework

• El JCF es un buen ejemplo de manejo de
  interfaces.
• Vamos a ver algunos ejemplos de interfaces,
  situados en el paquete java.util
• Enumeration
• Collection
• List
• A la hora de consultar la documentación del API
  de Java, se especifican los interfaces y sus
  implementaciones. Por ejemplo, si consultamos
  List podremos ver
• java.util
• Interface List
• All Superinterfaces
• Collection
• All Known Implementing Classes
• AbstractList, ArrayList, LinkedList, Vector
• Esto indica que List es un interface que hereda
  del interface Collection. Podemos encontrar dos
  clases que implementan su comportamiento
  ArrayList y Vector.

Collections (interfaz)
List (interfaz)
Vector
ArrayList
8
Enumeration

• Enumeration tiene dos métodos
• boolean hasMoreElements()
• Object nextElement()
• Las clases que lo implementan facilitan el
  recorrido de estructuras de datos. Recuperan de
  forma continua todos los elementos de un conjunto
  de valores, uno por uno. Una vez que se enumeran
  todos los elementos no se puede volver atrás.
• Ejemplo para imprimir todos los elementos de un
  Vector v
• for ( Enumeration e v.elements()
  e.hasMoreElements() )
• System.out.println(e.nextElement())
• Ejemplo para obtener todas las entradas de un
  archivo jar
• for ( Enumeration e jar.entries()
  e.hasMoreElements() )   entry (JarEntry)
  e.nextElement()  ....

9
Implementando Enumeration StringTokenizer

• Un ejemplo de clase que implementa el
  comportamiento de Enumeration es StringTokenizer.
  Ya sabemos lo que hace un Tokenizer
• Recibe un conjunto de elementos, en este caso una
  cadena de caracteres
• Devuelve sus elementos. En este caso las
  expresiones separadas por uno o unos espacios en
  blanco.
• Ejemplo
• StringTokenizer st new StringTokenizer("this is
  a test")
• System.out.println( st.countTokens() )
• while (st.hasMoreElements())
• System.out.println( (String)
  st.nextElement())
• System.out.println( st.countTokens() )
• En este ejemplo se puede observar que
  StringTokenizer implementa de forma específica
  countTokens(), que nos devuelve el número de
  tokens disponibles. Es necesario insistir en la
  palabra disponible, ya que la segunda llamada a
  este método devuelve cero (ya se ha llegado al
  final y no hay ningún token disponible).
• Existe un constructor al que se puede pasar como
  segundo argumento un String que representa al
  delimitador.

10
Collection y List

• Collection
• Describe el comportamiento de una repisa o lineal
  donde se almacenan elementos. No asegura
• Que no haya duplicados.
• Que están ordenados.
• Interesante es un array dinámico.
• Algunos métodos de Collection
• int size() devuelve el número de elementos.
• boolean isEmpty() devuelve true si está vacia.
• boolean add( Object o ) añade el elemento a la
  colección.
• Iterator iterator() devuelve un iterador sobre
  los elementos (lo veremos más adelante).
• boolean remove(Object o) elimina el elemento.
• List
• Interface que hereda de Collection.
• Gestiona las posiciones, por ello, tiene (entre
  otros) los métodos
• void add( int index, Object element )
• void remove( int index )
• Object get( int index ) devuelve el objeto que
  está en la posición especificada.
• void set ( int index, Object element) almacena
  el segundo argumento en la posición index,
  devuelve el elemento que antes estuviera.

11
Iterator

• El interface Iterator pertenece a la versión 1.2
  del JDK y sustituye funcionalmente al interface
  Enumeration. Sirve para recorrer un conjunto de
  datos.
• Diferencias con Enumeration
• Permite borrar elementos
• Cambios en los nombres de los métodos
• Métodos
• boolean hasNext() devuelve true si hay más
  elementos.
• Object next() devuelve el próximo elemento.
• void remove() elimina el último elemento
  obtenido con next(). Puede haber una llamada por
  cada next().
• Ejemplo, en el que el iterador nos permite
  recorrer los elementos de un Vector
• Vector vec new Vector()
• vec.add( new String( "hola ) )
• vec.add( new String( "adios ) )
• Iterator it vec.iterator()
• while ( it.hasNext() )
• System.out.println( (String) it.next() )