Dart中的面向对象

声明一个类

• 使用class关键字, 声明一个类

class Person{
}

类的属性和方法

1.属性会自动生成getter和setter方法, 属性用点运算符访问
2.使用final声明的属性只有getter方法
3.方法不能重载

class Man{
  //属性
  String name;
  int age;
  final String sex = "男";
  //方法
  void say(){
    print("我的名字是"+name+", 年龄是"+age.toString()+", 性别是"+sex);
  }
}

4.计算属性: 计算而来，本身是不存储值的

class Rectangle{
  num width, height;
  //计算属性
  num get area => width * height;
  set area(value){
    width = 10;
    height = value / width;
  }
}

main(){
  var r = new Rectangle();
  r.area = 65;
  print(r.width.toString() + "  "+ r.height.toString()); //10  6.5
}

5.静态成员, 使用static关键字来实现类级别的变量和函数, 静态成员不能访问非静态成员, 非静态成员可以访问静态成员

class Person{
  static const int age = 11;
  static int num = 1;
  static void addNum(){
    num ++;
  }
}

main(){
  print(Person.num); //1
  Person.addNum();
  print(Person.num); //2
  print(Person.age); //11
}

类及成员的可见性

1.在Dart中, 可见性是以library(库)为单位, 默认情况下, 一个Dart文件就是一个库
2.使用_表示私有
3.使用import导入库

构造方法

1.没有自定义构造方法, 系统会为我们自动生成一个默认构造方法
2.有自定义构造方法, 默认构造方法失效
3.构造方法不能重载

• 自定义构造函数

class Person{
  
  //属性
  String name;
  int age;

  //自定义构造函数
  Person(String name, int age){
    this.name = name;
    this.age = age;
  }

  //自定义构造函数的简写形式, 效果跟上面一致
  // Person(this.name, this.age);
}

main(){
  var person = new Person("张三", 11);
}

• 命名构造函数
  构造函数不能重载, 可以使用命名构造函数实现多个构造方法

class Person{  
  //属性
  String name;
  int age;

  //构造方法
  Person(this.name, this.age);
  //命名构造方法
  Person.withName(this.name);
  Person.withNameAndAge(this.name, this.age);
}

main(){
  var person1 = new Person("zhangsan", 11);
  //命名构造函数
  var person2 = new Person.withName("list");
  var person3 = new Person.withNameAndAge("wangwu", 12);
}

• 常量构造函数
  1.如果类是不可变状态, 可以把对象定义为编译时常量
  2.使用const声明构造方法, 并且所有变量都是final
  3.使用const声明对象, 也可以省略const

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

main(){
  //const person = const Person("lisi", 11);
  const person = Person('lisi', 11); //等价于上一行, const可以省略
}

继承

1.使用extends关键字
2.子类继承父类可见的属性和方法, 不会继承构造方法
3.子类可以重写父类的方法
4.单继承
5.子类的构造方法默认会调用父类的无名无参构造方法, 如果父类没有无名无参构造方法，则需要显示调用父类构造方法

class Animal{
  //属性
  String name;
  int age;

  //方法
  void run(){
    print("run...");
  }
}

//Person继承了Animal
class Person extends Animal{
  String address;
  void study(){
    print('study ....');
  }
}

//Person继承了Animal, 所有Person有了Animal的方法和属性
main(){
  var person = new Person();
  person.name = 'zhangsan';
  person.age = 11;
  person.address = '郑州';
  person.run(); //run..
  person.study(); //study...
}

抽象类

1. 抽象类使用abstract表示，不能直接被实例化
2. 抽象方法用abstract表示，无实现
3. 抽象类可以没有抽象方法
4. 有抽象方法的类一定是抽象类

//抽象类
abstract class Person{
  void run();
}
class Student extends Person{
  @override
  void run() {
    // TODO: implement run
    print("run ............");
  }
}

接口

1. 类和接口是统一的，类就是接口
2. 每个类都隐式的定义了一个包含所有实例成员的接口
3. 如果复用已有类的实现，使用继承extends
4. 如果只是使用已有类的外在行为，使用接口implements