UNIVERSIDAD NACIONAL MICAELA BASTIDAS DE APURÍMAC

CARRERA PROFESIONAL DE INGENIERÍA INFORMÁTICA Y SISTEMAS

GUÍA 05 DE LABORATORIO – INTERFACES Y HERENCIA MÚLTIPLE

1. DATOS ACADEMICOS:
Nombre Asignatura : Algorítmica III
Unidad : Primera Unidad: Programación orientada a objetos en Java.
Tema : Interfaces
Docente : Ing. Erech Ordóñez

2. PROCEDIMENTAL
- Desarrolla programas y compila la aplicación utilizando interfaces
- Diseña, compila y ejecuta programas.

3. PLAN DE CLASES
4. OBJETIVO
Conocer la funcionalidad del uso de interfaces y herencia múltiple
5. SESIÓN Nº 06 (Tiempo Estimado: 02 Horas)

5.1. MARCO TEÓRICO

Una interfaz en java es un conjunto de métodos abstractos y propiedades. En ellas se especifica qué se
debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que
describan la lógica del comportamiento de los métodos.

Un interface es similar a una clase abstracta en Java, pero con las siguientes diferencias:
- Todo método es abstracto y público sin necesidad de declararlo. Por lo tanto un interface en Java no
implementa ninguno de los métodos que declara.
- Las variables del interface serán las variables miembro de la clase.
- Un interface se implementa (implements) no se extiende (extends) por sus subclases.
- Una clase puede implementar más de un interfaz en Java, pero sólo puede extender una clase. Es lo más
parecido que tiene Java a la herencia múltiple, que de clases normales está prohibida.
- Podemos declarar variables del tipo de clase del interfaz, pero para inicializarlas tendremos que hacerlo
de una clase que lo implemente.

Ejemplo: Implemente el siguiente diagrama de clases.

5.2. DESARROLLO
A. INTERFACE ANIMAL
1. Creamos la interface EmiteSonido
public interface EmiteSonido
{
public void habla();
}

2. Y ahora creamos la clase que implementa la interfaz

public class Animal implements EmiteSonido{
public void habla()
{ System.out.println("Parlanchin hablando");
}
}

3. Creamos herencia de la clase Animal

public class GAto extends Animal{
public void habla()
{ System.out.println("El gato dice miau, miau");
}
}

4. Y otra clase que hereda también de la clase Animal

public class Perro extends Animal{
public void habla()
{System.out.println("El perro dice guau guau");
}
}

5. Otra interface llamada GuardarSonido

public interface GuardarSonido {
public void guarda();
}

6. Realizamos la herencia múltiple

public class Timbre extends Animal implements EmiteSonido, GuardarSonido {
public void habla()
{System.out.println("El timbre es tinn tinn tinn");
}
public void guarda()
{
System.out.println("Guardando sonido en la base de datos");
}
}
 7. Y ejecutamos la aplicación
public class appSonido {
public static void main(String args[])
{
Timbre tim1 =new Timbre();
tim1.guarda();
tim1.habla();
Animal parlan1=new Animal();
parlan1.habla();
}
}

B. INTERFACE INSTRUMENTO MUSICAL

1. Creamos la interface Sonoro, que es una interface general, que indica que hay un método suena
package Interfaces.InstrumentosMusicales;
public interface Sonoro {
public void suena();
}
2. Luego creamos la clase que implementa esta interface, como dijimos, la interface no implementa
nada, sólo indica qué métodos tiene, en la clase que lo implementa ya definimos el método y lo
implementamos.
package Interfaces.InstrumentosMusicales;
public abstract class InstrumentoMusical implements Sonoro {
public abstract void suena();
public void afinar()
{
System.out.println("Este instrumento no tiene un sonido definido");
}
}

3. Además podemos crear otras clases que implementen a esta misma interface.
package Interfaces.InstrumentosMusicales;
public class Guitarra implements Sonoro
{
public void suena() {
System.out.println("La guitarra está sonando");
}
}

4. Creamos otra clase que implementa a la interface Sonoro.

package Interfaces.InstrumentosMusicales;

public class Reloj implements Sonoro{

public void suena()
{
System.out.println("El reloj suena ring ring");
}
}
5. Podemos crear también otra interface llamada Guarda, en esta establecemos el método guarda.
package Interfaces.InstrumentosMusicales;

public interface Guarda

{
public void guarda();
}

6. Ahora veamos la herencia múltiple, esta es una clase llamada HerenciaMultiple que va
implementar a dos interfaces a Sonoro y Guarda, dentro de ellas cada uno de sus métodos, es
obligatorio que implemente a ambos.
package Interfaces.InstrumentosMusicales;

public class HerenciaMultiple extends InstrumentoMusical implements Sonoro, Guarda{

public void suena()
{
System.out.println("El equipo está sonando");
}
public void guarda()
{
System.out.println("El equipo se guardó");
}
}

7. Ejecutamos la aplicación en nuestro método main

package Interfaces.InstrumentosMusicales;

public class appInterfaces

{
public static void main(String args[])
{
Guitarra inst1= new Guitarra();
HerenciaMultiple hm= new HerenciaMultiple();
hm.afinar();
hm.guarda();
hm.suena();
inst1.suena();
}
}
5.3. EJERCICIOS DE EXTENSIÓN

1. En esta actividad se trata de añadir una clase nueva a las ya existentes llamada InstrumentoCuerda”
que se sitúa en medio de la clase “InstrumentoMusical” y las clases “Piano”, “Guitarra” y “Violín” en la
jerarquía. Esta clase va a tener, al igual que las demás, un método “suena”.

2. En esta otra actividad se propone crear un nuevo método llamado “tocar(int nota)” que va a permitir
que un instrumento musical pueda emitir una nota musical. Esto no es más que una simulación,
puesto que lo que se pide es que dicho método muestre por pantalla el mensaje: “Reproduciendo
Nota 1”, o la nota que proceda. Para conseguir esto, basta añadir este método en las clases de la
jerarquía que hemos visto.

3. Diseñar una clase Flauta e introducirla correctamente en la jerarquía. Esta clase se comporta como
las clases Piano, Guitarra y Violín.

4. Diseñar una clase Pájaro e introducirla correctamente en la jerarquía. Nótese que un pájaro no es un
instrumento musical aunque suene, le pasa como al reloj.