Herencia

Herencia

El paradigma orientado a objetos plantea el concepto de la herencia como una poderosa característica que otorga la capacidad de crear nuevas clases partiendo de otra definida previamente. Esto permite que la nueva clase herede sus atributos y métodos.

Esta característica nos permite reutilizar código, pero sobre todo, nos permite especializar las clases. Es decir, en lugar de crear una clase desde cero o modificar una clase existente, podemos crear una nueva clase que extienda las características y/o comportamientos de otra.

• La clase de la cual se hereda se conoce como clase padre, clase base o superclase.
• La clase que hereda se conoce como clase hija, clase derivada o subclase.

En Java, la herencia se define mediante la palabra clave extends empleando la siguiente sintaxis:

class <Clase Hija> extends <Clase Padre> {
    // ...
}

Como vemos, al definir una clase, podemos indicar que esta hereda de otra. Con lo cual todos los atributos y métodos de la clase padre, serán heredados por la clase hija también.

Clase padre y clase hija

La clase hija puede agregar nuevos atributos y métodos, o sobrecargar los métodos heredados de la clase padre.

Para ver este concepto de manera más clara, estableceremos la superclase Vehicle, de la cual heredaremos luego.

class Vehicle {
    private String brand;
    private String model;
    private int year;

    public Vehicle(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    public String getBrand() {
        return brand;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }
}

No obstante, podríamos tener la necesidad de crear nuevas clases que tienen en común los atributos y métodos de la clase Vehicle, pero que además tienen atributos y/o métodos propios. Por ejemplo, podríamos tener la necesidad de crear una clase Car.

class Car extends Vehicle {
    private int doors;

    public Car(String brand, String model, int year, int doors) {
        super(brand, model, year);
        this.doors = doors;
    }

    public int getDoors() {
        return doors;
    }
}

En este ejemplo podemos notar, que al momento de definir el constructor de la clase Car, estamos utilizando la palabra reservada super.

Palabra reservada super

La palabra reservada super nos permite acceder a los métodos de la clase padre.

En este caso, empleamos super para acceder al constructor de la clase Vehicle. De esta forma, delegamos la tarea de inicializar los atributos brand, model y year a la clase padre, y nos concentramos solo en inicializar los atributos propios de la clase Car.

De igual manera, podríamos usar super para acceder otros métodos de la clase padre. Por ejemplo, dentro de la clase Car, podríamos invocar el método getBrand() de la clase Vehicle de la siguiente forma:

super.getBrand();

Así también, podríamos definir tantas clases hijas como necesitemos. Por ejemplo, podríamos definir la clase Motorcycle de la siguiente forma:

class Motorcycle extends Vehicle {
    private int cc;

    public Motorcycle(String brand, String model, int year, int cc) {
        super(brand, model, year);
        this.cc = cc;
    }

    public int getCc() {
        return cc;
    }
}

Sobrecarga y sobreescritura de métodos

La sobrecarga de métodos es una característica de la que hemos hablado anteriormente, y que nos permite definir varios métodos con el mismo nombre pero con diferentes firmas.

Por otro lado, en el contexto de la herencia, podemos encontrarnos con un concepto similar, conocido como sobreescritura de métodos.

A diferencia de la sobrecarga de métodos, la sobreescritura de métodos nos permite redefinir un método heredado de la clase padre. Es decir, estamos modificando un método heredado, para adaptarlo a las necesidades de la clase hija.

Establezcamos un nuevo ejemplo para ver este concepto de manera más clara. En este caso, definiremos la clase Character, la cual representa un personaje de un videojuego.

class Character {
    private String name;
    private int level;
    private int health;

    public Character(String name, int level, int health) {
        this.name = name;
        this.level = level;
        this.health = health;
    }

    public String getName() {
        return name;
    }

    public int getLevel() {
        return level;
    }

    public int getHealth() {
        return health;
    }

    public void attack() {
        System.out.println("Atacando...");
        System.out.println("Daño: 10");
    }
}

Ahora, definiremos la clase Warrior, la cual representa un guerrero. Es decir, un personaje especializado en el combate cuerpo a cuerpo. Con esto en mente, podemos pensar que el método attack() de la clase Character no es suficiente para representar el ataque de un guerrero y nos gustaría que el daño que este realiza dependa de su nivel y de un nuevo atributo que definiremos, su fuerza.

Para esto nos veremos en la necesidad de sobreescribir el método attack(), para adaptarlo a las necesidades de la clase Warrior. En Java, podemos sobreescribir un método de la clase padre mediante la anotación @Override.

class Warrior extends Character {
    private int strength;

