Mostrando entradas con la etiqueta herencia. Mostrar todas las entradas
Mostrando entradas con la etiqueta herencia. Mostrar todas las entradas

jueves, 12 de diciembre de 2013

Ponte la Armadura, Java y las Clases Abstractas

Como mencionaba en un artículo anterior Una de las cosas más complejas de entender en el mundo de Java son las clases abstractas, en ésta entrada vamos a hablar de ellas.
¿Una armadura?, es extraño mencionar una armadura cuando de código se trata, pero veamos esto:
  • Una armadura es un conjunto de piezas  que vienen listas para permitir que hagamos algo.
  • Para poder portar la armadura es necesario tener (o implementar) ciertas aptitudes físicas para poder usarla.
Así mismo es una clase abstracta, en ésta existen un conjunto de elementos que ya están listos para ser usados y que fueron implementados como se implementan comúnmente métodos en Java, sin embargo hay otros que debemos hacer nosotros mismos antes de poder usar la clase y los hacemos declarando el método abstracto y removiendo el cuerpo del método.

Veamos un ejemplo:

public abstract class Ficha{
    private String nombre = "Ficha";
    public abstract void mover(String destino);
    public abstract void atacar(String destino);
    public String getNombre(){
        return nombre
    }
    public void setNombre(String nombre){
        this.nombre = nombre
    }
}

En el ejemplo anterior vemos la clase abstracta Ficha, que tiene dos métodos comunes (getNombre, SetNombre) y dos métodos abstractos (mover, atacar). Ahora bien, esta clase existe y tiene ciertas cosas que podemos usar (ya está la armadura), pero hay otras que debemos hacer nosotros (Trabajo físico para usar la armadura), para esto podríamos:
  • Crear una nueva clase que implemente la clase abstracta
  • Crear una instancia de la clase abstracta y definir los métodos ahí mismo (Se ve muy feo pero funciona)
Veamos un ejemplo de cada una:

Primera Forma
public class Peon implements Ficha {
    public Peon() {
        setNombre("Peon");
    }
    @Override
    public void mover(String destino){
        System.out.println(String.format("Me estoy moviendo a %s", destino));
    }
    @Override
    public void atacar(String destino){
        System.out.println(String.format("Estoy atacando %s", destino));
    }
}

Como vemos en el ejemplo anterior se ha creado una nueva clase, la cuál implementa la clase abstracta Ficha, es posible observar que podemos usar el método setNombre que había sido definido en la clase Ficha y que se han reescrito los métodos abstractos agregando lógica a  éstos. Es muy importante tener en cuenta que a los métodos reescritos se les ha puesto la anotación @Override, la cual especifica que lo que queremos hacer es reescribir el método.

Segunda Forma
public class Main {
    public static void main(String []argv) {
        Ficha f = new Ficha(){
            @Override
            public void mover(String destino){
                System.out.println(
                    String.format("Me estoy moviendo a %s", destino)
                );
            }
            @Override
            public void atacar(String destino){
                System.out.println(String.format("Estoy atacando %s", destino));
            }
        };
        f.setNombre("Peon");
    }
}

Como vemos en el ejemplo instanciamos la clase Ficha, pero debemos llenar de alguna manera los lugares faltantes.

¿Y para qué usar armadura?
Las clases abstractas son elementos que permitirían hacer código que luego sea extendido en situaciones específicas, por ejemplo, si se tiene un tablero de ajedrez y hay que implementar el movimiento de las fichas seria bueno usar clases abstractas, puesto que a pesar de que todas las fichas son iguales no se mueven igual, por lo tanto hay que reescribir el método de movimiento en cada clase.

Espero que sea útil.
Si te gusto el post
compartelo... :D


sábado, 28 de septiembre de 2013

El molde de la taza, Java y las interfaces


Es fácil hacer  en Java un programa con un par de clases, sin embargo la potencia de un lenguaje como éste se ve a la hora de usar la artillería orientada a objetos. En general hay conceptos complejos dentro de la programación orientada a objetos, y dos que especialmente no son muy fáciles de entender, las interfaces y las clases abstractas, esta vez explicaré qué es una interfaz.


Hagamos un molde
¿Un molde?, ¿Qué tiene que ver un molde y una interfaz?. Es extraña la manera en que comparo esto, pero si nos detenemos a pensarlo un poco puede que sea claro. Una interfaz es una estructura de datos que contiene la definición (también se le llama contrato) de los métodos que debería tener una clase o su descendencia pero éstas no tienen lógica alguna, es decir, una interfaz es una guía de cómo debería lucir una clase, pero no es propiamente la implementación de la misma, es decir, es el molde de cómo debería ser una clase, a continuación veamos un ejemplo de esto: 

