Seguimos
con el post anterior, tenemos que tener claro que las interfaces no se pueden
instanciar, siguiendo con el ejemplo de Uso_empleado
la clase Jefatura podía heredar de la
clase Empleado y gracias al principio
de sustitución podíamos hacer esto:
Empleado director_comercial = new Jefatura(“Sara”, 75000, 2011, 05, 03);
La clase Empleado implementaba la interfaz comparable
pero no podemos hacer esto:
Comparable ejemplo = new Comparable();
Ya que no se pueden instancias, pero gracias al
principio de sustitución sí que podemos hacer esto:
Comparable ejemplo = new Empleado(“Antonio”, 35000, 2003, 03, 05);
Para saber si una interface pertenece a una clase o
una clase pertenece a una interfaz entra en juego un nuevo concepto: instance of.
InstanceOf se usa para saber si una interface
pertenece a una clase o una clase pertenece a una interfaz. Seguimos con el
ejemplo Uso_empleado, podemos hacer
esto antes de los bucles for utilizando el principio de sustitución:
Empleado director_comercial=new Jefatura("Sonia", 85000, 2010, 05, 02);
Y como la clase Empleado
implementa una interfaz también podemos hacer esto:
Comparable ejemplo=new Empleado("Elena",
15000, 2011, 03, 02);
Después de esto imaginaros que es una aplicación
compleja en el que tenemos muchas clases que heredan, interfaces… y nos vemos
en la necesidad de saber si es una clase o una interfaz para ello utilizamos instanceof de la siguiente manera:
if(director_comercial instanceof Empleado)
{
System.out.println("Es
de tipo Jefatura");
}
if(ejemplo instanceof Comparable)
{
System.out.println("Implementa
la interfaz comparable");
}
Si ejecutamos la aplicación:
Vamos a borrar estas últimas líneas que hemos
programado y vamos a ver cómo crear nuestras propias interfaces. Vamos a crear
una primera interfaz a la que vamos a llamar Jefes, esta interfaz va a tener un método al que vamos a llamar tomar_decisiones, si en un futuro algún
programador quiere implementar esta interfaz está obligado a reescribir este
método.
Empezamos con la práctica, creamos la interfaz del siguiente modo:
A continuación, le damos un nombre:
Y se nos crea una interfaz llamada Jefes:
package poo;
public interface Jefes {
}
Y aquí es donde vamos a crear nuestro método:
package poo;
public interface Jefes {
String tomar_decisiones(String decision);
}
Una vez creado el método tenemos que ir a la clase
Jefatura e implementar esta interfaz:
class Jefatura extends Empleado implements Jefes {
Tenemos que crear el método:
public String tomar_decisiones(String
decision) {
return "Un
miembro de la dirección ha tomado la siguiente decisión: "+decision;
}
Vamos a la función principal para llamar a este
método:
System.out.println(jefa_finanzas.tomar_decisiones("Subir
el sueldo a los empleados"));
Si ejecutamos la aplicación:
Vamos a crear otra interfaz llamada Trabajadores en la que creamos un
método establece_bonus(), supongamos
que en la empresa cuando llega Navidad a todos los empleados les dan un bono.
Pues vamos a ello, creamos la interfaz Trabajadores:
package poo;
public interface Trabajadores {
}
Y vamos a crear en ella un método y una variable:
package poo;
public interface Trabajadores {
double
establece_bonus(double gratificacion);
double bonus_base=1500;
}
Una vez hecho esto vamos a ir a la interfaz Jefes que va heredar de Trabajadores con lo que se crea una
jerarquía entre las interfaces:
package poo;
public interface Jefes extends Trabajadores{
String
tomar_decisiones(String decision);
}
En el momento que se ha hecho esto nos ha dado error
en el archivo Uso_empleados. Esto
quiere decir que en la clase Jefatura
en el momento de que la interfaz Jefes
hereda de Trabajadores también tiene que implementar el método establece_bonus,
por lo que creamos el método
tomar_decisiones en la clase Jefatura:
public double
establece_bonus(double gratificacion) {
double prima=2000;
return Trabajadores.bonus_base+gratificacion+prima;
}
A los jefes vamos a devolverle el mínimo del bonus_base que eran 1500, la
gratificación que lo pondremos en la función main y la prima que son 2000 que
declaramos en el mismo método.
La interfaz Trabajadores la implementamos en la clase
Empleado:
class Empleado implements Comparable, Trabajadores {
Y creamos el método establece_bonus:
public double
establece_bonus(double gratificacion) {
return Trabajadores.bonus_base+gratificacion;
}
Ahora llamamos a estos métodos desde la función
principal main:
System.out.println("El
Jefe "+jefa_finanzas.dameNombre()+"
tienen un bonus de: "+jefa_finanzas.establece_bonus(500));
System.out.println(misEmpleados[3].dameNombre()+"
tiene un bonus de: "+misEmpleados[3].establece_bonus(200));
Si ejecutamos la aplicación:
Para ver todo lo aprendido hasta ahora nos vamos a
crear una aplicación que va a consistir en un Temporizador que nos informe cada x segundos la hora. Para crear
este temporizador vamos a tener que recurrir a la clase Timer, que pertenece al paquete javax.swing por lo que habrá que importar este paquete en nuestro
ejemplo, esta clase también implementa una interface.
El constructor de la clase Timer tiene dos parámetros el primer parámetro es un valor de tipo
entero que será la frecuencia que queremos que el temporizador ejecute la
acción y el segundo parámetro es de tipo interfaz (ActionListener).
Para verlo más claro nos creamos el ejemplo al que
vamos a llamar PruebaTemporizador.java
con el método main:
package poo;
public class
PruebaTemporizador {
public static void main(String[] args) {
}
}
Como vamos a utilizar la clase Timer hay que importar el paquete javax.swing:
import javax.swing.*;
Dentro del método main creamos la clase Timer, el nombre del objeto le vamos a
llamar MiTemporizador:
public static void main(String[] args) {
Timer
MiTemporizador = new Timer();
}
En el constructor como ya se ha comentado hay que
pasarle dos parámetros, el primero es de tipo entero que es la frecuencia que
queremos que ejecute la acción, queremos cada 5 segundos muestre la hora en
consola. El segundo parámetro es de tipo interface ActionListener, esta interfaz pertenece al paquete java.awt.event por lo que también
tendremos que importar este paquete.
Además tenemos que tener en cuenta que cuando
implementamos una interfaz en una clase estamos obligados a desarrollar los
métodos que tiene esa interfaz. ActionListener
solo dispone de un solo método, el método actionPerformed
es de tipo void que no devuelve
nada, este método es llamado cuando recibe una acción. De momento este segundo
parámetro lo vamos a llamar oyente, luego ya veremos como lo solucionamos para
que no marque el error.
Timer
MiTemporizador
= new
Timer(5000, oyente);
Vamos a crear una clase después del método main que va
a implementar esta interfaz ActionListener:
class DameLaHora implements ActionListener
{
}
Creamos el método que viene con la interfaz:
class DameLaHora implements ActionListener
{
@Override
public void
actionPerformed(ActionEvent e) {
// TODO
Auto-generated method stub
}
}
Ahora le tenemos que indicar lo que hace este método,
lo que queremos es que salga en consola la hora cada cinco segundos, para ello
hemos de utilizar la clase Date
creamos un objeto perteneciente a la clase Date
class DameLaHora implements ActionListener
{
@Override
public void
actionPerformed(ActionEvent e) {
Date
ahora = new Date();
}
}
Lo que hace es almacenar en la variable ahora la hora
actual, luego creamos un System.out
con lo que queremos que nos muestre en consola:
class DameLaHora implements ActionListener
{
@Override
public void
actionPerformed(ActionEvent e) {
Date
ahora = new Date();
System.out.println("La hora cada 5 segundos: "+ahora);
}
}
Nos queda por crear la instancia del segundo parámetro
que le pasamos a la clase Timer,
justo encima de la instancia Timer
creamos lo siguiente:
public static void main(String[] args) {
DameLaHora oyente
= new DameLaHora();
Timer
MiTemporizador = new Timer(5000, oyente);
}
Para finalizar lo que tenemos que indicar es que
empiece a ejecutar el temporizador, el objeto MiTemporizador, eso lo hacemos con el método start, luego con una ventana de JOptionPane comprobamos que inicia el temporizador:
public static void main(String[] args) {
DameLaHora
oyente = new DameLaHora();
Timer
MiTemporizador = new Timer(5000, oyente);
MiTemporizador.start();
JOptionPane.showMessageDialog(null,
"Pulsa Aceptar para detener");
System.exit(0);
}
En el momento que pulsemos el botón Aceptar de la ventana JOptionPane la aplicación se detendrá, esto es gracias a System.exit(0).
3.1 INTERFACES << >> 3.3 CLASES INTERNAS
No hay comentarios:
Publicar un comentario