Mixin class mixin dans Dart

introduire

Mixin est un modèle de méthode permettant de réutiliser du code dans une classe en héritage multiple.

Les mixins sont des classes de langages de programmation orientés objet qui fournissent des implémentations de méthodes . Les autres classes peuvent accéder aux méthodes et aux variablesmixin de la classe sans en être une sous-classe .

Pour faire simple, le design officiel est une classe qui peut être réutilisée facilement, sans avoir à implémenter de nombreuses interfaces.

Scénario d'application

 Par exemple, il y a une super-classe d'Anmal, et il y a trois sous-classes en dessous : Mammifère, Oiseau et Poisson, et il y a plus de sous-classes en dessous.

Ici, nous prenons trois classes comme exemples, à savoir Duck, Cat et Dove. Parmi elles, Duck peut exécuter les trois méthodes, Cat peut marcher et Dove peut marcher et voler. Si vous voulez utiliser l'héritage pour l'implémenter, c'est comme suit :

abstract class Animal{}
abstract class Swim{
  void swim();
}
abstract class Walk{
  void walk();
}
abstract class Fly{
  void fly();
}

class Duck extends Animal implements Swim,Walk,Fly{
  @override
  void fly() => print("fly");

  @override
  void swim() => print("swim");

  @override
  void walk() => print("walk");

}
class Cat extends Animal implements Walk{
  @override
  void walk() => print("walk");
}
class Dove extends Animal implements Walk,Fly{
  @override
  void fly() => print("fly");

  @override
  void walk() => print("walk");
}
void main(){
  Duck().swim();
  Duck().walk();
  Duck().fly();
  Cat().walk();
  Dove().fly();
  Dove().walk();
}

Les résultats de sortie sont les suivants :

 Parce que dart est aussi un langage d'héritage unique, cette utilisation est exactement la même qu'en Java, mais il est très redondant de réécrire toutes les méthodes dans l'interface. Existe-t-il un moyen de réutiliser les méthodes dans l'interface ? Pour le moment Vous pouvez utiliser le mixin.

Nous utilisons mixin au lieu d'interface. Si vous souhaitez réutiliser la méthode de la classe mixin, il vous suffit d'ajouter le mot clé with après la classe, comme suit :

abstract class Animal{}

mixin Swim{
  void swim() => print("swim");
}
mixin Walk{
  void walk() => print("walk");
}
mixin Fly{
  void fly() => print("fly");
}

class Duck extends Animal with Swim,Walk,Fly{}
class Cat extends Animal with Walk{}
class Dove extends Animal with Walk,Fly{}

void main(){
  Duck().swim();
  Duck().walk();
  Duck().fly();
  Cat().walk();
  Dove().fly();
  Dove().walk();
}

Le résultat imprimé final est exactement le même que ci-dessus, et la méthode pour implémenter le cas particulier dans la classe est la même que la méthode d'utilisation de l'interface, il suffit de la réécrire directement.

Utilisation avancée

Propriétés de linéarisation des mixins

Si la même méthode existe dans la classe que nous mélangeons, comment sera-t-elle appelée ? Par exemple, la méthode run() est définie à la fois dans la classe Person et dans la classe A, appelons-la dans la classe Male

class Person{ run() => print("person"); }

mixin A{ run() => print("A"); }

class Male extends Person with A{}

main(){
  Male().run();
}

Le résultat est le suivant :

-------------------------------------------------- -------------------------------------------------- ---

 

A

 Ici, seule la méthode run() de la classe A est exécutée. Dans dart, il existe une fonctionnalité grammaticale appelée linéarisation

 Le code du mixin ci-dessus est équivalent à

Class PersonA = Person with A
Class Male extends PersonA;

 Cela équivaut à la réécriture de la méthode run() dans la classe Person par A, donc la méthode run() réécrite dans la classe A est appelée.

Nous avons alors un moyen d'appeler la méthode dans la classe Person ? La réponse est bien sûr oui, et c'est très simple, puisqu'il s'agit d'héritage, on peut appeler directement la méthode parent, plus super.run()

class Person{ run() => print("person"); }

mixin A{
  @override
  run() {
    super.run();
    print("A");
  }
}

class Male extends Person with A{}

main(){
  Male().run();
}

La sortie est :

person
A

sur

Lors de l'utilisation de mixin, vous pouvez utiliser le mot-clé on pour restreindre. Lors du mixage dans cette classe, vous devez d'abord hériter ou mélanger dans la classe derrière on

comme:

class Person{ run() => print("person"); }

mixin A{ run() => print("A"); }

mixin C on Person{
  @override
  run() {
    super.run();
    print("C");
  }
}

//这里还可以是
//class Femal extends Person with A,C{}

class Female with A,Person,C{}  //混入时,Person类必须在C之前

main(){
  Female().run();
}

sortie finale

person
C

référence

Analyse mixin dans dart - Attack on Summer's Blog - Blog CSDN - dart mixin

Compréhension approfondie de Mixin dans Dart - Programmeur recherché