1 类
1.1 构造
//java中写法
class P {
double x;
double y;
P(int x, int y) {
this.x = x;
this.y = y;
}
}
//dart建议写法
class P {
num x;
num y;
Point(this.x, this.y);
}1.2 重定向构造
class P {
num x;
num y;
Point(this.x, this.y);
//重定向构造函数，使用冒号调用其他构造函数
P.alongXAxis(num x) : this(x, 0);
}1.3 命名构造函数
class Rect{
int _height;//定义成私有成员(前面加下划线),私有成员不能被外部直接访问
int _width;
Rect(this._height,this._width);//Dart默认构造函数 只能声明一次,Java可以声明多个
Rect.heigthSet(this._height);//命名构造函数 可以声明多个
Rect.widthSet(this._width);//命名构造函数 可以声明多个
Rect.allSet(this._width,this._height);//命名构造函数 可以声明多个
Rect.allSet2():_height=5,_width=5;//带默认参数的构造方法
//set get属性方法,外部通过访问属性的形式调用该方法
set setHeight(int value){
this._height=value;
}
//getter属性方法,不用括号，外部通过访问属性的形式调用该方法
get getHeight{
return _height;
}
//getter属性方法,不用括号，外部通过访问属性的形式调用该方法
get Area{
return _height*_width;
}
//定义私有方法
int _area(){
return _height*_width;
}
int getArea(){
return _area();
}
String getMessage(){
return('获取传入的高，宽值：$_height $_width 面积计算为：');
}
}1.4 类的Get和Set方法
class Rectangle {
num left;
num top;
num width;
num height;
Rectangle(this.left, this.top, this.width, this.height);
num get right => left + width;
set right(num value) => left = value - width;
num get bottom => top + height;
set bottom(num value) => top = value - height;
}2 抽象 和 继承
实例
// 定义父类
abstract class Person{
String name;
int age;
Person(this.name, this.age);
Person.second(this.name, this.age);
void show() {
print('$name $age');
}
//抽象方法定义规则，要求子类必须继承
void marry();
}
// 子类继承，必须实现抽象方法
class Boy extends Person{
double height;
Boy(String name, int age,double height):super(name,age){
this.height=height;
}
//方法重写
@override
void show(){
// super.show();
print('$name $age $height');
}
void playBoy(){
print('男生喜欢打王者荣耀');
}
@override
void marry() {
print('我是一个男生，要找一个女朋友结婚');
}
}3 封装 和 多态
3.1 说明
1、Dart中的多态体现在方法重写，向上转型
2、比如上面Boy子类中的方法重写，我们也可以再定义一个Girl子类重写；
3、向上转型，向下转型这里做一个简单的介绍，具体代码可在我的资源中下载去看
4、向上转型可以提取公共方法，向下转型可以转化到子类，调用子类方法，向上转型也是一种封装
3.2 实例
A is B 判断A是否是B类型
A as B 把A类型转换为B类型
if(p is Boy){
Boy boy=p as Boy;
boy.playBoy();
}4 接口
dart中类就是接口，和声明抽象类一样，一般是用abstract修饰
代码
abstract class Person {
void run();
}
class Student implements Person {
@override
void run() {
print("run 执行了。。。")
}
}5 Mixins
5.1 说明
实际上就是多继承
通过mixins实现类似多继承，但是mixins不属于继承，也不属于接口，就是一种新的特性
作为mixins的类只能继承于最终父类Object，不可以继承别的类
mixins类不能有构造函数
一个类可以继承于多个mixins
Mixins是Dart里面的一个全新概念，简单来说，用来复用多个类之间的代码，减少耦合，换句话来说，可以从中扩展方法（或变量）而不扩展类
5.2 示例
5.2.1 场景
工程师 = 软件工程师 + 建筑工程师
教师 = 美术教师 + IT教师
工作者 = 教师 + 工程师
5.2.2 图例
5.2.3 java实现
//工作者
abstract class Worker {
public abstract void doWork();//工作者需要工作
}
//工程师
class Engineer extends Worker {
@Override
public void doWork() {
System.out.println("工程师在工作");
}
}
//教师
class Teacher extends Worker {
@Override
public void doWork() {
System.out.println("教师在教学");
}
}
//软件工程师
class SoftwareEngineer extends Engineer {}
//建筑工程师
class BuildingEngineer extends Engineer {}
//美术教师
class ArtTeacher extends Teacher {}
//IT教师
class ITTeacher extends Teacher {}
5.3.4 Dart实现
//工作者
abstract class Worker {
void doWork();//工作者需要工作
}
//工程师
class Engineer extends Worker {
void doWork() {
print('工程师在工作');
}
}
//教师
class Teacher extends Worker {
void doWork() {
print('教师在教学');
}
}
//软件工程师
class SoftwareEngineer extends Engineer {}
//建筑工程师
class BuildingEngineer extends Engineer {}
//美术教师
class ArtTeacher extends Teacher {}
//IT教师
class ITTeacher extends Teacher {}5.4 扩展功能
5.4.1 图例
5.5 如果使用Java，那么我们自然就想到了使用interface。
5.5.1 代码示例
interface CanFixComputer {
void fixComputer();
}
interface CanDesignSoftware {
void designSoftware();
}
//软件工程师
class SoftwareEngineer extends Engineer implements CanFixComputer, CanDesignSoftware {
@Override
public void fixComputer() {
System.out.println("修电脑");
}
@Override
public void designSoftware() {
System.out.println("设计软件");
}
}
//IT教师
class ITTeacher extends Teacher implements CanFixComputer {
@Override
public void fixComputer() {
System.out.println("修电脑");
}
}5.5.2 说明
但是，我们知道Dart当中没有interface的概念，但并不意味着这门语言没有接口，事实上，Dart任何一个类都是接口，你可以实现任何一个类，只需要重写那个类里面的所有具体方法。
如果要用Dart来实现的话，只需要将interface修改成abstract class。
但是我们发现，fixComputer这个接口被继承了两次，并且两次的实现都是一样的，这里就出现了代码重复和冗余的问题。怎么办呢？在java中我们有接口的default实现来解决这个问题(这是一个java8出现的不得已的方案。)
但是，有了mixins之后，这件事就变得不那么难了。
5.6 Dart的处理
abstract class CanFixComputer {
void fixComputer() {
print('修电脑');
}
}
abstract class CanDesignSoftware {
void designSoftware() {
print('设计软件');
}
}
//软件工程师
class SoftwareEngineer extends Engineer
with CanFixComputer, CanDesignSoftware {}
//IT教师
class ITTeacher extends Teacher with CanFixComputer {}
main() {
ITTeacher itTeacher = new ITTeacher();
itTeacher.doWork();
itTeacher.fixComputer();
SoftwareEngineer softwareEngineer = new SoftwareEngineer();
softwareEngineer.doWork();
softwareEngineer.fixComputer();
softwareEngineer.designSoftware();
}通过以上代码，我们可以看到这里不用implements，更不是extends，而是with。
每个具有某项特性的类不再需要具体去实现同样的功能，接口是没法实现功能的，而通过继承的方式虽然能实现功能，但已经有父类，同时不是一个父类，又不能多继承，所以这个时候，Dart的Mixin机制就比Java的接口会高效，开发上层的只需要关心当前需要什么特性，而开发功能模块的关心具体要实现什么功能。
5.7 无论是extends、implements还是mixin，优先级最高的是在具体类中的方法。
class First {
void doPrint() {
print('First');
}
}
class Second {
void doPrint() {
print('Second');
}
}
class Father {
void doPrint() {
print('Father');
}
}
class Son1 extends Father with First,Second { }
class Son2 extends Father with First implements Second {
main() {
Son1 son1 = new Son1();
son1.doPrint(); // Second
Son2 son2 = new Son2();
son2.doPrint(); // First
}
}其实在Son2中implements只是说要实现他的doPrint()方法，这个时候其实具体实现是First中Mixin的具体实现。
而Mixin的具体顺序也是可以从代码倒过来看的，最后mixin的优先级是最高的。
优先级 with>extends>implements
6 泛型
6.1 说明
在Dart当中，有很多容器对象，在创建对象时都可以定义泛型类型，这一点和Java是一样。
Java中的泛型信息是编译时的，泛型信息在运行时是不存在的。
Dart的泛型类型是固化的，在运行时也有可以判断的具体类型。
6.2 示例
var list = List<String>();
list.add('aaa');
list.add('bbb');
list.add('ccc');
print(list);
var map = Map<int, String>();
map[1] = 'aaaa';
map[2] = 'bbbb';
map[3] = 'cccc';
print(map);
