Dart 学习笔记(三):类(创建,静态成员,继承,)

Dart和OC跟Swift一样是面向对象变成的语言,所以也有封装,继承和多态的概念, 在Dart里万物皆对象, 并且所有对象都继承与Object, 所有的对象都是类的实例,通常情况下类是由属性和方法组成的

通过class关键字来创建类

class Person {
  String name = '张三';
  int age = 23;

  void getInfo() {
    // print("姓名:$name ----- 年龄:$age");
    print('姓名:${this.name}----- 年龄:${this.age}');
    // this关键字指向了当前类的实例
  }
}

默认构造函数

如果想要在初始化的时候实现一些功能则需要使用构造函数

// 这是默认构造函数
Person() {
   print('这是构造函数里的内容, 在类初始化的时候触发');
}

我个人认为这个构造函数和iOS当中的初始化方法意义差不多, 也可以被重写,并且可以添加参数

Person(String name, int age) {
   this.name = name;
   this.age = age;
   print('初始化 姓名:${this.name}----- 年龄:${this.age}');
}

// 默认构造函数的简写
Person(this.name, this.age){
   print('初始化 姓名:${this.name}----- 年龄:${this.age}');
}

命名构造函数

Person.me() {
   print('我是一个命名构造函数');
}

默认构造函数有且只有一个, 但是命名构造函数可以有很多个

类当中的私有变量和私有方法

用 _ 来修饰前提是必须要把类单独抽离成一个文件, dart里面没有什么关键字是用来修饰私有变量和私有方法的

可以通过公共方法来调用私有方法和私有变量

class Animal {
  String _name = '猴子';//私有属性
  int age = 20;

  // 可以通过访问共有方法来间接获取私有属性
  String getName () {
    return this._name;
  }

  // 私有方法
  void _run() {
    print('这是一个私有方法');
  }

  // 通过公共方法调用私有方法
  execRun () {
    this._run();
  }

  Animal(this._name, this.age);

  void getInfo () {
    print('姓名:${this._name}----- 年龄:${this.age}');
  }
}

静态函数和静态属性

用static来修饰, 静态成员可以通过类名直接调用

int age = 22;
static var height = 175; // 静态属性
static void getHeight() {// 静态方法
    print(height); 
}
void getInfoTemp () {
    print('${this.age}-----${height}');// 非静态方法可以访问静态成员和非静态成员
    getHeight();// 非静态方法 也可以访问静态方法
}

// 调用
// 可以直接通过类来调用静态变量和静态方法,而不是通过实例变量
print(Person.height);
Person.getHeight();

注意

静态方法只能访问静态成员不能访问非静态属性也不能访问非静态方法

调用静态成员时不能使用this 因为this代表当前类的实例

非静态方法可以访问静态成员和非静态成员(方法和属性都可访问)

继承

用extends来继承其他类

子类会继承父类里面可见的属性和方法但是不会继承构造函数

子类能复写父类的方法

如果父类的默认构造函数为有参数的构造函数则子类必须要写自己的构造函数

重写父类方法直接和父类重名就行了或者用 @override

@override 可以写也可以不写建议写上

子类里调用父类的方法用super

class Boy extends Person {
  String sex;
  // 如果父类的默认构造函数 为有参数的构造函数 则子类必须要写自己的构造函数
  Boy(String name, int age, String sex) : super(name, age) { 
  // super 表示  把子类初始化时传进来的参数 赋值给父类
     this.sex = sex;
  }

  @override  // @override 可以写 也可以不写 建议写上
  void getInfo() {
    // TODO: implement getInfo
    // super.getInfo();
    print('复写父类 ${this.name}-----${this.age}');
  } 
}

抽象类用abstract关键字

1: Dart抽象类主要用于定义标准, 子类可以继承抽象类,也可以实现抽象类接口

2: Dart中抽象方法不能用abstract来修饰, Dart中没有方法体的方法称为抽象方法

3: 如果子类继承抽象类,那么必须要实现抽象类里的抽象方法

抽象类用途: 抽象类主要用于约束子类比如子类Dog中必须实现eat和run这两个方法这个时候父类就要用abstract来修饰(定义标准)

abstract class Animal {
  eat(); // 抽象方法 因为没有方法体
  run();

  printInfo() {// 普通方法 因为有方法体
    print('我是抽象类里的一个普通方法');
  }
}

class Dog extends Animal {
  @override
  eat() {
    // TODO: implement eat
    print('小狗在吃狗粮');
  }

  @override
  run() {
    // TODO: implement run
    print('小狗在跑');
  }
}

接口用关键词implements实现

abstract class A{
  String name;
  printA();
}

abstract class B{
  printB();
}

class C implements A,B{  
  @override
  String name;  
  @override
  printA() {
    print('printA');
  }
  @override
  printB() {
    // TODO: implement printB
    return null;
  }
}

Mixins

1: 作为Mixins的类只能继承自Object 不能继承其他类(这里指的不是根类如果A继承自Person那么A不能被c混入)

2: 作为Mixins的类不能有构造函数(A B不能有构造函数)

3: Mixins可以混入多个类

4: Mixinx不是继承不是接口是新的特性

总结

abstract, implements以及Mixins这三个东西的异同点,如何取舍及用途,网上有很多文章,我就不长篇大论了, 这里我只是说下我个人的理解,如果不对请各位指正
1:这三个东西可以实现开发者多继承的意图
2:可以制定规则规范,用来约束子类或者引用他们的类
3:我个人认为,这三个东西还有个重要的用途-------解耦!