1.类是隐式接口

直接上代码:

//main函数;
main(List<String> args) {
  SuperMan sm = SuperMan();
  sm.eating();
}

//定义类型1 runner ,同时它也是一个隐式接口
class Runner {
  Function running() {}
}

//定义类型2 Flyer ,同时它也是一个隐式接口
class Flyer {
  Function flying() {}
}

//定义类型3
class Animal {
  Function eating() {
    print('this animal is eating');
  }
}

/*
1.Dart语法没有关键字是用来定义接口的
2.没有这些关键字:interface / protocol
3.默认情况下所有的类都是隐式接口
4.Dart只支持单继承
5.当将一个类当做接口使用的时候,那么使用这个接口的类,需要Overide这个接口的所有方法
*/

//定义类型4 SuperMan 它集成了 Animal
//同时使用了类型1.类型2,隐式接口;
class SuperMan extends Animal implements Runner, Flyer {
  @override
  Function flying() {
    // TODO: implement flying
    throw UnimplementedError();
  }

  @override
  Function running() {
    // TODO: implement running
    throw UnimplementedError();
  }

  @override
  Function eating() {
    // TODO: implement eating
    var result = this.runtimeType;
    print('我现在的类型是:  ${result} 这个类型的');

    String str1 = '${result}';
    print('str1 是一个String类型 => $str1');

    print('调用一下父类的eating方法:');
    return super.eating();

     /*
      问题: 如果继承的类和使用的隐式接口中有同一个方法
      那么类里面那个同名的方法需要被override一下吗?
    */

    /*
      答案: 不用
      原因: 因为继承的父类里面,已经对同名方法进行了实现,子类可以等于已经拥有了方法的实现
   */
    
  }
}

2.混入式使用(mixin)

2.1代码格式

如果我们想定义一个混入式的接口,那么需要使用到关键字:mixin,语法如下:

//这里我们使用了mixin 这个关键字来修饰 Runner;
mixin Runner {
  running() {
    print('runner is runing');
  }
}

//定义一个Student类,使用了Runner混入
class Student with Runner {
  //在这里我们可以不用重写Runner内声明过的方法
}

//然后我们就可以直接使用Student的实例来调用running();方法了
main(List<String> args) {
  Student s = Student();
  s.running();
}

2.2 父类与混入的接口中实现了同一个方法

main(List<String> args) {
  Student s = Student();
  s.running();
}

mixin Runner {
  running() {
    print('runner is runing');
  }
}

class Person {
  running() {
    print('person is running');
  }
}

class Student extends Person with Runner {}

在上面这个Demo中,Person 和 Runner都实现了running();方法.
Student类继承了Person类,又使用了Runner接口.那么Student的实例,调用running();的时候,会执行哪一个方法的实现呢?
答案是:Student的实例会调用Runner的方法实现;
如果Student内部又重写了running();方法,则会直接使用重写后的方法实现;