El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Herència

Següent ►
►

Introducció

L'herència és un concepte fonamental en la programació orientada a objectes (OOP) que permet crear noves classes a partir de classes existents. Això facilita la reutilització del codi i la creació de jerarquies de classes més organitzades i mantenibles.

Conceptes Clau

  • Classe Base (Superclasse): La classe de la qual s'hereten propietats i mètodes.
  • Classe Derivada (Subclasse): La classe que hereta propietats i mètodes de la classe base.
  • Sobreescriptura de Mètodes: La capacitat de redefinir mètodes de la classe base en la classe derivada.

Sintaxi Bàsica

En Dart, l'herència es defineix utilitzant la paraula clau extends. Aquí teniu un exemple bàsic:

class Animal {
  void makeSound() {
    print('Animal makes a sound');
  }
}

class Dog extends Animal {
  @override
  void makeSound() {
    print('Dog barks');
  }
}

void main() {
  Dog myDog = Dog();
  myDog.makeSound(); // Output: Dog barks
}

Explicació del Codi

  1. Classe Base (Animal):

    • Conté un mètode makeSound que imprimeix un missatge genèric.

  2. Classe Derivada (Dog):

    • Utilitza extends per heretar de Animal.
    • Sobreescriu el mètode makeSound per proporcionar una implementació específica.

  3. Funció main:

    • Crea una instància de Dog i crida el mètode makeSound, que imprimeix "Dog barks".

Sobreescriptura de Mètodes

La sobreescriptura de mètodes permet que una subclasse proporcioni una implementació específica d'un mètode que ja està definit en la seva superclasse. Això es fa utilitzant l'anotació @override.

class Vehicle {
  void start() {
    print('Vehicle is starting');
  }
}

class Car extends Vehicle {
  @override
  void start() {
    print('Car is starting');
  }
}

void main() {
  Car myCar = Car();
  myCar.start(); // Output: Car is starting
}

Constructores i Herència

Quan una subclasse hereta d'una superclasse, també hereta els seus constructors. No obstant això, pot definir els seus propis constructors i cridar els constructors de la superclasse utilitzant la paraula clau super.

class Person {
  String name;
  
  Person(this.name);
}

class Student extends Person {
  int studentId;
  
  Student(String name, this.studentId) : super(name);
}

void main() {
  Student student = Student('John Doe', 12345);
  print('Name: ${student.name}, Student ID: ${student.studentId}');
  // Output: Name: John Doe, Student ID: 12345
}

Explicació del Codi

  1. Classe Base (Person):

    • Té un constructor que inicialitza la propietat name.

  2. Classe Derivada (Student):

    • Té una propietat addicional studentId.
    • El seu constructor crida el constructor de la superclasse Person utilitzant super(name).

Exercicis Pràctics

Exercici 1

Crea una classe Shape amb un mètode area que retorni 0. Després, crea una subclasse Circle que sobreescrigui el mètode area per calcular l'àrea d'un cercle.

class Shape {
  double area() {
    return 0;
  }
}

class Circle extends Shape {
  double radius;
  
  Circle(this.radius);
  
  @override
  double area() {
    return 3.14 * radius * radius;
  }
}

void main() {
  Circle circle = Circle(5);
  print('Area of the circle: ${circle.area()}'); // Output: Area of the circle: 78.5
}

Exercici 2

Crea una classe Employee amb propietats name i salary. Després, crea una subclasse Manager que afegeixi una propietat department i sobreescrigui un mètode displayInfo per mostrar tota la informació.

class Employee {
  String name;
  double salary;
  
  Employee(this.name, this.salary);
  
  void displayInfo() {
    print('Name: $name, Salary: $salary');
  }
}

class Manager extends Employee {
  String department;
  
  Manager(String name, double salary, this.department) : super(name, salary);
  
  @override
  void displayInfo() {
    print('Name: $name, Salary: $salary, Department: $department');
  }
}

void main() {
  Manager manager = Manager('Alice', 75000, 'IT');
  manager.displayInfo(); // Output: Name: Alice, Salary: 75000, Department: IT
}

Resum

En aquesta secció, hem après sobre l'herència en Dart, incloent-hi com crear subclasses, sobreescriure mètodes i utilitzar constructors amb herència. L'herència és una eina poderosa per a la reutilització del codi i la creació de jerarquies de classes més organitzades. Amb aquests coneixements, estàs preparat per avançar cap a conceptes més avançats de la programació orientada a objectes en Dart.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats