Does Dart support multiple inheritance?

Question

What are the mechanisms for multiple inheritance supported by Dart?

Answer 1

No, Dart does not support multiple implementation inheritance.

Dart has interfaces, and like most other similar languages it has multiple interface inheritance.

For implementation, there is only a single super-class chain that a class can inherit member implementations from.

Dart does have mixins, which allows implementation to be used by multiple classes, but not through inheritance as much as by mixin application.

Example:

class A {
  String get foo;
}
class A1 implements A {
  String get foo => "A1";
}
class A2 implements A {
  String get foo => "A2";
}
mixin B on A {
  String get foo => "B:${super.foo}";
}
class C extends A1 with B {
  String get foo => "C:${super.foo}";
}
class D extends A2 with B {
  String get foo => "D:${super.foo}";
}
void main() {
  print(C().foo); // C:B:A1
  print(D().foo); // D:B:A2
}

Here the same member, B.foo, is mixed into two different classes, with two different super-classes.

Each of the classes C and D has only a single superclass chain. The superclass of C is the anonymous mixin application class A1 with B, the superclass of D is the distinct mixin application class A2 with B. Both of these classes contain the mixin member B.foo.

Mixins are not multiple inheritance, but it's the closest you'll get in Dart.

Answer 2

Actually, it's quite easy. The only thing that needs to be understood is that Interfaces are not defined explicitly. Instead, Dart automatically creates Interfaces for all classes. That means you can implement a class like you would implement an interface. For pure Interfaces, there's abstract classes.

Here is how that works:

abstract class TestInterfaceA{
  String getStringA();
}

abstract class TestInterfaceB{
  String getStringB();
}

class TestInterfaceImplementer implements TestInterfaceA, TestInterfaceB{
  @override
  String getStringA() {
    return "A";
  }

  @override
  String getStringB() {
    return "B";
  }
}

main(){
  test("TestInterfaceImplementer should be able to call method from TestInterface A", () {
    TestInterfaceA testInterfaceA = TestInterfaceImplementer();

    expect(testInterfaceA.getStringA(), "A");
  });
  test("TestInterfaceImplementer should be able to call method from TestInterface B", () {
    TestInterfaceB testInterfaceB = TestInterfaceImplementer();

    expect(testInterfaceB.getStringB(), "B");
  });
}