Herencia
## Objetivos de Aprendizaje
- Comprender la herencia de clases
- Trabajar con clases abstractas
- Dominar interfaces
- Aprender mixins
## Conceptos Basicos de Herencia
### Extendiendo una Clase
```dart
class Animal {
String name;
Animal(this.name);
void eat() {
print('$name esta comiendo');
}
}
class Dog extends Animal {
Dog(String name) : super(name);
void bark() {
print('$name dice Guau!');
}
}
void main() {
var dog = Dog('Buddy');
dog.eat(); // Buddy esta comiendo
dog.bark(); // Buddy dice Guau!
}
```
### La Palabra Clave super
```dart
class Vehicle {
String brand;
Vehicle(this.brand);
void drive() {
print('Conduciendo $brand');
}
}
class Car extends Vehicle {
int doors;
Car(String brand, this.doors) : super(brand);
@override
void drive() {
super.drive();
print('Auto con $doors puertas');
}
}
void main() {
var car = Car('Toyota', 4);
car.drive();
// Conduciendo Toyota
// Auto con 4 puertas
}
```
## Clases Abstractas
### Definiendo Clase Abstracta
```dart
abstract class Shape {
// Metodo abstracto - sin implementacion
double area();
// Metodo concreto
void describe() {
print('Forma con area: ${area()}');
}
}
class Circle extends Shape {
double radius;
Circle(this.radius);
@override
double area() => 3.14159 * radius * radius;
}
class Rectangle extends Shape {
double width;
double height;
Rectangle(this.width, this.height);
@override
double area() => width * height;
}
void main() {
var circle = Circle(5);
circle.describe(); // Forma con area: 78.53975
var rect = Rectangle(4, 6);
rect.describe(); // Forma con area: 24
}
```
### No se Puede Instanciar Abstracta
```dart
abstract class Shape {
double area();
}
// var shape = Shape(); // Error: no se puede instanciar clase abstracta
```
## Interfaces
### Interface Implicita
```dart
// Toda clase define implicitamente una interfaz
class Person {
String name;
Person(this.name);
void greet() {
print('Hola, soy $name');
}
}
// Implementa interfaz
class Student implements Person {
@override
String name;
Student(this.name);
@override
void greet() {
print('Hola, soy $name y estudio');
}
}
void main() {
var student = Student('Alice');
student.greet(); // Hola, soy Alice y estudio
}
```
### Interface Explicita
```dart
class Reader {
void read() {
print('Leyendo...');
}
}
class Writer {
void write() {
print('Escribiendo...');
}
}
// Puede implementar multiples
class Author implements Reader, Writer {
@override
void read() {
print('Autor leyendo...');
}
@override
void write() {
print('Autor escribiendo...');
}
}
void main() {
var author = Author();
author.read();
author.write();
}
```
## Mixins
### Mixin Basico
```dart
mixin Flyable {
void fly() {
print('Volando!');
}
}
mixin Walkable {
void walk() {
print('Caminando!');
}
}
class Bird with Flyable, Walkable {
String name;
Bird(this.name);
}
void main() {
var bird = Bird('Gorrizon');
bird.fly(); // Volando!
bird.walk(); // Caminando!
}
```
### Mixin con Restricciones
```dart
mixin Navigator on Vehicle {
void navigate() {
print('Navegando...');
}
}
class Vehicle {
String brand = 'Generico';
}
// Solo puede mezclarse en Vehicle o subclases
class Car extends Vehicle with Navigator {
}
void main() {
var car = Car();
car.navigate();
}
```
### Mixin con Implementacion por Defecto
```dart
mixin PrintMixin {
void printData() {
print('Datos: ${getData()}');
}
String getData(); // Metodo requerido
}
class MyClass with PrintMixin {
@override
String getData() => 'Hola desde MyClass';
}
void main() {
var obj = MyClass();
obj.printData(); // Datos: Hola desde MyClass
}
```
## Mixin vs Extension
| Caracteristica | Mixin | Extension |
|----------------|-------|-----------|
| Agrega campos | Si | No |
| Agrega constructores | Si | No |
| Agrega metodos | Si | Si |
| Requiere definicion de clase | No | No |
| Multiples mixins | Si | Unico |
## Jerarquia de Clases
### Combinando Todo
```dart
abstract class Animal {
String name;
Animal(this.name);
void breathe() {
print('$name esta respirando');
}
}
abstract class Mammal extends Animal {
Mammal(super.name);
void walk() {
print('$name esta caminando');
}
}
mixin Flyable {
void fly() {
print('Volando');
}
}
class Bat extends Mammal with Flyable {
Bat(super.name);
}
void main() {
var bat = Bat('Bruce');
bat.breathe(); // Bruce esta respirando
bat.walk(); // Bruce esta caminando
bat.fly(); // Volando
}
```
## Sobre-escritura de Metodos
### Anotacion @override
```dart
class Parent {
void greet() {
print('Hola desde Parent');
}
}
class Child extends Parent {
@override
void greet() {
print('Hola desde Child');
}
}
void main() {
var child = Child();
child.greet(); // Hola desde Child
}
```
### super en Metodos Sobre-escritos
```dart
class Parent {
String greet() => 'Hola';
}
class Child extends Parent {
@override
String greet() {
return '${super.greet()} desde Child';
}
}
void main() {
print(Child().greet()); // Hola desde Child
}
```
## Abstract vs Interface
| Aspecto | Abstract | Interface |
|---------|----------|-----------|
| Metodos | Abstractos o concretos | Abstractos solo (antes de Dart 3) |
| Campos | Puede tener | No puede tener campos de instancia |
| Constructores | Puede tener | No puede tener |
| Multiples | Single extends | Multiple implements |
| Herencia | Single extends | Multiple implements |
## Resumen
- Herencia: `class Hijo extends Padre`
- `super` se refiere a la clase padre
- Clases abstractas: `abstract class` con metodos abstractos
- Interfaces: palabra clave `implements`, multiples permitidos
- Mixins: palabra clave `with`, agrega funcionalidad a clases
- `mixin M on T` restringe mixin a T o subclases
- `@override` indica sobre-escritura de metodo
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →