如果父类没有无参构造方法，只有有参构造或命名构造放方法，则子类需要显示调用父类的有参构造方法或者命名构造方法，还可以结合初始化列表进行使用。
class Person {
String name;
//如果父类没有无参构造方法，只有有参构造或命名构造放方法，则子类需要显示调用父类的有参构造方法或者命名构造方法
Person(this.name);
Person.withName(this.name);
}
class Student extends Person {
final String gender;
//有参构造方法，调用父类的有参构造方法
Student(String name, String gender)
: gender = gender,
super(name);
//子类中的命名构造方法也是一样
Student.withName(this.name, this.gender)
super.withName(name);
//如果gender在初始化列表中初始化也是可以的
Student.withName(String name) : super.withName(name);
Student.withName(String name, String g)
//初始化列表
: gender = g,
super.withName(name);
}
抽象类
抽象abstract是面向对象中的一个非常重要的概念，通常用于描述父类拥有一种行为但无法给出细节实现，而需要通过子类来实现抽象的细节。这种情况下父类被定义为抽象类，子类继承父类后实现其中的抽象方法。
同Java语言类似，Dart中的抽象类也使用abstract来实现，不过抽象函数无需使用abstract，直接给出定义不给出方法体实现即可
抽象类中可以有数据，可以有常规函数，可以有抽象函数，但抽象类不能实例化。子类继承抽象类后必须实现其中的抽象函数。
演示示例：Dog类继承Animal抽象类
main(){
var d = new Dog();
d.name = “dog”;
d.eat();
d.display();
}
abstract class Animal{
String name; //数据
void display(){ //普通函数
print(“名字是:${name}”);
}
void eat(); //抽象函数
}
class Dog extends Animal{
@override
void eat() { //实现抽象函数
print(“eat”);
}
}
运行结果
接口
和Java一样，dart也有接口，但是和Java还是有区别的。
首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现。
同样使用implements关键字进行实现。
但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍。而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类。
class Person {
String name;
//计算属性
int get age => 18;
void run() {
print(‘Person run…’);
}
}
//dart的接口，类也可以作为接口，使用implements关键字进行实现，需要将所有属性和方法都实现…
class Student implements Person {
@override
String name;
@override
int get age => null;
@override
void run() {
}
}
一般会使用抽象类进行实现。
//dart的接口有点奇怪，所以一般会将抽象类作为接口来使用
abstract class Person {
void run();
}
class Student implements Person {
@override
void run() {
print(‘student…run…’);
}
}
var student = new Student();
student.run();
基于Mixins的多继承
除了上面和其他语言类似的单继承外，在Dart中还提供了另一继承的机制就是基于Mixins的多继承，但是它不是真正意义上类的多继承，它始终还是只能有一个超类(基类)。
1、为什么需要Mixins?
为什么需要Mixins多继承？它实际上为了解决单继承所带来的问题，我们很多语言中都是采用了单继承+接口多实现的方式。但是这种方式并不能很好适用于所有场景。
假设一下下面场景，我们把车进行分类，然后下面的颜色条表示各种车辆具有的能力。
我们通过上图就可以看到，这些车辆都有一个共同的父类 Vehicle,然后它又由两个抽象的子类: MotorVehicle 和 NonMotorVehicle 。有些类是具有相同的行为和能力，但是有的类又有自己独有的行为和能力。比如公交车 Bus 和摩托车 Motor 都能使用汽油驱动，但是摩托车 Motor 还能载货公交车 Bus 却不可以。
如果仅仅是单继承模型下，无法把部分子类具有相同行为和能力抽象放到基类，因为对于不具有该行为和能力的子类来说是不妥的，所以只能在各自子类另外实现。那么就问题来了，部分具有相同能力和行为的子类中都要保留一份相同的代码实现。这就是产生冗余，突然觉得单继承模型有点鸡肋，食之无味弃之可惜。
//单继承模型的普通实现
abstract class Vehicle {}
abstract class MotorVehicle extends Vehicle {}
abstract class NonMotorVehicle extends Vehicle {}
class Motor extends MotorVehicle {
void petrolDriven() => print(“汽油驱动”);
void passengerService() => print(‘载人’);
void carryCargo() => print(‘载货’);
}
class Bus extends MotorVehicle {
void petrolDriven() => print(“汽油驱动”);
void electricalDriven() => print(“电能驱动”);
void passengerService() => print(‘载人’);
}
class Truck extends MotorVehicle {
void petrolDriven() => print(“汽油驱动”);
void carryCargo() => print(‘载货’);
}
class Bicycle extends NonMotorVehicle {
void electricalDriven() => print(“电能驱动”);
void passengerService() => print(‘载人’);
}
class Bike extends NonMotorVehicle {
void passengerService() => print(‘载人’);
}
可以从上述实现代码来看发现，有很多相同冗余代码实现，请注意这里所说的相同代码是连具体实现都相同的。很多人估计想到一个办法那就是将各个能力提升成接口，然后各自的选择去实现相应能力。但是我们知道即使抽成了接口，各个实现类中还是需要写对应的实现代码，冗余还是无法摆脱。不妨我们来试试用接口:
//单继承+接口多实现
abstract class Vehicle {}
abstract class MotorVehicle extends Vehicle {}
abstract class NonMotorVehicle extends Vehicle {}
//将各自的能力抽成独立的接口，这样的好处就是可以从抽象角度对不同的实现类赋予不同接口能力，
// 职责更加清晰,但是这个只是一方面的问题，它还是无法解决相同能力实现代码冗余的问题
abstract class PetrolDriven {
void petrolDriven();
}
abstract class PassengerService {
void passengerService();
}
abstract class CargoService {
void carryCargo();
}
abstract class ElectricalDriven {
void electricalDriven();
}
//对于Motor赋予了PetrolDriven、PassengerService、CargoService能力
class Motor extends MotorVehicle implements PetrolDriven, PassengerService, CargoService {
@override
void carryCargo() => print(‘载货’);//仍然需要重写carryCargo
@override
void passengerService() => print(‘载人’);//仍然需要重写passengerService
@override
void petrolDriven() => print(“汽油驱动”);//仍然需要重写petrolDriven
}
//对于Bus赋予了PetrolDriven、ElectricalDriven、PassengerService能力
class Bus extends MotorVehicle implements PetrolDriven, ElectricalDriven, PassengerService {
@override
void electricalDriven() => print(“电能驱动”);//仍然需要重写electricalDriven
@override
void passengerService() => print(‘载人’);//仍然需要重写passengerService
@override
void petrolDriven() => print(“汽油驱动”);//仍然需要重写petrolDriven
}
//对于Truck赋予了PetrolDriven、CargoService能力
class Truck extends MotorVehicle implements PetrolDriven, CargoService {
@override
void carryCargo() => print(‘载货’);//仍然需要重写carryCargo
@override
void petrolDriven() => print(“汽油驱动”);//仍然需要重写petrolDriven
}
//对于Bicycle赋予了ElectricalDriven、PassengerService能力
class Bicycle extends NonMotorVehicle implements ElectricalDriven, PassengerService {
@override
void electricalDriven() => print(“电能驱动”);//仍然需要重写electricalDriven
@override
void passengerService() => print(‘载人’);//仍然需要重写passengerService
}
//对于Bike赋予了PassengerService能力
class Bike extends NonMotorVehicle implements PassengerService {
@override
void passengerService() => print(‘载人’);//仍然需要重写passengerService
}
针对相同实现代码冗余的问题，使用Mixins就能很好的解决。它能复用类中某个行为的具体实现，而不是像接口仅仅从抽象角度规定了实现类具有哪些能力，至于具体实现接口方法都必须重写，也就意味着即使是相同的实现还得重新写一遍。一起看下Mixins改写后代码:
//mixins多继承模型实现
abstract class Vehicle {}
abstract class MotorVehicle extends Vehicle {}
abstract class NonMotorVehicle extends Vehicle {}
//将各自的能力抽成独立的Mixin类
mixin PetrolDriven {//使用mixin关键字代替class声明一个Mixin类
void petrolDriven() => print(“汽油驱动”);
}
mixin PassengerService {//使用mixin关键字代替class声明一个Mixin类
void passengerService() => print(‘载人’);
}
mixin CargoService {//使用mixin关键字代替class声明一个Mixin类
void carryCargo() => print(‘载货’);
}
mixin ElectricalDriven {//使用mixin关键字代替class声明一个Mixin类
void electricalDriven() => print(“电能驱动”);
}
class Motor extends MotorVehicle with PetrolDriven, PassengerService, CargoService {}//利用with关键字使用mixin类
class Bus extends MotorVehicle with PetrolDriven, ElectricalDriven, PassengerService {}//利用with关键字使用mixin类
class Truck extends MotorVehicle with PetrolDriven, CargoService {}//利用with关键字使用mixin类
class Bicycle extends NonMotorVehicle with ElectricalDriven, PassengerService {}//利用with关键字使用mixin类
class Bike extends NonMotorVehicle with PassengerService {}//利用with关键字使用mixin类
可以对比发现Mixins类能真正地解决相同代码冗余的问题，并能实现很好的复用；所以使用Mixins多继承模型可以很好地解决单继承模型所带来冗余问题。
2、Mixins是什么?
用dart官网一句话来概括: Mixins是一种可以在多个类层次结构中复用类代码的方式。
基本语法
方式一: Mixins类使用关键字 mixin 声明定义
mixin PetrolDriven {//使用mixin关键字代替class声明一个Mixin类
void petrolDriven() => print(“汽油驱动”);
}
class Motor extends MotorVehicle with PetrolDriven {//使用with关键字来使用mixin类
…
}
class Petrol extends PetrolDriven{//编译异常，注意:mixin类不能被继承
…
}
main() {
var petrolDriven = PetrolDriven()//编译异常，注意:mixin类不能实例化
}
方式二: Dart中的普通类当作Mixins类使用
class PetrolDriven {
factory PetrolDriven._() => null;//主要是禁止PetrolDriven被继承以及实例化
void petrolDriven() => print(“汽油驱动”);
}
class Motor extends MotorVehicle with PetrolDriven {//普通类也可以作为Mixins类使用
…
}
3、使用Mixins多继承的场景
那么问题来了，什么时候去使用Mixins呢？
当想要在不同的类层次结构中多个类之间共享相同的行为时或者无法合适抽象出部分子类共同的行为到基类中时.
比如说上述例子中在 MotorVehicle (机动车)和 Non-MotorVehicle (非机动车)两个不同类层次结构中，其中 Bus (公交车)和 Bicycle (电动自行车)都有相同行为 ElectricalDriven 和 PassengerService. 但是很明显你无法把这个两个共同的行为抽象到基类 Vehicle 中，因为这样的话 Bike (自行车)继承 Vehicle 会自动带有一个 ElectricalDriven 行为就比较诡异。所以这种场景下mixins就是一个不错的选择，可以跨类层次之间复用相同行为的实现。
4、Mixins的线性化分析
在说Mixins线性化分析之前，一起先来看个例子
class A {
void printMsg() => print(‘A’);
}
mixin B {
void printMsg() => print(‘B’);
}
mixin C {
void printMsg() => print(‘C’);
}
class BC extends A with B, C {}
class CB extends A with C, B {}
main() {
var bc = BC();
bc.printMsg();
var cb = CB();
cb.printMsg();
}
不妨考虑下上述例子中应该输出啥呢?
输出结果:
C
B
Process finished with exit code 0
为什么会是这样的结果？实际上可以通过线性分析得到输出结果。理解Mixin线性化分析有一点很重要就是:
在Dart中Mixins多继承并不是真正意义上的多继承，实际上还是单继承；而每次Mixin都是会创建一个新的中间类。并且这个中间类总是在基类的上层。
关于上述结论可能有点难以理解，下面通过一张mixins继承结构图就能清晰明白了:
尾声
面试成功其实都是必然发生的事情，因为在此之前我做足了充分的准备工作，不单单是纯粹的刷题，更多的还会去刷一些Android核心架构进阶知识点，比如：JVM、高并发、多线程、缓存、热修复设计、插件化框架解读、组件化框架设计、图片加载框架、网络、设计模式、设计思想与代码质量优化、程序性能优化、开发效率优化、设计模式、负载均衡、算法、数据结构、高级UI晋升、Framework内核解析、Android组件内核等。
不仅有学习文档，视频+笔记提高学习效率，还能稳固你的知识，形成良好的系统的知识体系。这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家梳理了多年的架构经验，筹备近6个月最新录制的，相信这份视频能给你带来不一样的启发、收获。
Android进阶学习资料库
一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！
大厂面试真题
PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
《2017-2021字节跳动Android面试历年真题解析》
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
e知识点、常见算法题汇总。）
[外链图片转存中…(img-gdAA6RKV-1714484562259)]
《2017-2021字节跳动Android面试历年真题解析》
[外链图片转存中…(img-ITMb1eTi-1714484562259)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
633
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
