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 类型转换
is 类型判断
.. 级联操作（连缀） (记住)

class Person {
  String name;
  num age;
  Person(this.name, this.age);
  void printInfo() {
    print("${this.name} ----- ${this.age}");
  }
}

main() {
  Person p = new Person('张三', 20);
  // 判断是否存在这个方法
  p?.printInfo();
  // 判断是否属于这个类
  if (p is Person) {
    p.name = '小樱';
  }
  p.printInfo();

  // 类型转换
  // var p0;

  // p0='';

  // p0=new Person('张三1', 20);

  // // p0.printInfo();
  // (p0 as Person).printInfo();

  Person p1 = new Person('张三1', 20);

  p1.printInfo();

  p1
    ..name = "李四"
    ..age = 30
    ..printInfo();
}

Dart 类的继承-简单继承

面向对象的三大特性：封装 、继承、多态

Dart中的类的继承：
1、子类使用extends关键词来继承父类
2、子类会继承父类里面可见的属性和方法但是不会继承构造函数
3、子类能复写父类的方法 getter和setter

class Person {
  String name = '张三';
  num age = 20;
  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

class Web extends Person {}

class Person1 {
  String name;
  num age;
  Person1(this.name, this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

// Dart 类的继承 super关键词的使用  实例化自类给父类构造函数传参
class Web1 extends Person1 {
  Web1(String name, num age) : super(name, age);
}

class Person2 {
  String name;
  num age;
  Person2(this.name, this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

// Dart 类的继承 实例化自类给命名构造函数传参
class Web2 extends Person2 {
  String sex;
  Web2(String name, num age, String sex) : super(name, age) {
    this.sex = sex;
  }
  run() {
    print("${this.name}---${this.age}--${this.sex}");
  }
}

main() {
  // 继承了父类
  Web w = new Web();
  print(w.name); // 张三
  w.printInfo(); // 张三---20

  Web1 w1 = new Web1('雏田', 18);
  w1.printInfo(); // 雏田---18

  // Dart 类的继承 实例化自类给命名构造函数传参
  Web2 w2 = new Web2('鸣人', 18, "男");
  w2.printInfo();
  w2.run();
}

Dart 类的继承覆写父类的方法

面向对象的三大特性：封装 、继承、多态

Dart中的类的继承：
1、子类使用extends关键词来继承父类
2、子类会继承父类里面可见的属性和方法但是不会继承构造函数
3、子类能复写父类的方法 getter和setter


class Person {
  String name;
  num age;
  Person(this.name, this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }

  work() {
    print("${this.name}在工作...");
  }
}

class Web extends Person {
  Web(String name, num age) : super(name, age);

  run() {
    print('run');
  }

  //覆写父类的方法
  @override //可以写也可以不写  建议在覆写父类方法的时候加上 @override
  void printInfo() {
    print("姓名：${this.name}---年龄：${this.age}");
  }

  @override
  work() {
    print("${this.name}的工作是秘书");
  }
}

main() {
  Web w = new Web('甘雨', 20);

  w.printInfo(); // 姓名：甘雨---年龄：20

  w.work(); // 甘雨的工作是写代码
}

Dart 自类里面调用父类的方法

面向对象的三大特性：封装 、继承、多态

Dart中的类的继承：
1、子类使用extends关键词来继承父类
2、子类会继承父类里面可见的属性和方法但是不会继承构造函数
3、子类能复写父类的方法 getter和setter

class Person {
  String name;
  num age;
  Person(this.name, this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }

  work() {
    print("${this.name}在工作...");
  }
}

class Web extends Person {
  Web(String name, num age) : super(name, age);

  run() {
    print('run');
    super.work(); //自类调用父类的方法
  }

  //覆写父类的方法
  @override //可以写也可以不写  建议在覆写父类方法的时候加上 @override
  void printInfo() {
    print("姓名：${this.name}---年龄：${this.age}");
  }
}

main() {
  Web w = new Web('刻晴', 18);

  w.printInfo(); // 姓名：刻晴---年龄：18

  w.run();

  /*
    run
    刻晴在工作...
   */
}

Dart中的抽象类

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

1、抽象类通过abstract 关键字来定义

2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。

3、如果子类继承抽象类必须得实现里面的抽象方法

4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。

5、抽象类不能被实例化，只有继承它的子类可以

extends抽象类和 implements的区别：

1、如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类

2、如果只是把抽象类当做标准的话我们就用implements实现抽象类

案例：定义一个Animal 类要求它的子类必须包含eat方法,使用 abstract 修饰符来定义抽象类 — 抽象类不能实例化。抽象类通常用来定义接口，以及部分实现。如果希望抽象类能够被实例化，那么可以通过定义一个工厂构造函数来实现。

abstract class Animal {
 eat(); // 抽象方法
 run(); // 抽象方法
 printInfo() {
   print('iAmAnOrdinaryMethodInAnAbstractClass
 我是一个抽象类里面的普通方法');
 }
}

class Dog extends Animal {
 @override
 eat() {
   // TODO: implement eat
   print('小狗在吃骨头，继承了Animal 并且复写eat方法');
 }

 @override
 run() {
   // TODO: implement run
   print('小狗在奔跑，继承了Animal 并且复写run方法');
 }
}

class Cat extends Animal {
 @override
 eat() {
   // TODO: implement eat
   print('小猫在吃鱼,继承了Animal 并且复写eat方法');
 }

 @override
 run() {
   // TODO: implement run
   print('小猫在奔跑,继承了Animal 并且复写run方法');
 }
}

main() {
 Dog d = new Dog();
 d.eat(); // 小狗在吃骨头，继承了Animal 并且复写eat方法
 d.run(); // 小狗在奔跑，继承了Animal 并且复写run方法
 d.printInfo();
 /**
   iAmAnOrdinaryMethodInAnAbstractClass
   我是一个抽象类里面的普通方法
  */
 Cat c = new Cat();
 c.eat(); // 小猫在吃鱼，继承了Animal 并且复写eat方法
 c.run(); // 小猫在奔跑，继承了Animal 并且复写run方法
 c.printInfo();
 /**
   iAmAnOrdinaryMethodInAnAbstractClass
   我是一个抽象类里面的普通方法
  */
}

Datr中的多态：

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

子类的实例赋值给父类的引用。

多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现。

abstract class Anlmal {
  eat();
}

class Dog extends Anlmal {
  @override
  eat() {
    // TODO: implement eat
    print('小狗在吃骨头，继承了Animal 并且复写eat方法');
  }

  run() {
    print('run');
  }
}

class Cat extends Anlmal {
  @override
  eat() {
    // TODO: implement eat
    print('小猫在吃鱼，继承了Animal 并且复写eat方法');
  }

  foo() {
    print('fn');
  }
}

main() {
  Anlmal d = new Dog();
  d.eat(); // 小狗在吃骨头，继承了Animal 并且复写eat方法

  Anlmal c = new Cat();
  c.eat(); // 小猫在吃鱼，继承了Animal 并且复写eat方法
}

接口

和Java一样，dart也有接口，但是和Java还是有区别的。

首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现。

同样使用implements关键字进行实现。

但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍。

而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类。

建议使用抽象类定义接口。

定义一个DB库支持 mysql mssql mongodb

mysql mssql mongodb三个类里面都有同样的方法

abstract class Db {
  // 接口： 约定，规范
  late String url; // 数据库链接地址
  add(String data);
  save();
  delete();
}

class Mysql implements Db {
  @override
  late String url;

  Mysql(String s);

  @override
  add(String data) {
    // TODO: implement add
    print('这是mysql的add方法' + data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }

  remove() {}
}

class MsSql implements Db {
  @override
  late String url;

  @override
  add(String data) {
    // TODO: implement add
    print('这是mssql的add方法' + data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }
}

main() {
  Mysql mysql = new Mysql('http://127.0.0.1:3000');
  mysql.add('甘雨'); // 这是mysql的add方法甘雨
}

接口抽离

创建一个lib文件

里面创建Db.dart

abstract class Db {
  // 接口： 约定，规范
  late String url; // 数据库链接地址
  add(String data);
  save();
  delete();
}

里面创建MsSql.dart

import 'Db.dart';

class MsSql implements Db {
  @override
  late String url;

  @override
  add(String data) {
    // TODO: implement add
    print('这是mssql的add方法' + data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }
}

里面创建MySql.dart

import 'Db.dart';

class Mysql implements Db {
  @override
  late String url;

  Mysql(String s);

  @override
  add(String data) {
    // TODO: implement add
    print('这是mysql的add方法' + data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }

  remove() {}
}

index.dart 直接引入

import 'lib/MsSql.dart';
import 'lib/MySql.dart';

main() {
  Mysql mysql = new Mysql('http://127.0.0.1:3000');
  mysql.add('刻晴'); // 这是mysql的add方法刻晴

  MsSql msSql = new MsSql();
  msSql.url = 'http://127.0.0.1:7001';
  mysql.add('五更瑠璃'); // 这是mysql的add方法五更瑠璃
}

Dart中implements实现多个接口

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

abstract class B {
  late String name;
  printB();
}

class C implements A, B {
  @override
  late String name;

  @override
  printA() {
    // TODO: implement printA
    print('printA');
  }

  @override
  printB() {
    // TODO: implement printB
    return null;
  }
}

void main() {
  C c = new C();
  c.printA(); // printA
  c.printB();
}

mixins

mixins的中文意思是混入，就是在类中混入其他功能。

在Dart中可以使用mixins实现类似多继承的功能

因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件：

1、作为mixins的类只能继承自Object，不能继承其他类
2、作为mixins的类不能有构造函数
3、一个类可以mixins多个mixins类
4、mixins绝不是继承，也不是接口，而是一种全新的特性

class A {
String info = 'this is A';
void printA() {
  print('A');
}
}

class B {
void printB() {
  print('B');
}
}

class C with A, B {}

void main() {
var c = new C();
c.printA();// A
c.printB();// B
print(c.info);// this is A
}

class Person {
  String name;
  num age;
  Person(this.name, this.age);
  printInfo() {
    print('${this.name}----${this.age}');
  }

  void run() {
    print("Person Run");
  }
}

class A {
  String info = 'this is A';
  void printA() {
    print('A');
  }
}

class B {
  void printB() {
    print('B');
  }

  void run() {
    print("B Run");
  }
}

class C extends Person with B, A {
  C(String name, num age) : super(name, age);
}

class D with A, B {}

void main() {
  var c = new C('雏田', 20);
  c.printInfo(); // 雏田----20
  c.printB(); // B
  print(c.info); // this is A

  /*
    mixins的实例类型是什么？

    很简单，mixins的类型就是其超类的子类型。
  */
  var d = new D();
  print(d is D); // true
  print(d is A); // true
  print(d is B); // true
}

泛型

通俗理解：泛型就是解决类接口方法的复用性、以及对不特定数据类型的支持(类型校验)

//只能返回string类型的数据

// String getData(String value){
//     return value;
// }

//同时支持返回 string类型 和int类型  （代码冗余）

// String getData1(String value){
//     return value;
// }

// int getData2(int value){
//     return value;
// }

//同时返回 string类型 和number类型       不指定类型可以解决这个问题

// getData(value){
//     return value;
// }

//不指定类型放弃了类型检查。我们现在想实现的是传入什么 返回什么。比如:传入number 类型必须返回number类型  传入 string类型必须返回string类型

// T getData<T>(T value){
//     return value;
// }

getData<T>(T value) {
  return value;
}

void main() {
  // print(getData(21));

  // print(getData('xxx'));

  // getData<String>('你好');

  print(getData<int>(12));
}

集合List 泛型类的用法

//案例：把下面类转换成泛型类，要求List里面可以增加int类型的数据，也可以增加String类型的数据。但是每次调用增加的类型要统一

//  class PrintClass{
//       List list=new List<int>();
//       void add(int value){
//           this.list.add(value);
//       }
//       void printInfo(){
//           for(var i=0;i<this.list.length;i++){
//             print(this.list[i]);
//           }
//       }
//  }

//  PrintClass p=new PrintClass();
//     p.add(1);
//     p.add(12);
//     p.add(5);
//     p.printInfo();

class PrintClass<T> {
  List list = new List<T>();
  void add(T value) {
    this.list.add(value);
  }

  void printInfo() {
    for (var i = 0; i < this.list.length; i++) {
      print(this.list[i]);
    }
  }
}

main() {
  // PrintClass p=new PrintClass();
  // p.add(11);
  // p.add('xxx');
  // p.add(5);
  // p.printInfo();

  // PrintClass p=new PrintClass<String>();

  // p.add('你好');

  //  p.add('哈哈');

  // p.printInfo();

  PrintClass p = new PrintClass<int>();

  p.add(12);

  p.add(23);

  p.printInfo();

  // List list=new List();
  // list.add(12);
  // list.add("你好");
  // print(list);

  // List list=new List<String>();

  // // list.add(12);  //错误的写法

  // list.add('你好');
  // list.add('你好1');

  // print(list);

  // List list=new List<int>();

  // // list.add("你好");  //错误写法
  // list.add(12);

  // print(list);
}

Dart中的泛型接口:

实现数据缓存的功能：有文件缓存、和内存缓存。内存缓存和文件缓存按照接口约束实现。

1、定义一个泛型接口约束实现它的子类必须有getByKey(key) 和 setByKey(key,value)

> 2、要求setByKey的时候的value的类型和实例化子类的时候指定的类型一致

// abstract class ObjectCache {
//   getByKey(String key);
//   void setByKey(String key, Object value);
// }

// abstract class StringCache {
//   getByKey(String key);
//   void setByKey(String key, String value);
// }

// abstract class Cache<T> {
//   getByKey(String key);
//   void setByKey(String key, T value);
// }

abstract class Cache<T> {
  getByKey(String key);
  void setByKey(String key, T value);
}

class FlieCache<T> implements Cache<T> {
  @override
  getByKey(String key) {
    return null;
  }

  @override
  void setByKey(String key, T value) {
    print("我是文件缓存 把key=${key}  value=${value}的数据写入到了文件中");
  }
}

class MemoryCache<T> implements Cache<T> {
  @override
  getByKey(String key) {
    return null;
  }

  @override
  void setByKey(String key, T value) {
    print("我是内存缓存 把key=${key}  value=${value} -写入到了内存中");
  }
}

void main() {
  // MemoryCache m=new MemoryCache<String>();

  //  m.setByKey('index', '首页数据');

  MemoryCache m = new MemoryCache<Map>();

  m.setByKey('index', {"name": "张三", "age": 20});
}

Dart中的库

前面介绍Dart基础知识的时候基本上都是在一个文件里面编写Dart代码的，但实际开发中不可能这么写，模块化很重要，所以这就需要使用到库的概念。

在Dart中，库的使用时通过import关键字引入的。在Dart中，库的使用时通过import关键字引入的。

library指令可以创建一个库，每个Dart文件都是一个库，即使没有使用library指令来指定library指令可以创建一个库，每个Dart文件都是一个库，即使没有使用library指令来指定

Dart中的库主要有三种：


    1、我们自定义的库     
          import 'lib/xxx.dart';
    2、系统内置库       
          import 'dart:math';    
          import 'dart:io'; 
          import 'dart:convert';
    3、Pub包管理系统中的库  
        https://pub.dev/packages
        https://pub.flutter-io.cn/packages
        https://pub.dartlang.org/flutter/

        1、需要在自己想项目根目录新建一个pubspec.yaml
        2、在pubspec.yaml文件 然后配置名称 、描述、依赖等信息
        3、然后运行 dart pub get 获取包下载到本地  
        4、项目中引入库 import 'package:http/http.dart' as http; 看文档使用

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(); // 类里面的方法互相调用
  }
}

Dart中导入自己本地库

import 'lib/Animal.dart';

main() {
  var a = new Animal('雏田', 20);
  print(a.getName());
  print(a.execRun());
}

导入系统内置库math库

import 'dart:math';

main() {
  print(min(11, 22));//11
  print(max(11, 22));//22
}

导入系统内置库实现请求数据httpClient

import 'dart:io';
import 'dart:convert';

getData() async {
  //1、创建HttpClient对象
  var httpClient = new HttpClient();
  //2、创建Uri对象
  var uri = new Uri.http('news-at.zhihu.com', '/api/3/stories/latest');
  //3、发起请求，等待请求
  var request = await httpClient.getUrl(uri);
  //4、关闭请求，等待响应
  var response = await request.close();
  //5、解码响应的内容
  return await response.transform(utf8.decoder).join();
}

void main() async {
  var result = await getData();
  print(result);
}

async await

async和await
这两个关键字的使用只需要记住两点：
只有async方法才能使用await关键字调用方法
如果调用别的async方法必须使用await关键字
async是让方法变成异步。
await是等待异步方法执行完成。

testAsync() async {
  return 'Hello async';
}

void main() async {
  var result = await testAsync();
  print(result);
}

Dart 导入Pub包管理系统中的库

pub包管理系统:

1、从下面网址找到要用的库
https://pub.dev/packages
https://pub.flutter-io.cn/packages
https://pub.dartlang.org/flutter/

2、创建一个pubspec.yaml文件，内容如下

    name: xxx
    description: A new flutter module project.
    dependencies:  
        http: ^0.12.0+2
        date_format: ^1.0.6

3、配置dependencies

4、运行dart pub get 获取远程库

5、看文档引入库使用

import 'dart:convert' as convert;
import 'package:http/http.dart' as http;
import 'package:date_format/date_format.dart';

main() async {
  var url =
      "http://www.phonegap100.com/appapi.php?a=getPortalList&catid=20&page=1";

  // Await the http get response, then decode the json-formatted responce.
  var response = await http.get(url);
  if (response.statusCode == 200) {
    var jsonResponse = convert.jsonDecode(response.body);

    print(jsonResponse);
  } else {
    print("Request failed with status: ${response.statusCode}.");
  }

  print(formatDate(
      DateTime(1989, 2, 21), [yyyy, '-', mm, '-', dd])); // 1989-02-21
  print(formatDate(DateTime(1989, 2, 21), [yy, '-', m, '-', dd])); // 89-2-21
  print(formatDate(DateTime(1989, 2, 1), [yy, '-', m, '-', d])); // 89-2-1

  print(
      formatDate(DateTime(1989, 2, 1), [yy, '-', MM, '-', d])); // 89-February-1
  print(formatDate(DateTime(1989, 2, 21), [yy, '-', M, '-', d])); // 89-Feb-21

  print(formatDate(DateTime(1989, 2, 1), [yy, '-', M, '-', d])); // 89-Feb-1

  print(formatDate(
      DateTime(2018, 1, 14), [yy, '-', M, '-', DD])); // 18-Jan-Sunday
  print(formatDate(DateTime(2018, 1, 14), [yy, '-', M, '-', D])); // 18-Jan-Sun

  print(formatDate(
      DateTime(1989, 02, 1, 15, 40, 10), [HH, ':', nn, ':', ss])); // 15:40:10

  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10),
      [hh, ':', nn, ':', ss, ' ', am])); // 03:40:10 PM

  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10),
      [hh, ':', nn, ':', ss, ' ', am])); // 03:40:10 PM

  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10), [hh])); // 03
  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10), [h])); // 3

  print(formatDate(DateTime(1989, 02, 1, 5), [am])); // AM
  print(formatDate(DateTime(1989, 02, 1, 15), [am])); // PM

  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10),
      [HH, ':', nn, ':', ss, z])); // 15:40:10+0800

  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10),
      [HH, ':', nn, ':', ss, ' ', Z])); //15:40:10 CST

  print(formatDate(DateTime(1989, 02, 21), [yy, ' ', w])); // 89 4
  print(formatDate(DateTime(1989, 02, 21), [yy, ' ', W])); // 89 8

  print(formatDate(DateTime(1989, 12, 31), [yy, '-W', W])); // 89-W53
  print(formatDate(DateTime(1989, 1, 1), [yy, '-', mm, '-w', W])); // 89-01-w1

  print(formatDate(DateTime(1989, 02, 1, 15, 40, 10),
      [HH, ':', nn, ':', ss, ' ', Z])); // 15:40:10 CST

  print(formatDate(DateTime(2020, 04, 18, 21, 14), [H, '\h', n])); // 21h14
}

