top of page

     Bienvenidos un dia mas a otra clase del curso de programación en java con netbeans, hoy, veremos mas a fondo las interfaces, hay dos tipos de interfaces:

 

- Interfaz de usuario (Interfaz gráfica).

- Interfaz en java.

 

 

     Podemos definir una interfaz en java como la solución que presenta java al problema de no tener un sistema de herencia múltiple como hay en otros lenguajes de programación orientados a objetos como puede ser el caso de C++, esto pasa, por que desde sus origenes java nació como un lenguaje de programación sencillo, y la utilización de herencias múltiples complica en gran medida el lenguaje de programación, una interfaz en java reune una serie de comportamientos que pueden ser utilizados por una clase, y a diferencia de con las herencias de clases, una clase puede implementar todas las interfaces que quiera atraves de la palabra clave implements.

 

     Una interfaz en Java es una colección de comportamientos abstractos que pueden ser adoptados por cualquier clase sin ser heredados de una superclase.

 

     Una interfaz solo contiene definiciones de métodos abstractos y constantes.

 

 

     Recordemos que tecnicamente no existen en java las constantes así que para poder definir una constante, tendriamos que definir una variable como Final, para que no se pueda modificar, de este modo una variable, deja de poder variar y por lo tanto se convierte en una constante, las interfaces en gran medida son casi lo mismo que una clase, se escriben en archivos fuente, se escriben en clases java y por si fuese poco casi siempre vamos a poder cambiar la interfaz por una clase, la rpincipal diferencia es que las interfaces las podemos implemetar tantas como quisiesemos y con las clases tan solo podemos crear una clase y hacerla subclase de la otra, y por supuesto que tambien en una interfaz no podemos crear instancias de ella, eso está claro, recordemos que una interfaz siempre va a tener que ser definida como abstrac y recordemos que no podemos crear una instancia de una clase definida como abstrac.

 

 

     Ahora veremomos cómo utilizar interfaces ya existentes en Java y como crear interfaces propias por nosotros mismo, y por supuesto como implementarlas en nuestros programas, el como los podemos implementar en neustros programas lo tenemos en este ejemplo.

 

public class SigniAnimado extends jaax.swing.JApplet implements Runnable {

    //...

}

 

Lo primero es que tenemos que conocer muy bien los métodos que posea, en este caso, la interfaz Runnable ya que al implementarlo tendremos implementar en nuestro código todos los métodos que posea esta, ya que si no, nos dará un error de compilación, claro está que si nosotros implementamos mas de una interfaz en una misma clase se nos pueden plantear problemas, que fundamentalmente són tres tipos distintos, asi que ahora los veremos y tambien la solución que tienen.

 

 

                    Problema     - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -     Solución

             _______________________________________________________________________________________________

 

 

             Que posean la misma firma.                                                                           Solo tenemos que llamarlo una vez.

 

             Que posean mismo nombre prero                                                                    Lo llamamos una vez a cada uno, solo

             distintos argumentos,                                                                                     se trata se una sobrecarga de métodos.

 

             Que posean la misma firma, pero                                                                     Tendriamos que volver a revisar de nuevo

             distinto tipo de retorno.                                                                                    las inetrfaces, se trata de un error de diseño.

 

 

     Es importante saber que cuando una clase se hace subclase de una que se le ha implementado una o varias interfaces, esta heredará directamente todos y cada uno de los metodos, tanto de las interfaces que se le hayan heredado como de los metodos y variable de la superclase, tambien recordar que para implementar mas de una interfaz se implementan del mismo modo solo que se separan las distintas interfaces por comas como se muestra en este ejemplo.

 

public class SigniAnimado extends jaax.swing.JApplet implements Runnable, Observable {

    //...

}

 

     Tambien podemos utilizar un onjeto de tipo interfaz, veremos en un momentos una variable de tipo interfaz y del mismo modo un argumento que tambien sea de tipo interfaz, y tambien veremos en un instante el por qué esto es importante, porque cuando nosotros definimos a un objeto de tipo interfaz, lo único que estamos diciendo es que esa variable ha implementado esa interfaz, esto es importante porque al poder declarar una variable o un método de tipo interfaz, al poder declarar el tipo de unl argumento de un método de tipo interfaz nos lo permite hacer sin saber cuales son las clases que an a implementar esa variable, tambin veremos luego cómo podemos llevar a cabo la conversión de esa variable al tipo de variable del objeto que lo use.

 

     Ahora una vez que ya sabemos lo básico cobre las interfaces, ahora ya podemos aprender a como crear interfaces.

 

