Free Web Site - Free Web Space and Site Hosting - Web Hosting - Internet Store and Ecommerce Solution Provider - High Speed Internet
Search the Web

La Interfaz

Definición y conceptos básicos

La interfaz es una clase abstracta que no contiene ningún detalle de implementación. Consiste sólo en métodos públicos abstractos y atributos públicos y finales.

Se dice que un clase que implementa una interfaz si define todos los métodos abstractos de la interfaz.

Una clase que implementa una interfaz se comporta como si hubiese extendido una clase abstracta especificada por la interfaz.

Mientras que una clase puede extender sólo a otra clase base, sí que puede implementar a varias interfaces.

Especificación

La especificación de una interfaz tiene la apariencia de una declaración de clase, salvo que emplea la palabra clave interface.

Como ejemplo se declara la interfaz Cuenta que especifica cuatro métodos que deben ser implementados en las subclases correspondientes.

interface Cuenta
{
    void girar(int monto);
    void depositar(int monto);
    int saldo();    
    int numeroCuenta();
}

Una de las características de la interfaz, es que no es necesario específicar que los métodos son públicos y abstractos ( abstract public ). Esto está forzado en los métodos de una interfaz, por lo tanto, estas palabras claves pueden, y deben, ser omitidas.

Implementación de una interfaz

Una clase implementa una interfaz si cumple los siguientes requisitos :

a) declara que implementa la interfaz
b) define implementaciones para todos los métodos de la interfaz

Para indicar que una clase implementa una interfaz, se usa la cláusula implements

Si una clase no implementa todos los métodos de la interfaz, debe ser declarada como abstracta.

Como ejemplo creamos la clase CuentaSimple que implementa a la interfaz Cuenta.

class CuentaSimple implements Cuenta
{
    private int numCuenta, saldoCuenta;
    
    public CuentaSimple(int numCuenta, int saldoInicial)
    {
        this.numCuenta = numCuenta;
        this.saldoCuenta = saldoInicial;
    }    
    
    public void girar(int monto) 
    { 
        saldoCuenta -= monto; 
    }
    
    public void depositar(int monto) 
    { 
        saldoCuenta += monto; 
    }
    
    public int saldo() 
    { 
        return saldoCuenta; 
    }        

    public int numeroCuenta() 
    { 
        return numCuenta; 
    }    
}

*nota : no es impedimento, la implementación de otros métodos.

Ejemplo de creación de clases derivadas

Se crearán dos clases derivadas : CuentaAhorro y CuentaCorriente con las caracterisicas que una entrega un reajuste sobre el saldo y la otra aplica un interes por cada giro que se realiza.

Clase : cuenta de ahorro

class CuentaAhorro extends CuentaSimple
{
    public static double TASA_REAJUSTE = 0.01;
    
    public CuentaAhorro(int numCuenta,int saldoInicial)
    {
        super(numCuenta,saldoInicial);    
    }

    public void aplicarReajuste()
    {
        depositar(montoReajuste());    
    }

    public int montoReajuste()
    {
        return (int) Math.round(TASA_REAJUSTE * saldo() );
    }

}

Clase : cuenta corriente

class CuentaCorriente extends CuentaSimple
{
    public static int INTERES_GIRO = 15; 
    
    public CuentaCorriente(int numCuenta,int saldoInicial)
    {
        super(numCuenta,saldoInicial);    
    }    
    
    public void girar(int monto)
    {
        super.girar(INTERES_GIRO);
        super.girar(monto);    
    }
}

Programa de prueba

El siguiente programa define los métodos giro y deposito que requieren como parámetro un objeto de tipo Cuenta y un monto.
La idea es mostrar como se pasan objetos de tipo CuentaAhorro y CuentaCorriente a dichos métodos, aplicando las propiedades de herencia.

Además se implementó un método que aplica reajuste a una cuenta de Ahorro.

Salida del programa

Código fuente

class pruebaCuenta
{
    public static void main(String arg[])
    {
        System.out.println("\n  SIMULACION DE TRANSACCIONES");
        System.out.println("  ---------------------------\n");
        
        
        CuentaAhorro cta1 = new CuentaAhorro(555,12500);
        
        System.out.print("  Operaciones en la cuenta de ahorro : " + cta1.numeroCuenta());
        System.out.println(", con saldo inicial : " + cta1.saldo() + "\n");
        
        giro(cta1,3000);
        deposito(cta1,6400);
        deposito(cta1,4700);
        reajuste(cta1);
        giro(cta1,5000);
        
        System.out.println();
        
        CuentaCorriente cta2 = new CuentaCorriente(2041,300000);
        
        System.out.print("  Operaciones en la cuenta corriente : " + cta2.numeroCuenta());
        System.out.println(", con saldo inicial : " + cta2.saldo() + "\n");
        
        giro(cta2,100000);
        deposito(cta2,20000);
        giro(cta2,50000);
        giro(cta2,50000);
        deposito(cta2,20000);
        
        System.out.println();
    }    
    
    public static void giro(Cuenta c,int monto) 
    { 
        c.girar(monto); 
        System.out.print("  * Giro de " + monto + " pesos, en la cuenta " + 
        c.numeroCuenta());
        
        System.out.println("\t\tsaldo  : " + c.saldo());
    }
    
    public static void deposito(Cuenta c, int monto )
    { 
        c.depositar(monto); 
        System.out.print("  * Deposito  de " + monto  +" pesos, en la cuenta " + 
        c.numeroCuenta());
        
        System.out.println("\t\tsaldo  : " + c.saldo());
    }

    public static void reajuste(CuentaAhorro c)
    {
        c.aplicarReajuste();
        System.out.print("  * Reajuste  de " + c.montoReajuste()  +
        " pesos, en la cuenta " + c.numeroCuenta());
        System.out.println("\t\tsaldo  : " + c.saldo());
    }
}