La herencia es uno de los pilares fundamentales de la Programación Orientada a Objetos (POO). Permite que una clase (subclase o clase derivada) herede campos y métodos de otra clase (superclase o clase base). Esto promueve la reutilización del código y establece una relación jerárquica entre las clases.

Conceptos Clave

  1. Superclase (Clase Base): La clase de la cual se heredan campos y métodos.
  2. Subclase (Clase Derivada): La clase que hereda campos y métodos de la superclase.
  3. Palabra clave extends: Utilizada para indicar que una clase hereda de otra.

Ejemplo Básico de Herencia

Superclase: Animal

public class Animal {
    // Campos
    protected String name;
    protected int age;

    // Constructor
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Método
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

Subclase: Dog

public class Dog extends Animal {
    // Campo adicional
    private String breed;

    // Constructor
    public Dog(String name, int age, String breed) {
        super(name, age); // Llamada al constructor de la superclase
        this.breed = breed;
    }

    // Método adicional
    public void fetch() {
        System.out.println(name + " is fetching the ball!");
    }

    // Sobrescritura de método
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

Uso de las Clases

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy", 3, "Golden Retriever");
        myDog.makeSound(); // Salida: Bark
        myDog.fetch(); // Salida: Buddy is fetching the ball!
    }
}

Explicación del Código

  1. Superclase Animal:

    • Tiene dos campos: name y age.
    • Un constructor que inicializa estos campos.
    • Un método makeSound que imprime un sonido genérico.
  2. Subclase Dog:

    • Hereda los campos y métodos de Animal.
    • Añade un campo adicional breed.
    • Tiene su propio constructor que llama al constructor de la superclase usando super.
    • Añade un método fetch.
    • Sobrescribe el método makeSound para proporcionar una implementación específica.

Ejercicio Práctico

Ejercicio 1: Crear una Jerarquía de Clases

  1. Crear una superclase Vehicle con los siguientes campos y métodos:

    • Campos: make (marca), model (modelo), year (año).
    • Constructor para inicializar estos campos.
    • Método startEngine que imprime "Engine started".
  2. Crear una subclase Car que herede de Vehicle y añada:

    • Campo adicional: numberOfDoors (número de puertas).
    • Constructor que inicialice todos los campos, incluyendo los de la superclase.
    • Método honk que imprima "Honk! Honk!".

Solución

Superclase: Vehicle

public class Vehicle {
    protected String make;
    protected String model;
    protected int year;

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

    public void startEngine() {
        System.out.println("Engine started");
    }
}

Subclase: Car

public class Car extends Vehicle {
    private int numberOfDoors;

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

    public void honk() {
        System.out.println("Honk! Honk!");
    }
}

Uso de las Clases

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Corolla", 2020, 4);
        myCar.startEngine(); // Salida: Engine started
        myCar.honk(); // Salida: Honk! Honk!
    }
}

Resumen

En esta sección, hemos aprendido sobre la herencia en Java, cómo crear superclases y subclases, y cómo utilizar la palabra clave extends para establecer relaciones jerárquicas entre clases. También hemos visto cómo sobrescribir métodos y añadir nuevos campos y métodos en las subclases. La herencia es una herramienta poderosa que permite la reutilización del código y la creación de estructuras de clases más organizadas y mantenibles.

Curso de Programación en Java

Módulo 1: Introducción a Java

Módulo 2: Flujo de Control

Módulo 3: Programación Orientada a Objetos

Módulo 4: Programación Orientada a Objetos Avanzada

Módulo 5: Estructuras de Datos y Colecciones

Módulo 6: Manejo de Excepciones

Módulo 7: Entrada/Salida de Archivos

Módulo 8: Multihilo y Concurrencia

Módulo 9: Redes

Módulo 10: Temas Avanzados

Módulo 11: Frameworks y Librerías de Java

Módulo 12: Construcción de Aplicaciones del Mundo Real

© Copyright 2024. Todos los derechos reservados