Dart入门——类

Dart是面向对象的语言，其用法和大部分面向对象语言如java很相似。此外Dart还有很多特有的语法。

变量

变量声明

类的变量声明时需要先对其进行初始化。

class Person {
  // 方式一: 设置默认值
  // int age = 0;
  // String name = "";
  
  // 方式二: 指明延后初始化，类似于kotlin的 lateinit var
  // late int age;
  // late String name;
  
  // 方式三: 设置为可空类型，与kotlin的可空类型相似
  // int? age;
  // String? name;
}

变量的getter/setter

所有实例变量均会隐式地声明一个 Getter 方法， 非final类型还会隐式地声明一个 Setter 方法。

var person = Person();
// 调用name的setter方法
person.name = 'Dart';
// 调用name的getter方法
print(person.name);

静态变量

Dart的静态变量除了用static修饰外，还需要const。

static const String country = 'China';

构造函数

默认构造

和java一样，在没有声明构造方法时，会有个默认的无参构造方法。

class Person {
  int age = 0;
  String name = "";
}

void main(){
  // 调用默认构造函数
  var person = Person();
}

有参构造

可以在构造方法中对属性进行赋值，和jave一样:

class Person {
  int age = 0;
  String name = "";
  
  Person(int age, String name) {
  	this.age = age;
  	this.name = name;
  }
}

在Dart的语法糖里上面代码可以简化:

class Person {
  int age;
  String name;
  
  Person(this.age, this.name);
}

为构造函数命名

Dart中可以为构造函数命名:

class Person {
  int age = 0;
  String name = "";

  Person(this.age, this.name);
  // 将构造函数命名为fromJson
  Person.fromJson(Map<String, dynamic> json) {
    this.age = json['age'];
    this.name = json['name'];
  }
}

void main(){
  // new可以省略
  var person = new Person.fromJson({"age":18,"name":"dart"});
  print(person.age);
  print(person.name);
}

常量构造函数

class Person {
  // 常量构造引用的字段必须为final修饰
  final int age;
  final String name;

  const Person.create(this.age, this.name);
}
void main() {
  var person1 = const Person.create(10, "Dart");
  var person2 = const Person.create(10, "Dart");
  var person3 = const Person.create(11, "Dart");
  var person4 = Person.create(10, "Dart");
  var person5 = Person.create(10, "Dart");
  // 返回true, 即person1和person2为同一个实例
  print(person1 == person2);
  // 返回false, person1和person3构造参数不同
  print(person1 == person3);
  // 返回false, person4和person5调用构造时没有使用const关键字
  print(person4 == person5);
}

总结:
  1.常量构造函数需要使用const修饰，引用的属性需要用final修饰。
  2. 当调用常量构造函数使用const修饰时，如果构造参数一致则为同一个对象。
  3. 当调用常量构造函数未使用const修饰时，则为和普通构造一样。

方法

操作符重写

Dart的方法使用和Java一致，此外Dart支持操作符重载

class Point {
  int x;
  int y;

  Point(this.x, this.y);
  // 需要operator关键字修饰
  Point operator +(Point point) => Point(point.x + x, point.y + y);
}

void main() {
  var point1 = Point(10, 10);
  var point2 = Point(10, 20);
  var point3 = point1 + point2;
  // 打印结果 x:20 y:30
  print("x:${point3.x} y:${point3.y}");
}

获取对象类型

Dart中使用 runtimeType 判断对象的实例类型

void main() {
  // 推断类型未初始化，类型为Null
  var a;
  // 推断类型，已初始化
  var b = 1;
  // 强类型
  String s = "";
  // 打印 Null
  print(a.runtimeType);
  // 打印 int
  print(b.runtimeType);
  // 打印 String
  print(s.runtimeType);
}

抽象类

Dart和Java一样可以通过abstract 来定义一个抽象类，但抽象方法不需要abstract修饰，只需要去除方法体。同样继承抽象类需要实现其抽象方法。

abstract class Drawable {
  // 没有方法体，为抽象方法
  void draw();
  // 有方法体，为普通方法
  void setPaint() {
    print("设置一个画笔");
  }
}

class Point extends Drawable{
  int x;
  int y;

  Point(this.x, this.y);

  @override
  void draw() {
    // 这里实现抽象方法
  }
}

接口

在Dart中没有interface的关键字，但每个类都可以作为一个接口被另一个类实现。

class Person {
  int age=0;
  String name="";

  Person(this.age, this.name);

  void say(){
    print("Person say");
  }
}

class Chinese implements Person{
  // Person的成员变量被继承下来
  @override
  int age=0;

  @override
  String name="";
  
  // Person的方法被继承下来
  @override
  void say() {
    print("Chinese say");
  }

}

void main(){
  // Person的构造函数没有被继承
  var chinese=Chinese();
  chinese.say();
}

Person的成员变量和方法被继承下来，而构造函数没有被继承。但成员变量和方法都需要Chinese自己初始化和实现。