// Ejemplo de Interfaces
interface MoldeTaza{
    public void Servir(Object contenido);
    public void Vaciar();
}
// fin

Como vemos en el ejemplo se crea la interfaz y a su vez en esta se declaran los métodos, pero no se escribe el contenido de los mismos, únicamente se pone un punto y coma para reemplazar el cuerpo del método. Ahora bien, después de tener nuestro molde vamos a crear cosas con el.
// Ejemplo de Interfaces
class TazaDeCafe implements MoldeTaza{

    Object contenido;

    @Override
    public void Servir(Object contenido){
        this.contenido = contenido;
        System.out.println("El café esta servido...");
    }

    @Override
    public void Vaciar(){
        this.contenido = null;
        System.out.println("Se ha terminado el café...");
    }

}
// fin

Como vemos en el código anterior la clase TazaDeCafe implementa la interfaz MoldeTaza (Los métodos de las interfaces no se heredan, se implementan), es decir, los métodos que se describieron en la interfaz se reescriben con el cuerpo que corresponde de acuerdo a la clase, además se pone la anotación Override, que especifíca que el método no es propio de esta clase puesto que la primera vez que se escribió fue en una clase padre o en un interfaz que ha sido implementada. 

Y ¿Para qué usar moldes?
Tal vez una de las cosas más complejas de las interfaces no son en sí cómo hacerlas, lo que realmente las hace complejas es saber cuándo y por qué usarlas. Para entender esto debemos partir de un caso de prueba. Supongan que están haciendo un juego de ajedrez, todos sabes que hay un tablero en el cual hay varios tipos de fichas, todas estas son diferentes, se mueven diferente, se ven diferentes, pero al fin y al cabo no dejan de ser fichas. Este seria un caso ideal para usar interfaces, con una interfaz ficha definiremos todas las posibles acciones que tiene una ficha y cómo debe responder el tablero ante los objetos que implementan ésta interfaz, pero a la hora de hacer una ficha específica como el Caballo se especificarán la manera en que debe ejecutar las acciones este objeto.

Espero que les sea de utilidad.

martes, 23 de julio de 2013

Entendiendo Javascript (III)


Objetos por aquí, objetos por allá, muy bonito, muy bonito, pero de que sirve esto sin la Herencia?

Herencia
Retomando, JavaScript nos provee ciertas herramientas para poder usar programación orientada a objetos, entre estas los prototipos, de esta manera podemos hacer gala de nuestras habilidades con este paradigma, pero aún hace falta una de las mas importantes herramientas, la herencia.
La herencia en JavaScript se hace al igual que las clases mediante el prototipo, pero hay dos maneras de implementarla:

Herencia Mediante Cadena de Prototipos:
Este tipo de herencia se hace mediante el uso del prototipo de los objetos, de esta manera:

// Ejemplo de Herencia por prototipos

// clase padre
function Mamifero(medio, num_extremidades, sonido){
    this.medio = medio; 
    this.extremidades = num_extremidades;
    this.saludo = function(){console.log(sonido)};
}

// clase hija
function Perro(raza){
    this.raza = raza;
}
// especificamos cual es la clase padre
Perro.prototype = new Mamifero("terrestre", 4, "Guauu, Guauu...");
fluffy = new Perro("Doberman");
fluffy.saludo()
// Fin del ejemplo

Lo que acabamos de ver se llama cadena de prototipos, y esta se basa en que una clase hija lo que hace es reemplazar su prototipo por una instancia de la clase padre, por esto se hace la asignación de una instancia de la clase padre al prototipo como vemos en la linea 15.

Herencia mediante llamado al Constructor del Padre:
Este tipo de herencia hace uso del constructor de la clase padre de manera directa, se hace así:
// Ejemplo de Herencia por prototipos

// clase padre
function Mamifero(medio, num_extremidades, sonido){
    this.medio = medio; 
    this.extremidades = num_extremidades;
    this.saludo = function(){console.log(sonido)};
}

// clase hija
function Gato(raza){
    Mamifero.call(this,"terrestre", 4, "Miauu, Miauu...");
    this.raza = raza;
}
// insatancia de la clase
jack = new Gato("Angora")
jack.saludo()
// Fin del ejemplo

Lo que acabamos de ver fue otra manera de usar herencia en JavaScript, esta es más interesante por que encapsula todo dentro del mismo bloque de código. Lo que se está haciendo es que se llama el constructor de la clase padre pero se especifica que los atributos y métodos de la clase padre deben ser establecidos en la clase actual, lo anterior se lleva a cabo mediante el método call, usado en la linea 12, el cual recibe como primer parámetro la referencia al objeto en construcción.