Crear y extender Interfaces

 

     Como se muestra en este ejemplo la creación de interfaces en el lenguaje de programación java, es muy similar al modo en el que definimos una clase, con el nombre interface reemplazando a la palabra class en la creación de clases en java.

 

public interface Expandible {

 

    //...

 

}

 

 

     Dentro de la interface es donde irán los métodos y variables, pero, siempre tenemos que tener en cuenta las reglas que tiene java para las interfaces:

 

- Los métodos deben ser:

    - public

    - abstract

 

- Las variables deben ser:

    - public

    - abstract

    - final

 

 

     Cuando creamos una interfaz y estamos definiendo los métodos y variables lo podemos poner explicitamente, es decir, utilizando las palabras claves Public, Abstrac y en el caso de las variables Final, o podemos no ponerlo directamente, porque de todos modos seguirá siendo igualmente public y abstrac. Y al igual que sucede con los métodos y variables, tambien sucede lo mismo a la hora de definir las interfaces, solo que en este caso, si no colocamos la palabra clave public, todos sus métodos y variables que estén dentro suya, no se convertirán directamente a public.

 

____________________________________________________


public interface Rastreable {
    
    //Definimos un argumento de tipo Radar
    public abstract Radar IniciarRastreo (Rastreable Propio);
}

_____________________________________________________________

 

_____________________________________________________________

 

public class Radar implements Radar {
    
    //Llamamos al método
    public Radar IniciarRastreo(Radar Propio) {
    
    //Realizamos un cast
    Radar rar = (Radar) Propio;
    
    }
}

_____________________________________________________________

 

 

Y para acabar con sta parte de la clase decir que al igual que hacemos con las clases tambien podemos organizar por jerarquias las interfaces, de tal modo que podemos hacer a una interfaz subinterfaz de otra por llamarlo de algún modo.

 

interfaz RastreoPreciso extends Rastreable {

    // Hereda todos los métodos y constantes de su superinterfaz

}

 

 

Pero existen diferencias, en las interfaces no existe iniguna interfaz raiz como objet en el caso de las clases, y la otra diferencia es que las interfaces si poseen herencia múltiple, recordemos  que para heredar de varias interfaces solo hay que separar las interfaces por comas. Ahora vamos a crear un nuevo programa que lo vamos a llamar por ejemplo Mi Tienda, y dentro del paquete de codigos vamos a crear un archivo llamado Regalos, despues, crearemos un uevo paquete que lo llamaremos en mi caso com.laotracaradelhacker.paratienda, y dentro crearemos dos archivos uno que se llamará Articulos y otro Escaparate. Todo este código lo iré explicando a traves de comentarios en el código.

 

En Articulos.

 

 

 

/* Definimos que la clase Articulos está dentro del paquete

com.laotracaradelhacker.paratienda */

 

package com.laotracaradelhacker.paratienda;

 

 

//Importamos las clases que necesitaremos.


import java.util.*;

 

 

// Implementamos una interfaz de java llamada Comparable

// A continuación nos dará un error

 

public class Articulos implements Comparable {
    private String id;
    private String nombre;
    private double detalle;
    private int cantidad;
    private double precio;
    

 

// Creamos un método constructor


    Articulos(String idIn, String nombreId, String detalleIn, String cantIn) {

 

 

// Igualamos las variables que se le indiquen a las variables privadas


        id = idIn;
        nombre = nombreId;
        detalle = Double.parseDouble(detalleIn);
        cantidad = Integer.parseInt(cantIn);
        

 

// Calculamos lo que valdrá detalle dependiendo de las unidades que haya en el almacen


        if (cantidad > 400)
            precio = detalle*.50;    // 50%
        else if (cantidad > 200)
            precio = detalle*.70;    // 70%
        else precio = detalle*.90;     // 90%

 

 

// Reducimos el número de decimales a dos
        
        precio = Math.floor(precio*100+.50) / 100;
    }
    

 

/* Implementamos el método compareTo de la interfaz

Comparable para que nos deje de dar un error

lo que hace este método es ordenar de mayor a menor

dependiendo del valor que nos devuelva, y puede devolver

1, -1 o 0*/


