Extending a class

Use extends to create a subclass, and super to refer to thesuperclass:

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

Overriding members

Subclasses can override instance methods, getters, and setters.You can use the @override annotation to indicate that you areintentionally overriding a member:

class SmartTelevision extends Television {
  @override
  void turnOn() {...}
  // ···
}

To narrow the type of a method parameter or instance variable in code that istype safe,you can use the covariant keyword.

Overridable operators

You can override the operators shown in the following table.For example, if you define aVector class, you might define a + method to add two vectors.

Note: You may have noticed that != is not an overridable operator. The expression e1 != e2 is just syntactic sugar for !(e1 == e2).

Here’s an example of a class that overrides the + and - operators:

class Vector {
  final int x, y;
  Vector(this.x, this.y);
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
  // Operator == and hashCode not shown. For details, see note below.
  // ···
}
void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);
  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

If you override ==, you should also override Object’s hashCode getter.For an example of overriding == and hashCode, seeImplementing map keys.

For more information on overriding, in general, seeExtending a class.

noSuchMethod()

To detect or react whenever code attempts to use a non-existent method orinstance variable, you can override 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}');
  }
}

You can’t invoke an unimplemented method unlessone of the following is true:

• The receiver has the static type dynamic.

• The receiver has a static type thatdefines the unimplemented method (abstract is OK),and the dynamic type of the receiver has an implemention of noSuchMethod()that’s different from the one in class Object.

For more information, see the informalnoSuchMethod forwarding specification.