dart中class类

Dart面向对象的介绍 以及Data内置对象

• 面向对象编程(OOP)的三个基本特征是：封装、继承、多态

  • 封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用, 而一部分属性和方法则隐藏。

  • 继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

  • 多态：允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 。

• Dart所有的东西都是对象，所有的对象都继承自Object类。

• Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类

  一个类通常由属性和方法组成。

void main() {
  List list = new List();
  list.isEmpty;
  list.add('香蕉');
  list.add('苹果');

  Map m = new Map();
  m["username"] = "张三";
  m.addAll({"age": 20});
  m.isEmpty;

  Object a = 123;
  Object v = true;
  print(a); // 123
  print(v); // true
}

Dart中创建义类使用类

• Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类

class Person {
  String name = '雏田';
  int age = 18;
  void getInfo() {
    // print("$name  ------  $age"); // 第一种写法
    print("${this.name} ----  ${this.age}"); // 第二种写法
  }

  void setinfo(int age) {
    this.age = age;
  }
}

void main() {
  // 实例化
  var p1 = new Person();
  print(p1.name); // 雏田
  p1.getInfo(); // 雏田 ----  18

  print('------------------------------------');

  Person p2 = new Person();
  p2.setinfo(26);
  p2.getInfo(); // 雏田 ----  26
}

Dart中自定义类的默认构造函数

class Person {
  String name = '雏田';
  int age = 18;

  // 默认构造函数
  Person() {
    print('这是构造函数里面的内容  这个方法在实例化的时候触发');
  }

  void printInfo() {
    print("${this.name} ----  ${this.age}"); // 第二种写法
  }
}

class Persons {
  String name;
  int age;
  // 默认构造函数
  /*  Persons(String name, int age) {
    this.name = name;
    this.age = age;
  } */
  //默认构造函数的简写
  Persons(this.name, this.age);

  void printInfo() {
    print("${this.name} --- ${this.age}");
  }
}

void main() {
  Person p1 = new Person();
  p1.printInfo();
  /* 
    这是构造函数里面的内容  这个方法在实例化的时候触发
    雏田 ----  18
   */

  Persons p2 = new Persons('五更琉璃', 16);
  p2.printInfo();
  /* 
    五更琉璃 --- 16
   */

  Persons p3 = new Persons('嘉怡', 25);
  p3.printInfo();
  /* 
      嘉怡 --- 25
  */
}

Dart中自定义类的命名构造函数

• Dart中自定义类的命名构造函数
• Dart里面构造函数可以写多个

class Person {
  String name;
  int age;

  // 默认构造函数的简写
  Person(this.name, this.age);

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

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

  void printInfo() {
    print("${this.name} ---- ${this.age}");
  }
}

void main() {
  var time = new DateTime.now(); // 实例化DateTime调用它的命名构造函数
  print(time); // 2021-01-24 22:48:26.483371

  Person p1 = new Person.setInfo('雏田', 18); // 默认实例化类的时候调用的是 默认构造函数
  p1.printInfo(); // 雏田 ---- 18

  Person p2 = new Person.now(); //命名构造函数
  /* 
    我是命名构造函数
   */
}

Dart中把类单独抽离成一个模块

Person.dart

class Person {
  String name;
  int age;
  // 默认构造函数的简写
  Person(this.name, this.age);

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

  Person.setInfo(String name, int age) {
    this.name = name;
    this.age = age;
  }
  void printInfo() {
    print("${this.name} ----- ${this.age}");
  }
}

index.dart

import 'lib/Person.dart';

void main() {
  Person p1 = new Person.setInfo('兔子零', 10000);
  p1.printInfo(); // 兔子零 ----- 10000
}

Dart中的私有方法 和私有属性

Animal.dart

class Animal {
  String _name; //私有属性
  int age;
  // 默认构造函数的简写
  Animal(this._name, this.age);

  void printInfo() {
    print("${this._name} ---- ${this.age}");
  }

  String getName() {
    // 获取私有属性
    return this._name;
  }

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

  execRun() {
    // 调用私有方法
    this._run(); // 类里面方法的相互调用
  }
}

index.dart

• Dart和其他面向对象语言不一样，Data中没有 public private protected这些访问修饰符合
  但是我们可以使用_把一个属性或者方法定义成私有。

import 'lib/Animal.dart';

void main() {
  Animal a = new Animal('大黄', 3);
  print(a.getName()); // 大黄
  a.execRun(); // 这是一个私有方法
}

类中的getter和setter修饰符的用法

class Rect {
  int height;
  int width;

  Rect(this.height, this.width);

  getArea() {
    return this.height * this.width;
  }
}

class Rect1 {
  int height;
  int width;

  Rect1(this.height, this.width);

  // 类似vue种的计算属性 computed
  get area {
    return this.height * this.width;
  }

  set areaHeight(value) {
    this.height = value;
  }
}

void main() {
  Rect r = new Rect(10, 2);
  print("面积：${r.getArea()}"); // 面积：20

  Rect1 r1 = new Rect1(20, 2); // 面积:40
  print("面积:${r1.area}"); //注意调用直接通过访问属性的方式访问area

  r1.areaHeight = 200;
  print("面积:${r1.area}"); // 面积:400
}

类中的初始化列表

class Rect {
  int height;
  int width;
  Rect()
      : height = 10,
        width = 3 {
    print("${this.height} ---- ${this.width}");
  }

  getArea() {
    return this.height * this.width;
  }
}

void main() {
  Rect r = new Rect();
  print(r.getArea());
  /* 
    10 ---- 3
    30
   */
}

Dart 类中的静态成员静态方法

Dart中的静态成员:

1、使用static 关键字来实现类级别的变量和函数

2、静态方法不能访问非静态成员，非静态方法可以访问静态成员

class Person {
  static String name = '雏田';
  int age = 20;

  static void show() {
    print('静态方法');
  }

  // 非静态方法可以访问静态成员以及非静态成员
  void printInfo() {
    print(name); // 访问静态属性
    print(this.age); //访问非静态属性
    show(); // 调用静态方法
  }

  //静态方法
  static void printUserInfo() {
    print(name); // 静态属性
    show(); // 静态方法
    // print(this.age); //静态方法没法访问非静态的属性
    /** 这里会报错
     * but got 'this'.
     * print(this.age); //静态方法没法访问非静态的属性
     */
    // this.printInfo(); //静态方法没法访问非静态的方法
    // printInfo(); 这里会报错
  }
}

main() {
  // 静态属性和方法可以直接调用，不需要new
  print(Person.name); // 雏田
  Person.show(); // 静态方法
  Person.printUserInfo();
  /**
   * 雏田
   * 静态方法
   */
}

Dart 中的对象操作符

Dart中的对象操作符:

? 条件运算符 （了解）
as</