冲突解决

当引入两个库中有相同名称标识符的时候，如果是java通常我们通过写上完整的包名路径来指定使用的具体标识符，甚至不用import都可以，但是Dart里面是必须import的。当冲突的时候，可以使用as关键字来指定库的前缀。如下例子所示：
Person1.dart

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

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

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

Person2.dart

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

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

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

import 'lib/Person1.dart';
import 'lib/Person2.dart' as lib;

main(List<String> args) {
  Person p1 = new Person('张三', 20);
  p1.printInfo(); //Person1:张三----20

  lib.Person p2 = new lib.Person('李四', 20);

  p2.printInfo(); // Person2:李四----20
}

部分导入

部分导入
如果只需要导入库的一部分，有两种模式：

     模式一：只导入需要的部分，使用show关键字，如下例子所示：

      import 'package:lib1/lib1.dart' show foo;

     模式二：隐藏不需要的部分，使用hide关键字，如下例子所示：

      import 'package:lib2/lib2.dart' hide foo;

// import 'lib/myMath.dart' show getAge;

import 'lib/myMath.dart' hide getName;

void main() {
//  getName();
  getAge();
}

延迟加载

延迟加载

    也称为懒加载，可以在需要的时候再进行加载。
    懒加载的最大好处是可以减少APP的启动时间。

    懒加载使用deferred as关键字来指定，如下例子所示：

    import 'package:deferred/hello.dart' deferred as hello;

    当需要使用的时候，需要使用loadLibrary()方法来加载：

    greet() async {
      await hello.loadLibrary();
      hello.printGreeting();
    }

dart中class类

学习交流群：634196762

Sometimes you need to applaud yourself

dart中class类

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

Dart中创建义类使用类

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

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

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

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

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

类中的初始化列表

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

Dart 中的对象操作符

Dart 类的继承-简单继承

Dart 类的继承 覆写父类的方法

Dart 自类里面调用父类的方法

Dart中的抽象类

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

extends抽象类 和 implements的区别：

Datr中的多态：

接口

接口抽离

Dart中implements实现多个接口

mixins

mixins的中文意思是混入，就是在类中混入其他功能。

泛型

Dart中的泛型接口:

Dart中的库

Dart中导入自己本地库

导入系统内置库math库

导入系统内置库实现请求数据httpClient

async await

Dart 导入Pub包管理系统中的库

冲突解决

部分导入

延迟加载

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

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

Dart 类的继承覆写父类的方法

extends抽象类和 implements的区别：