Dart: Tudo é interface?

• Eu vejo interfaces...
• Com que frequencia?
• O tempo todo!

Em Dart todas as classes definem interfaces implicitamente, ou seja, sempre que você tiver uma classe pode criar uma outra classe implementando ela.
Ao fazer isso você precisa implementar todos os métodos que ela tem respeitando o contrato.

class A {
  int numero() => 1;
  String texto() => 'A';
}

class B implements A {
  @override
  int numero() => 2;
  @override
  String texto() => 'B';
}

void main() {
  print(A().numero()); // 1
  print(A().texto());  // A
  print(B().numero()); // 2
  print(B().texto());  // B
}

O mais comum de se ver é a criação de uma abstract class quando vai se usar para implementar em outra, assim você não declara o corpo dos métodos.

E a interface?

Na versão 3.0 do Dart foram adicionados diversos modificadores, e um deles foi interface.

Então eu posso criar uma interface direto?

Não. Eu sei, é meio confuso. Mas vamos lá...
Os modificadores adicionados foram para resolver alguns problemas para quem desenvolve bibliotecas.

Quando você tem uma biblioteca e seu usuário precisa passar uma classe que você definiu, ele pode estender uma classe sua ou implementar já que classes são interfaces.

Mas e se eu não quiser que a pessoa possa estender? Eu quero realmente só que a pessoa use o contrato que eu criei. O modificador interface é usado para isso, deixar explícito que é apenas para ser implementada.

Dentro da sua biblioteca, ainda é possível estender:

interface class A {
  int numero() => 1;
  String texto() => 'A';
}

class B extends A {
  @override
  int numero() => 2;
  @override
  String texto() => 'B';
}

Porém fora dela não é permitido, dando o seguinte erro:

import './lib_a.dart';

 //The class 'A' can't be extended outside 
// of its library because it's an interface class. 
// dart(invalid_use_of_type_outside_library)
class C extends A {
  @override
  int numero() => 2;
  @override
  String texto() => 'C';
}

class D implements A {
  @override
  int numero() => 2;
  @override
  String texto() => 'D';
}

Criando uma interface pura

É possível combinar mais de um modificador, com isso podemos criar uma abstract interface class.
Com isso, a classe terá métodos abstratos (sem corpo) e só poderá ser implementada, virando uma interface pura.

abstract interface class A {
  int numero();
  String texto();
}

class B implements A {
  @override
  int numero() => 2;
  @override
  String texto() => 'B';
}

Conhecia esses novos modificadores para classe? Já aproveitou o fato de Dart ter interfaces implícitas? Conta aí nos comentários.