Herencia
## Objetivos de Aprendizaje
- Comprender las relaciones de herencia
- Usar la palabra clave extends
- Sobrescribir métodos
- Dominar la palabra clave super
## ¿Qué es la Herencia?
Una forma de crear una nueva clase basada en una clase existente:
```java
// Clase padre
public class Animal {
String name;
int age;
public void eat() {
System.out.println("Eating...");
}
}
// Clase hija
public class Dog extends Animal {
String breed;
public void bark() {
System.out.println("Woof!");
}
}
```
## ¿Por qué Herencia?
### Reutilización de Código
```java
Dog dog = new Dog();
dog.name = "Buddy"; // Heredado de Animal
dog.age = 3; // Heredado de Animal
dog.eat(); // Heredado de Animal
dog.bark(); // Método propio de Dog
```
### Organización Jerárquica
```text
Animal (padre)
├── Dog (hijo)
├── Cat (hijo)
└── Bird (hijo)
```
## La Palabra Clave extends
```java
public class Parent {
// campos y métodos
}
public class Child extends Parent {
// hereda todos los miembros de Parent
// añade sus propios campos y métodos
}
```
## Sobrescritura de Métodos
### Anotación @Override
```java
public class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}
```
### Llamar al Método Padre
```java
public class Dog extends Animal {
@Override
public void makeSound() {
super.makeSound(); // Llamar la versión del padre primero
System.out.println("Woof!");
}
}
```
## Palabra Clave super
### Referencia a la Clase Padre
```java
public class Child extends Parent {
public Child(String name, int age) {
super(name); // Llamar constructor de Parent
super.name = "Override"; // Acceder campo del padre
}
@Override
public void someMethod() {
super.someMethod(); // Llamar versión del padre
}
}
```
### super() Constructor
```java
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
}
public class Dog extends Animal {
private String breed;
public Dog(String name, String breed) {
super(name); // Debe ser la primera sentencia
this.breed = breed;
}
}
```
## Herencia y Constructores
### Encadenamiento de Constructores
```java
public class GrandParent {
public GrandParent() {
System.out.println("GrandParent constructor");
}
}
public class Parent extends GrandParent {
public Parent() {
super(); // Llamado automáticamente si no es explícito
System.out.println("Parent constructor");
}
}
public class Child extends Parent {
public Child() {
super(); // Llamado automáticamente
System.out.println("Child constructor");
}
}
// Salida:
// GrandParent constructor
// Parent constructor
// Child constructor
```
## Control de Acceso con Herencia
### Qué Hereda la Clase Hija
| Miembro | private | (por defecto) | protected | public |
|---------|---------|---------------|-----------|--------|
| Heredado | No | Sí | Sí | Sí |
| Accesible | No | Sí | Sí | Sí |
### Acceso Protected
```java
public class Animal {
protected int age; // Accesible en subclases
}
public class Dog extends Animal {
public void setAge(int age) {
this.age = age; // OK - protected accesible
}
}
```
## Herencia Multinivel
```java
public class A { }
public class B extends A { }
public class C extends B { }
// C hereda de B, que hereda de A
```
## Herencia Simple
Java solo permite UN padre directo:
```java
// Esto NO está permitido en Java
public class A { }
public class B { }
public class C extends A, B { } // ¡Error!
```
## Clase Object
### Padre Ultimo
```java
public class Dog extends Object { // Implícito
// equals(), hashCode(), toString() heredados de Object
}
Dog dog = new Dog();
dog.toString(); // de la clase Object
```
## Operador instanceof
### Verificación de Tipo
```java
public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }
Animal animal = new Dog();
if (animal instanceof Dog) {
Dog dog = (Dog) animal; // Cast seguro
dog.bark();
}
```
### Pattern Matching Java 16+
```java
if (animal instanceof Dog dog) {
dog.bark(); // Acceso directo, sin cast necesario
}
```
## Ocultamiento de Métodos
### Métodos Estáticos
```java
public class Parent {
public static void staticMethod() {
System.out.println("Parent static");
}
}
public class Child extends Parent {
public static void staticMethod() {
System.out.println("Child static");
}
}
Parent.staticMethod(); // Parent static
Child.staticMethod(); // Child static
```
## Clases Final
### No Se Pueden Extender
```java
public final class MathUtils {
public static int add(int a, int b) {
return a + b;
}
}
// public class ExtendedMath extends MathUtils { } // ¡Error!
```
## Resumen
- Herencia: `class Hija extends Padre`
- La hija hereda todos los campos y métodos del padre (excepto private)
- Sobrescribir métodos con `@Override`
- Usar `super` para acceder miembros del padre
- Las llamadas a constructores se encadenan: `super()` debe ser primero
- `protected` accesible en subclases
- Solo herencia simple (un padre)
- `instanceof` verifica el tipo de objeto
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →