Inheritance: extends, super, and overriding · ⁨Herencia: extends, super y overriding⁩

English

Inheritance: building on a class

Inheritance lets one class reuse another class's fields and methods.
The class you build on is the superclass (parent); the new class is the subclass (child).
A subclass is-a kind of its superclass: a Dog is an Animal.

Español

Herencia: construir sobre una clase

La herencia permite que una clase reutilice los campos y métodos de otra clase.
La clase en la que te basas es la clase padre (superclase); la nueva clase es la clase hija (subclase).
Una subclase es-un tipo de su superclase: un Dog es un Animal.

Una superclase Animal; Dog y Cat la extienden cada uno e invocan speak()

English

`extends` and `super`

Write class Dog extends Animal to make Dog a subclass of Animal.
Dog automatically gets every public method of Animal, like getName().
The subclass constructor calls the superclass constructor first with super(...).

Español

`extends` y `super`

Escribe class Dog extends Animal para hacer que Dog sea una subclase de Animal.
Dog obtiene automáticamente todos los métodos públicos de Animal, como getName().
El constructor de la subclase llama primero al constructor de la superclase con super(...).

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        System.out.println(d.getName());   // Rex   (inherited from Animal)
        System.out.println(d.speak());     // Woof  (Dog's own version)
    }
}

class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return this.name; }
    public String speak() { return "some sound"; }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);          // run Animal's constructor
    }
    public String speak() {   // override Animal's speak()
        return "Woof";
    }
}

English

Overriding a method

A subclass can override an inherited method: give it the same signature, a new body.
Dog's speak() replaces Animal's speak() for Dog objects.
Methods it does not override (like getName()) are still inherited unchanged.

Español

Invocar un método

Una subclase puede invocar un método heredado: le da la misma firma, un nuevo cuerpo.
El Dog de speak() reemplaza al Animal de speak() para los objetos Dog.
Los métodos que no invoca (como getName()) se heredan sin cambios.

English

`super.method()` — extend, don't replace

Sometimes you want the parent's work plus a little more.
Inside an override, super.describe() runs the superclass version of the method.
Then you add to its result instead of rewriting it from scratch.

Español

`super.method()` — extender, no reemplazar

A veces quieres que el trabajo del padre más un poco más.
Dentro de una invocación, super.describe() ejecuta la versión de la superclase del método.
Luego agregas a su resultado en lugar de reescribirlo desde cero.

public class Main {
    public static void main(String[] args) {
        Bird b = new Bird("Tweety");
        System.out.println(b.describe());
        // I am an animal named Tweety, and I can fly
    }
}

class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String describe() { return "I am an animal named " + this.name; }
}

class Bird extends Animal {
    public Bird(String name) { super(name); }
    public String describe() {
        return super.describe() + ", and I can fly";   // reuse, then add
    }
}

English

is-a: a subclass fits where its superclass is expected

Because a Dog is an Animal, you can write Animal a = new Dog("Spot");.
The variable's type is Animal, but the object is really a Dog.
This "is-a" rule is what makes the next lesson — polymorphism — possible.

Español

is-a: una subclase encaja donde se espera su superclase

Porque un Dog es un Animal, puedes escribir Animal a = new Dog("Spot");.
El tipo de la variable es Animal, pero el objeto es realmente un Dog.
Esta regla "is-a" es lo que hace posible la siguiente lección: polimorfismo.

English

Common mistakes

super(...) must be the first line of a subclass constructor.
Add @Override so the compiler catches a wrong signature.

Español

Errores comunes

super(...) debe ser la primera línea de un constructor de subclase.
Agrega @Override para que el compilador detecte una firma incorrecta.

English

Now you try

Each task gives you a finished Animal superclass. Write or complete the subclass below it.
A hidden Harness builds your object and checks both inherited and new behaviour.
Press Run to compile, then Check answer. Your code runs on the server, so even the first run is fast.

Español

Ahora tú intentas

Cada tarea te ofrece una superclase Animal terminada. Escribe o completa la subclase debajo de ella.
Un Controlador oculto construye tu objeto y verifica tanto el comportamiento heredado como el nuevo.
Presiona Run para compilar, luego Check answer. Tu código se ejecuta en el servidor, así que incluso la primera ejecución es rápida.

Below the finished Animal, write a class Cat that extends Animal. Give it a constructor Cat(String name) that passes the name up with super(name). Add nothing else — Cat should inherit getName() for free. · ⁨Debajo de la clase Animal terminada, escribe una clase Cat que extienda Animal. Dale un constructor Cat(String name) que pase el nombre hacia arriba con super(name). No añadas nada más — Cat debería heredar getName() automáticamente.⁩

// Animal is written for you. Do not change it.
class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return this.name; }
    public String speak() { return "some sound"; }
    public String describe() { return "I am an animal named " + this.name; }
}

// TODO: write a class Cat that extends Animal.
//   - constructor Cat(String name) that calls super(name)
//   - nothing else: Cat inherits getName() for free

Click Run to see the output here. · ⁨Haz clic en Ejecutar para ver la salida aquí.⁩

Complete the class Cow (it already extends Animal). Override speak() so a Cow returns · ⁨ retornos ⁩"Moo" instead of the default. getName() must still work (inherited). · ⁨Completa la clase Cow (ya extiende Animal). Sobreescribe speak() para que una Cow devuelva "Moo" en lugar del valor por defecto. getName() debe seguir funcionando (heredado).⁩

// Animal is written for you. Do not change it.
class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return this.name; }
    public String speak() { return "some sound"; }
    public String describe() { return "I am an animal named " + this.name; }
}

class Cow extends Animal {
    public Cow(String name) {
        super(name);
    }

    // TODO: override speak() so a Cow returns "Moo"
}

Click Run to see the output here. · ⁨Haz clic en Ejecutar para ver la salida aquí.⁩

Complete the class Fish (it already extends Animal). Override describe() so it returns the Animal description plus ", and I can swim". Reuse the parent's work by calling super.describe() — do not rewrite the whole sentence. · ⁨Completa la clase Fish (ya extiende Animal). Sobreescribe describe() para que devuelva la descripción de Animal más ", and I can swim". Reutiliza el trabajo del padre llamando a super.describe() — no reescribas toda la oración.⁩

// Animal is written for you. Do not change it.
class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return this.name; }
    public String speak() { return "some sound"; }
    public String describe() { return "I am an animal named " + this.name; }
}

class Fish extends Animal {
    public Fish(String name) {
        super(name);
    }

    // TODO: override describe() to return super.describe() + ", and I can swim"
}

Click Run to see the output here. · ⁨Haz clic en Ejecutar para ver la salida aquí.⁩

Inheritance: extends, super, and overriding · ⁨Herencia: extends, super y overriding⁩

Inheritance: building on a class

Herencia: construir sobre una clase

`extends` and `super`

`extends` y `super`

Overriding a method

Invocar un método

`super.method()` — extend, don't replace

`super.method()` — extender, no reemplazar

is-a: a subclass fits where its superclass is expected

is-a: una subclase encaja donde se espera su superclase

Common mistakes

Errores comunes

Now you try

Ahora tú intentas

Handout · ⁨Material⁩

Log in or create account · ⁨Iniciar sesión o crear cuenta⁩

Your subject · ⁨Tu asignatura⁩

All sections · ⁨Todas las secciones⁩

Feedback & help · ⁨Comentarios y ayuda⁩

Inheritance: extends, super, and overriding · ⁨Herencia: extends, super y overriding⁩

Inheritance: building on a class

Herencia: construir sobre una clase

extends and super

extends y super

Overriding a method

Invocar un método

super.method() — extend, don't replace

super.method() — extender, no reemplazar

is-a: a subclass fits where its superclass is expected

is-a: una subclase encaja donde se espera su superclase

Common mistakes

Errores comunes

Now you try

Ahora tú intentas

`extends` and `super`

`extends` y `super`

`super.method()` — extend, don't replace

`super.method()` — extender, no reemplazar