    public Warrior(String name, int level, int health, int strength) {
        super(name, level, health);
        this.strength = strength;
    }

    public int getStrength() {
        return strength;
    }

    @Override
    public void attack() {
        System.out.println("Atacando...");
        System.out.println("Daño: " + (10 * getLevel() + getStrength()));
    }
}

Como vemos, antes de definir el método attack(), hemos agregado la anotación @Override. Esta anotación nos permite indicarle al compilador que estamos sobreescribiendo un método de la clase padre. De esta forma, podremos realizar la misma operación tanto para objetos de la clase Character como para objetos de la clase Warrior.

De la misma manera, podemos sobreescibir métodos de la clase padre en cualquier otra clase hija. Por ejemplo, podríamos definir la clase Wizard, la cual representa un mago. Es decir, un personaje especializado en el combate a distancia. Con esto en mente, nos gustaría que el daño que este realiza dependa de su nivel y de un nuevo atributo que definiremos, su mana.

class Wizard extends Character {
    private int mana;

    public Wizard(String name, int level, int health, int mana) {
        super(name, level, health);
        this.mana = mana;
    }

    public int getMana() {
        return mana;
    }

    public void setMana(int mana) {
        this.mana = mana;
    }

    @Override
    public void attack() {
        System.out.println("Atacando...");
        System.out.println("Daño: " + (10 * getLevel() + getMana()));
        setMana(getMana() - 10);
    }
}

Herencia múltiple

La herencia múltiple es una característica que permite que una clase herede de más de una clase padre. En Java, la herencia múltiple no es permitida, ya que puede generar conflictos en el código.

Sin embargo, existen alternativas para simular la herencia múltiple y, en la práctica, obtener el mismo resultado. Para ello se emplea el concepto de interfaces, el cual veremos más adelante. De momento, nos concentraremos en la herencia simple.

Jeraquía de clases

La herencia nos permite crear una jerarquía de clases, una estructura en la que una clase hija hereda de una clase padre, y esta a su vez hereda de otra clase padre, y así sucesivamente.

Siguiendo con el ejemplo planteado sobre los personajes de un videojuego, podríamos definir la clase Character como una clase padre, y definir las clases Warrior y Wizard como clases hijas.

Además, esta última podría ser padre de otra clase. Por ejemplo, podríamos definir la clase AncientWizard, la cual representa un mago mucho más poderoso que el mago común, y que agrega comportamientos y características propias. Por supuesto, esta clase herada de la clase Wizard.

class AncientWizard extends Wizard {
    private int wisdom;

    public AncientWizard(String name, int level, int health, int mana, int wisdom) {
        super(name, level, health, mana);
        this.wisdom = wisdom;
    }

    public int getWisdom() {
        return wisdom;
    }

    @Override
    public void attack() {
        System.out.println("Atacando...");
        System.out.println("Daño: " + (10 * getLevel() + getMana() + getWisdom()));
    }
}

Gráficamente podemos representar esta jerarquía mediante un árbol de herencia, en el cual cada nodo representa una clase, y cada rama representa una relación de herencia.

En Java, veremos que existen muchos de estos árboles de herencia para clases que ya están definidas. Podemos entender mejor el comportamiento de las mismas si analizamos su jerarquía de clases.

La herencia puede se interpretada mediante la analogía de es un. Por ejemplo, en la naturaleza podríamos decir que un perro es un animal, y que un gato es un animal. De la misma manera, podríamos decir que un perro es un mamífero, y que un gato es un mamífero. Si abstrajéramos este tipo de entidades a componentes de software veríamos que estas realaciones se mantienen y que podemos aplicarlas a la herencia.

Igualmente con nuestro ejemplo de personajes de videojuegos, podemos decir que un Warrior es un Character, y que un Wizard es un Character. De la misma manera, podemos decir que un AncientWizard es un Wizard.

Así podríamos seguir atrás en la jerarquía de clases, y nos daríamos cuenta que todas las clases, ya sea las que definimos nosotros o las que nos provee Java, heredan de una clase padre común, la clase Object.

Es decir, cualquier instancia es un Object.