Dart Herencia y Polimorfismo
La herencia es una de las tres características principales de la programación orientada a objetos; permite que una clase se extienda basándose en otra.
Este capítulo presenta la herencia única con extends en Dart, la sobrescritura de métodos, la palabra clave super y las clases abstractas.
extends herencia única
Dart solo admite herencia única: cada clase solo puede tener una clase padre directa.
Pero la cadena de herencia puede ser larga: la subclase hereda de la clase padre, la clase padre hereda de la clase abuela, transmitiéndose nivel por nivel.
Ejemplo
class Animal {
String name;
Animal(this.name);
void eat() {
print('$name está comiendo');
}
void sleep() {
print('$name está durmiendo');
}
}
// Subclase: usa extends para heredar de Animal
class Dog extends Animal {
String breed; // raza
// El constructor de la subclase debe llamar al constructor de la clase padre
Dog(String name, this.breed) : super(name);
// Método nuevo de la subclase
void bark() {
print('$name ($breed) está ladrando!');
}
}
void main() {
var dog = Dog('Wangcai', 'Golden Retriever');
// Llamar a un método heredado de la clase padre
dog.eat();
dog.sleep();
// Llamar al método propio de la subclase
dog.bark();
// El objeto de la subclase también es del tipo de la clase padre
Animal animal = dog; // Dog es Animal, se puede convertir hacia arriba (upcasting)
animal.eat();
}
Wangcai está comiendo Wangcai está durmiendo ¡Wangcai (Golden Retriever) está ladrando! Wangcai está comiendo
La subclase puede acceder a todas las variables miembro y métodos no privados de la clase padre.
Los miembros privados (que comienzan con guion bajo) no se heredan.
Dart no tiene palabras clave public, protected ni private. Los miembros que comienzan con guion bajo (_) son privados a nivel de biblioteca (library-private) y solo pueden accederse dentro del mismo archivo. Esto es diferente del control de acceso de Java/C++.
Sobrescritura de métodos @override
La subclase puede sobrescribir (override) los métodos de la clase padre para proporcionar su propia implementación.
Utilizar la anotación @override indica claramente la intención de sobrescribir; el compilador te ayudará a comprobar si la sobrescritura es correcta.
Ejemplo
String name;
Animal(this.name);
// Método de la clase padre
void makeSound() {
print('$name emitió algunos sonidos');
}
@override
String toString() {
return 'Animal: $name';
}
}
class Cat extends Animal {
Cat(String name) : super(name);
// Anotación @override: le indica al compilador que estoy sobrescribiendo un método de la clase padre
@override
void makeSound() {
print('$name maúlla~');
}
}
class Duck extends Animal {
Duck(String name) : super(name);
@override
void makeSound() {
print('$name hace cuac!');
}
}
void main() {
var cat = Cat('Xiaohua');
var duck = Duck('Pato Donald');
cat.makeSound();
duck.makeSound();
// Polimorfismo: el mismo método tiene diferentes comportamientos en diferentes objetos
List<Animal> animals = [
Cat('Mimi'),
Duck('Yaya'),
Cat('Qiuqiu'),
];
print('--- ZOOLÓGICO EJEMPLO ---');
for (var animal in animals) {
animal.makeSound(); // En tiempo de ejecución se llama al método del tipo real
}
}
小花 喵喵叫~ 唐老鸭 嘎嘎叫! --- EJEMPLO 动物园 --- 咪咪 喵喵叫~ 鸭鸭 嘎嘎叫! 球球 喵喵叫~
El ejemplo anterior muestrapolimorfismo (Polymorphism): la misma llamada al método animal.makeSound() ejecuta un comportamiento que depende del tipo real del objeto.
Usar la anotación @override tiene dos ventajas: primero, hace que la intención del código sea más clara; segundo, si la clase padre no tiene un método con el mismo nombre (por ejemplo, un error de ortografía), el compilador mostrará un error. Se recomienda añadir siempre @override.
La palabra clave super
super representa el objeto de la clase padre; la subclase utiliza super para llamar al constructor, métodos y propiedades de la clase padre.
Ejemplo
String brand;
int year;
Vehicle(this.brand, this.year);
void start() {
print('El vehículo $brand ha arrancado');
}
void displayInfo() {
print('Marca: $brand, Año: $year');
}
}
class ElectricCar extends Vehicle {
int batteryLevel;
ElectricCar(String brand, int year, this.batteryLevel)
: super(brand, year); // Llamar al constructor de la clase padre
@override
void start() {
// Llamar al método de la clase padre dentro de un método de la subclase
super.start(); // Primero se ejecuta la lógica de arranque de la clase padre
print('Nivel de batería: $batteryLevel%');
print('Motor eléctrico arrancado en silencio');
}
@override
void displayInfo() {
super.displayInfo(); // Primero se muestra la información básica de la clase padre
print('Nivel de batería: $batteryLevel%'); // Luego se agrega la información específica de la subclase
}
}
void main() {
var car = ElectricCar('EJEMPLO EV', 2026, 85);
car.start();
print('---');
car.displayInfo();
}
EJEMPLO EV 车辆启动了 电池电量: 85% 电动机无声启动完成 --- 品牌: EJEMPLO EV, 年份: 2026 电池电量: 85%
Resumen de casos de uso de super
| Escenario | Sintaxis | Descripción |
|---|---|---|
| Llamar al constructor de la clase padre | : super(args) | Debe llamarse en la lista de inicialización |
| Llamar a métodos de la clase padre | super.methodName() | Se puede llamar en métodos sobrescritos de la subclase |
| Acceder a propiedades de la clase padre | super.propertyName | Acceder a variables miembro de la clase padre |
Clases abstractas abstract
Una clase abstracta es una clase que no puede instanciarse directamente; solo define la especificación de la interfaz, y las subclases implementan la lógica concreta.
Ejemplo
abstract class Shape {
// Método abstracto: sin cuerpo, la subclase debe implementarlo
double getArea();
double getPerimeter();
// Las clases abstractas también pueden tener métodos concretos
void describe() {
print('Esta es una forma, área: ${getArea()}, perímetro: ${getPerimeter()}');
}
}
class Rectangle extends Shape {
double width;
double height;
Rectangle(this.width, this.height);
@override
double getArea() => width * height;
@override
double getPerimeter() => 2 * (width + height);
}
class Circle extends Shape {
double radius;
Circle(this.radius);
@override
double getArea() => 3.14159 * radius * radius;
@override
double getPerimeter() => 2 * 3.14159 * radius;
}
void main() {
// Shape shape = Shape(); // ¡Error! Las clases abstractas no pueden instanciarse
var rect = Rectangle(10, 5);
var circle = Circle(7);
rect.describe();
circle.describe();
// La clase abstracta se usa como tipo
List<Shape> shapes = [
Rectangle(3, 4),
Circle(5),
Rectangle(6, 2),
];
print('--- ESTADÍSTICAS DE FORMAS EJEMPLO ---');
double totalArea = 0;
for (var shape in shapes) {
totalArea += shape.getArea();
}
print('Área total: ${totalArea.toStringAsFixed(2)}');
}
这是一个形状,面积: 50.0, 周长: 30.0 这是一个形状,面积: 153.93791, 周长: 43.98226 --- EJEMPLO 形状统计 --- 总面积: 108.54
Otras extensionesEl valor principal de una clase abstracta es "definir un contrato". Les dice a todas las subclases: debes implementar estos métodos, o la compilación no pasará. Esto hace que la colaboración en equipo sea más segura: quien implementa no omitirá métodos, y quien llama tiene la certeza de que los métodos existen.