Dart基础篇 2.面向对象

构造方法：

        有参构造方法

        无参构造方法

        命名构造方法

        命名工厂构造方法

        工厂构造方法

定义Dart类Person

///定义一个Dart类，所有类都继承自Object
class Person {
  String name;
  int age;

  //父类构造方法
  Person(this.name, this.age);

  //重写父类toString
  @override
  String toString() {
    return 'name:$name , age: $age';
  }
}

 定义Dart类Student集成Person类

///面向对象
class Student extends Person {
  //定义类的变量
  late String _school; //通过下划线来表示私有字段（变量）
  String? city;
  String? country;
  late String name;

  ///构造方法：
  ///通this.school初始化自有参数
  ///name,age交给父类进行初始化
  ///city为可选参数
  ///country设有默认参数
  Student(this._school, String name, int age, {this.city, this.country = "中国"})
      : name = '$country.$city',
        super(name, age) {
    //构造方法提不是必须的
    print("构造方法提不是必须的");
  }

  ///命名构造方法
  Student.cover(Student stu) : super(stu.name, stu.age) {
    print("命名构造方法");
  }

  ///命名工厂构造方法 factory 类名.方法名
  ///他可以有返回值，而且不需要讲类的final变量作为参数，是提供一种灵活获取类对象的方式。
  factory Student.stu(Student stu) {
    return Student(stu._school, stu.name, stu.age,
        city: stu.city, country: stu.country);
  }

  @override
  String toString() {
    return 'name:$name school:${this._school},city:$city,country:$country ${super.toString()}';
  }

  //可以为私有字段设置getter来让外界获取到私有字段
  String get school => _school;

  //可以为私有字段设置getter来让外界获取对私有字段的修改
  set school(String value) {
    _school = value;
  }

  //静态方法
  static doPrint(String str) {
    print("doPrint:$str");
  }
}

通过下划线来表示私有字段（变量）

  构造方法，可以设置默认参数 ，可选参数{}中指定默认参数，和可选参数

  子类构造方法必须要实现父类的构造方法

  命名构造方法 定义：类名.方法名

  命名工厂构造方法 factory 类名.方法名（他可以有返回值） 

---

 

///继承抽象类要实现它的抽象方法，否则也需要将自己定义成抽象类
class StudyFlutter extends Study {
  @override
  void study() {
    print('Learning Flutter');
  }
}

///使用 abstract 修饰符来定义一个抽象类，该类不能被实例化。抽象类在定义接口的时候非常有用，实际上抽象中也包含一些实现
abstract class Study {
  void study();
}

///为类添加特征：mixins
///mixins 是在多个类层次结构中重用代码的一种方式
///要使用 mixins ，在 with 关键字后面跟一个或多个 mixin 的名字(用逗号分开)，并且with要用在extends关键字之后
///mixins的特征：实现 mixin ，就创建一个继承 Object 类的子类(不能继承其他类)，不声明任何构造方法，不调用 super
///猜猜上面的类中哪个是mixin？

class Test extends Person with Study {
  Test(String name, int age) : super(name, age);

  @override
  void study() {
    // TODO: implement study
  }
}

 

使用 abstract 修饰符来定义一个抽象类，该类不能被实例化。抽象类在定义接口的时候非常有用，实际上抽象中也包含一些实现

为类添加特征：mixins
mixins 是在多个类层次结构中重用代码的一种方式
要使用 mixins ，在 with 关键字后面跟一个或多个 mixin 的名字(用逗号分开)，并且with要用在extends关键字之后
mixins的特征：实现 mixin ，就创建一个继承 Object 类的子类(不能继承其他类)，不声明任何构造方法，不调用 super
猜猜上面的类中哪个是mixin？

---

具体调用

///面向对象
_oopLearn(){
  //创建Student对象
  Student stu1 = Student('清华', "majunbao", 20);
  print(stu1.toString());
  stu1.school = '985';
  print(stu1.toString());

  Student.doPrint('_oopLearn');


  Logger logger1 = Logger();
  Logger logger2 = Logger();
  //通过工厂方法每次创建的 都是 同一个对象 所以返回true
  print(logger1 == logger2); // true
  logger1.log("majunbao");
  logger2.log("majunbao");

  StudyFlutter sf = StudyFlutter();
  sf.study();

}

 

class DataType extends StatefulWidget {
  const DataType({Key? key}) : super(key: key);

  @override
  State<DataType> createState() => _DataTypeState();
}

class _DataTypeState extends State<DataType> {
  @override
  Widget build(BuildContext context) {
    //面向对象
    _oopLearn();
    return Container(
      child: const Text("面向对象 ，请查看控制台输出"),
    );
  }
}