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