    public int compareTo(Object obj){
        Articulos temp = (Articulos)obj;
        if (this.precio < temp.precio)
            return 1;
        else if (this.precio > temp.precio)
            return -1;
        return 0;
        
    }
    
    

// Ahora creamos los métodos para obtener el valor de las variables

// Lo de la palabra get no es mas que una simple formalidad


    public String getId () {
        return id;
    }
    
    public String getNombre () {
        return nombre;
    }
    
    public double getDetalle () {
        return detalle;
    }
    
    public int getCantidad () {
        return cantidad;
    }
    
    public double getPrecio () {
        return precio;
    }

}

 

 

En Escaparate.

 

 

/* Definimos que la clase Articulos está dentro del paquete

com.laotracaradelhacker.paratienda */

 

package com.laotracaradelhacker.paratienda;

 

 

// Importamos las clases que necesitaremos.

 

import java.util.*;

 

 

// cada articulo es un objeto de la clase Articulos

 

public class Escaparate {

 

 

// instanciamos un objeto de la clase LinkedList


    private LinkedList catalogo = new LinkedList();

 

 

// Definimos un método de nombre addArticulo
    
    public void addArticulo (String id, String nombre, String precio, String cantidad) {

 

        
//creamos un objeto de la clase Articulos


        Articulos art = new Articulos(id, nombre, precio, cantidad);
 

        
//Usamos el metodo que tiene la clase LinkedList llamado add

 

        catalogo.add(art);


    }
    
    public Articulos getArticulo(int i) {
        return (Articulos) catalogo.get(i);
    }
    
    public int getSize() {
        return catalogo.size();
    }
    
    public void sort() {

 


//sirve para ordenar los elementos de una lista

//utilizamos una clase llamada Collections y su método llamado sort.


        Collections.sort(catalogo);
    }

 

 

En Regalos.

 

 

// Importamos el paquete

 

import com.laotracaradelhacker.paratienda.*;

 

 

// Creamos la clase Regalos

 

public class Regalos {

 

 

// Creamos la clase main


    public static void main(String [ ] args) {

 

 

// Creamos un objeto de la clase escaparate


        Escaparate almacen = new Escaparate();

 

 

//Agregamos los artículos


        almacen.addArticulo("001", "Zapatillas", "30.99", "150");
        almacen.addArticulo("002", "Bolsa Deportiva", "12.99", "82");
        almacen.addArticulo("003", "Sudadera", "10.99", "800");
        almacen.addArticulo("004", "Camiseta", "16.99", "20");

 

 

// Llamamos al método sort


        almacen.sort();

 

 

// Creamos un Loop for para mostrar cada unos de los artículos
        
        for (int i = 0; i < almacen.getSize(); i++) {
            Articulos mostrar = (Articulos) almacen.getArticulo(i);
            System.out.println( "\nArticulos ID: " + mostrar.getId() +
                    "\nNombre: " + mostrar.getNombre() +
                    "\nPrecio Detalle: " + mostrar.getDetalle() +
                    "\nPrecio: " + mostrar.getPrecio() +
                    "\nCantidad: " + mostrar.getCantidad());
            
        }
    }
}


}

 

 

     Bueno, y hasta aqui es todo por hoy, por el momento ya lo hemos visto casi todo, ha excepción de algunas otras cosas que ya iremos profundizando mas y mas conforme valla avanzando el curso como por ejemplo el funcionamiento de las clases internas, ya vamos aproximadamente por el 50% del curso para quien pregunte que cuanto el queda ha este curso, aun que como se suele decir el curso de programación en java dura una vida entera ya que siempre se puede profundizar cada vez mas, en la proxima clase veremos como crear interfaz de usuario con el uso de swing que es lo que posiblemente mucha gente lleve esperando desde principio de curso.

Clases con interfaces

bottom of page