Mixin vs Interface

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy — lição 55 de 110.

Você viu como os mixins se comparam à herança. Agora vamos comparar mixins com interfaces, já que ambos permitem que você trabalhe com múltiplos tipos. A principal diferença é o que eles fornecem: interfaces definem um contrato, enquanto mixins fornecem implementação.

Quando você implementa uma interface, você promete fornecer certos métodos, mas você escreve todo o código por conta própria. Quando você usa um mixin, você recebe o código real gratuitamente.

// Abordagem de interface - você deve implementar tudo
abstract class Printable {
  void printInfo();
}

class Report implements Printable {
  @override
  void printInfo() {
    print('Printing report...');  // Você escreve isso
  }
}

// Abordagem de mixin - implementação incluída
mixin Printable {
  void printInfo() {
    print('Printing...');  // Já escrito para você
  }
}

class Report with Printable {}  // Recebe printInfo() automaticamente

Então, quando você deve usar cada um? Use uma interface quando classes diferentes precisarem das mesmas assinaturas de método, mas implementações diferentes. Use um mixin quando as classes devem compartilhar exatamente o mesmo comportamento.

Recurso	Interface	Mixin
Fornece	Apenas contrato	Contrato + código
Implementação	Você a escreve	Incluída
Palavra-chave	implements	with
Melhor para	Comportamentos diferentes, mesma API	Comportamento compartilhado

Você pode até combinar ambas as abordagens - use interfaces para definir o que uma classe pode fazer e mixins para fornecer implementações comuns onde for apropriado. No Dart, ao combinar ambos, sempre coloque with antes de implements:

class MyClass with SomeMixin implements SomeInterface {
  // with vem antes de implements
}

Desafio

Fácil

Vamos construir um sistema de notificação que demonstra quando usar interfaces versus mixins. Você criará uma interface para notificações que exigem implementações diferentes e um mixin para comportamento de log compartilhado que deve ser idêntico em todos os tipos de notificação.

Você organizará seu código em três arquivos:

notifiable.dart: Defina uma classe abstrata Notifiable que atua como uma interface. Ela deve declarar dois métodos abstratos: send(String message) e getChannel() que retorna uma String. Diferentes tipos de notificação implementarão esses métodos de forma diferente com base em seu canal específico.
logging.dart: Crie um mixin Logging que fornece comportamento compartilhado que todas as notificações devem ter. Inclua um método logSent(String channel, String message) que imprime [LOG] Sent via [channel]: [message] e um método logTimestamp() que imprime [LOG] Timestamp recorded. Este comportamento é idêntico para todos os tipos de notificação, tornando-o perfeito para um mixin.
main.dart: Importe ambos os arquivos e crie duas classes de notificação que combinam a interface com o mixin:
- Uma classe EmailNotification que usa o mixin Logging e implementa Notifiable. Seu getChannel() deve retornar 'Email', e seu método send() deve imprimir Sending email: [message], depois chamar logSent() com o canal e a mensagem, e então chamar logTimestamp()
- Uma classe SMSNotification que usa o mixin Logging e implementa Notifiable. Seu getChannel() deve retornar 'SMS', e seu método send() deve imprimir Sending SMS: [message], depois chamar logSent() com o canal e a mensagem, e então chamar logTimestamp()
Em seguida, crie um EmailNotification e chame send('Hello World'), imprima uma linha vazia, crie um SMSNotification e chame send('Quick update')

Observe como a interface força cada classe a escrever suas próprias implementações de send() e getChannel() (comportamento diferente), enquanto o mixin fornece os métodos de log que funcionam de forma idêntica para ambos (comportamento compartilhado).

Exemplo de saída:

Sending email: Hello World
[LOG] Sent via Email: Hello World
[LOG] Timestamp recorded

Sending SMS: Quick update
[LOG] Sent via SMS: Quick update
[LOG] Timestamp recorded

Folha de consulta

Interfaces definem um contrato (assinaturas de método), enquanto mixins fornecem a implementação (código real).

Quando você implementa uma interface, você deve escrever todo o código por conta própria:

abstract class Printable {
  void printInfo();
}

class Report implements Printable {
  @override
  void printInfo() {
    print('Printing report...');  // Você escreve isso
  }
}

Quando você usa um mixin, você recebe a implementação gratuitamente:

mixin Printable {
  void printInfo() {
    print('Printing...');  // Já escrito para você
  }
}

class Report with Printable {}  // Recebe printInfo() automaticamente

Quando usar cada um:

Use uma interface quando classes diferentes precisam das mesmas assinaturas de método, mas implementações diferentes
Use um mixin quando as classes devem compartilhar exatamente o mesmo comportamento

Recurso	Interface	Mixin
Fornece	Apenas contrato	Contrato + código
Implementação	Você escreve	Incluída
Palavra-chave	implements	with
Melhor para	Comportamentos diferentes, mesma API	Comportamento compartilhado

Você pode combinar ambas as abordagens. Ao combinar, sempre coloque with antes de implements:

class MyClass with SomeMixin implements SomeInterface {
  // with vem antes de implements
}

Experimente você mesmo

import 'notifiable.dart';
import 'logging.dart';

// TODO: Criar a classe EmailNotification que:
//       - usa o mixin Logging (with)
//       - implementa Notifiable (implements)
//       - getChannel() retorna 'Email'
//       - send() imprime 'Sending email: [message]', depois chama logSent(), depois logTimestamp()

// TODO: Criar a classe SMSNotification que:
//       - usa o mixin Logging (with)
//       - implementa Notifiable (implements)
//       - getChannel() retorna 'SMS'
//       - send() imprime 'Sending SMS: [message]', depois chama logSent(), depois logTimestamp()

void main() {
  // TODO: Criar uma EmailNotification e chamar send('Hello World')
  
  // TODO: Imprimir uma linha vazia
  
  // TODO: Criar uma SMSNotification e chamar send('Quick update')
}