Mixins

Los mixins son una forma de definir código que se puede reutilizar en múltiples jerarquías de clases. Están pensados para proporcionar implementaciones de miembros en masa.

Para usar un mixin, usa la palabra clave with seguida de uno o más nombres de mixins. El siguiente ejemplo muestra dos clases que usan (o son subclases de) mixins:

class Musician extends Performer with Musical {
  // ···
}
​
class Maestro extends Person with Musical, Aggressive, Demented {
  Maestro(String maestroName) {
    name = maestroName;
    canConduct = true;
  }
}

Para definir un mixin, usa la declaración mixin. En el caso poco común de que necesites definir tanto un mixin como una clase, puedes usar la declaración mixin class.

Los mixins y las clases mixin no pueden tener una cláusula extends, y no deben declarar ningún constructor generativo.

Por ejemplo:

mixin Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;
​
  void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}

A veces, un mixin depende de poder invocar un método o acceder a campos, pero no puede definir esos miembros por sí mismo (porque los mixins no pueden usar parámetros de constructor para instanciar sus propios campos).

Las siguientes secciones cubren diferentes estrategias para garantizar que cualquier subclase de un mixin defina los miembros de los que depende el comportamiento del mixin.

Declarar un método abstracto en un mixin obliga a cualquier tipo que use el mixin a definir el método abstracto del cual depende su comportamiento.

mixin Musician {
  void playInstrument(String instrumentName); // Abstract method.
​
  void playPiano() {
    playInstrument('Piano');
  }
  void playFlute() {
    playInstrument('Flute');
  }
}
​
class Virtuoso with Musician {
​
  @override
  void playInstrument(String instrumentName) { // Subclass must define.
    print('Plays the $instrumentName beautifully');
  }
}

Declarar miembros abstractos también te permite acceder al estado en la subclase de un mixin, llamando a getters que están definidos como abstractos en el mixin:

/// Can be applied to any type with a [name] property and provides an
/// implementation of [hashCode] and operator `==` in terms of it.
mixin NameIdentity {
  String get name;
​
  @override
  int get hashCode => name.hashCode;
​
  @override
  bool operator ==(other) => other is NameIdentity && name == other.name;
}
​
class Person with NameIdentity {
  final String name;
​
  Person(this.name);
}

De manera similar a declarar el mixin como abstracto, colocar una cláusula implements en el mixin sin implementar realmente la interfaz también asegurará que se definan las dependencias de miembros para el mixin.

abstract interface class Tuner {
  void tuneInstrument();
}
​
mixin Guitarist implements Tuner {
  void playSong() {
    tuneInstrument();
​
    print('Strums guitar majestically.');
  }
}
​
class PunkRocker with Guitarist {
​
  @override
  void tuneInstrument() {
    print("Don't bother, being out of tune is punk rock.");
  }
}

La cláusula on existe para definir el tipo con respecto al cual se resuelven las llamadas a super. Por lo tanto, solo debes usarla si necesitas tener una llamada a super dentro de un mixin.

La cláusula on obliga a cualquier clase que use un mixin a ser también una subclase del tipo en la cláusula on. Si el mixin depende de miembros en la superclase, esto asegura que esos miembros estén disponibles donde se usa el mixin:

class Musician {
  musicianMethod() {
    print('Playing music!');
  }
}
​
mixin MusicalPerformer on Musician {
  performerMethod() {
    print('Performing music!');
    super.musicianMethod();
  }
}
​
class SingerDancer extends Musician with MusicalPerformer { }
​
main() {
  SingerDancer().performerMethod();
}

En este ejemplo, solo las clases que extienden o implementan la clase Musician pueden usar el mixin MusicalPerformer. Debido a que SingerDancer extiende Musician, SingerDancer puede incorporar (mix in) MusicalPerformer.

Una declaración mixin define un mixin. Una declaración class define una clase. Una declaración mixin class define una clase que se puede usar tanto como una clase regular como un mixin, con el mismo nombre y el mismo tipo.

mixin class Musician {
  // ...
}
​
class Novice with Musician { // Use Musician as a mixin
  // ...
}
​
class Novice extends Musician { // Use Musician as a class
  // ...
}

Cualquier restricción que se aplique a clases o mixins también se aplica a clases mixin (mixin classes):

• Los mixins no pueden tener cláusulas extends ni with, por lo que tampoco puede tenerlas una mixin class.
• Las clases no pueden tener una cláusula on, por lo que tampoco puede tenerla una mixin class.