Extender una clase

Usa extends para crear una subclase, y super para hacer referencia a la superclase:

class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
  // ···
}
​
class SmartTelevision extends Television {
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
  // ···
}

Para otro uso de extends, consulta la discusión sobre tipos parametrizados en la página de Genéricos.

Las subclases pueden sobrescribir métodos de instancia (incluyendo operadores), getters y setters. Puedes usar la anotación @override para indicar que estás sobrescribiendo intencionalmente un miembro:

class Television {
  // ···
  set contrast(int value) {
    // ···
  }
}
​
class SmartTelevision extends Television {
  @override
  set contrast(num value) {
    // ···
  }
  // ···
}

La declaración de un método sobrescrito debe coincidir con el método (o métodos) que sobrescribe de varias maneras:

• El tipo de retorno debe ser del mismo tipo (o un subtipo) que el tipo de retorno del método sobrescrito.
• Los tipos de parámetros deben ser del mismo tipo (o un supertipo) que los tipos de parámetros del método sobrescrito. En el ejemplo anterior, el setter de contrast de SmartTelevision cambia el tipo de parámetro de int a un supertipo, num.
• Si el método sobrescrito acepta n parámetros posicionales, entonces el método que sobrescribe también debe aceptar n parámetros posicionales.
• Un método genérico no puede sobrescribir a uno no genérico, y un método no genérico no puede sobrescribir a uno genérico.

A veces es posible que quieras estrechar el tipo de un parámetro de método o una variable de instancia. Esto infringe las reglas normales y es similar a una conversión descendente (downcast) en el sentido de que puede provocar un error de tipo en tiempo de ejecución. Aun así, estrechar el tipo es posible si el código puede garantizar que no ocurrirá un error de tipo. En este caso, puedes usar la palabra clave covariant en una declaración de parámetro. Para más detalles, consulta la especificación del lenguaje Dart.

Para detectar o reaccionar cada vez que el código intente usar un método o variable de instancia no existente, puedes sobrescribir noSuchMethod():

class A {
  // Unless you override noSuchMethod, using a
  // non-existent member results in a NoSuchMethodError.
  @override
  void noSuchMethod(Invocation invocation) {
    print(
      'You tried to use a non-existent member: '
      '${invocation.memberName}',
    );
  }
}

No puedes invocar un método no implementado a menos que una de las siguientes situaciones sea cierta:

• El receptor tiene el tipo estático dynamic.

• El receptor tiene un tipo estático que define el método no implementado (abstract está bien), y el tipo dinámico del receptor tiene una implementación de noSuchMethod() que es diferente de la de la clase Object.

Para obtener más información, consulta la especificación informal de reenvío de noSuchMethod.