Flutter——进阶

类

  创建Person类
   1、 class Person {
          String name = "张三";
          int age = 23;
          //默认的构造函数
          Person(){
                print('实例化自动触发构造函数！');
          }
          void getInfo() {
            print('$name');
            print('${this.name}');
          }
        }
        void main() {
          var p1 = new Person();
          p1.getInfo();
        }
  2、class Person{
        String ? name;
        int ? age;
        //默认的构造函数
        Person(String name,int age){  //可简写Person(this.name,this.age);-
            this.name = name;
            this.age = age;
          }
        void getInfo() {
            print('$name');
            print('${this.name}');
          }
        }
        void main() {
          var p1 = new Person('zhang',20);
          p1.getInfo();
        }
  3.命名构造函数
      class Person{
          String ? name;
          int ? age;
          //默认的构造函数
          // Person(String name,int age){
          //   this.name = name;
          //   this.age = age;
          // }
          Person(this.name,this.age);
          Person.now(){
            print('命名构造函数！');
          }
          void getInfo() {
            print('$name');
            print('${this.name}');
          }
        }
      void main() {
      var p1 = new Person('zhang',20);
      var p2 = new Person.now();
      p1.getInfo();
    }
类的抽离：将class 类抽离成文件，再需要的地方import即可。
私有方法和私有属性： 使用“_”可以将属性和方法定义成私有，必须再一个单独的文件里
   
    String ? _name; 私有属性
    int ? age;      公有属性
    void _run       私有方法
    void running    公有方法
如何访问私有属性和方法：可以使用公共方法修改私有属性和调用私有方法
   get ：
   class Rect{
       num h;
       num w;
      Rect(this.h,this.w);
      get area {
        return this.h*this.w;
      }
    }
 void main() {
      Rect r = new Rect(10, 2);
      print(r.area);
   }
set ：相当于计算属性
   class Rect{
      num h;
      num w;
      Rect(this.h,this.w);
      get area {
        return this.h*this.w;
      }
      set heightr(value) {
        this.h = value;
      }
    }
    void main() {
          Rect r = new Rect(10, 2);
          r.heightr =100;
          print(r.area);
    }
类的初始化列表：初始化时就实例化之前使用这个值
    //在默认的构造函数同上例：
        Rect():h=10,w=10{
            print(这里会在实例化之前优先执行);
        }
静态属性和静态方法：static 修饰
  static String name = "张三"
  static void Fn() //静态方法只能访问静态属性静态方法
对象的操作符
  ？：
      Person p;
      p? Fn()  //表示如果为空对象则不执行方法
  as:
       var p1 = new Person('zhang', 20);
       // p1.getInfo();
       var p2;
       p2 = new Person('adf', 30);
       p2.getInfo();   //老版本中使用(p1 as Object).getInfo(); 
  ..级联:
       Person p1 = new Person('zhang', 30);
       p1.getInfo();
       p1..age=60
         ..name="王五"
         ..getInfo();

类的继承

class Person {
  String? name = "张三";
  int? age = 60;
  Person(this.name, this.age);
  void printInfo() {
    print("${this.name}");
  }
  work(){
    print('写代码');
  }
}

class Web extends Person {
  String? sex;
  Web(String name, int age, sex) : super(name, age) {
    this.sex = sex;
  }
  run (){
    print("${this.sex}");
    super.work();  //调用父类方法
  }
  //重写父类的方法
  @override
  void printInfo(){
    print("${this.age}");
  }
}

void main() {
  Web w = new Web('zhang', 60,'女');
  w.printInfo();  //会输出年龄，因为重写了父类方法
  w.run();
}

抽象类

-抽象类通过abstract关键字定义
-dart 中的抽象方法不能用abstract声明，dart没有方法体的方法就叫抽象方法
-如果子类继承抽象类必须的实现里面的抽象方法
-如果把抽象类当作接口实现的化必须的实现抽象类里面定义的所有属性和方法
-抽象类不能被实例化，只有继承它的子类可以
-extends 抽象类和imolements的区别：
   如果要复用抽象类里面的方法，并且要用抽象方法约束子类的话我们就用extends继承抽象类
   如果只是把抽象类当作标准的话我们就用implements实现抽象类
抽象类：
abstract class Animal {
  eat(); //抽象方法,所以子类必须实现重载eat方法
  run();
  printInfo() {
    print("抽象类的普通方法！");
  }
}

class Dog extends Animal {
  @override
  eat() {
    // TODO: implement eat
    print('狗吃骨头！');
  }

  @override
  run() {
    // TODO: implement run
    print('狗猫跑去哦！');
  }
}

class Cat extends Animal {
  @override
  run() {
    // TODO: implement eat
    print('猫跑去哦！');
  }

  @override
  eat() {
    // TODO: implement eat
    print('猫吃骨头！');
  }
}

void main() {
  Dog d = new Dog();
  d.eat();
  Cat c = new Cat();
  c.run();
}
多态：
  同上，只是在实例化子类时，将实例化赋值给父类
  Animal c = new Cat();
  c.eat(); //此时实例只有父类的方法
一个类实现多个接口：
  class C implements A,B{    
    }
mixins:使用width
继承的父类中不能有构造函数
class C extends A width B{
 }
class C extends Person width A,B{ //继承Person类，B和A中有同样的方法，后面的会替换掉前面的
 }

泛型

解决不特定的类型校验和代码复用
    T getData<T>(T value){ // 第一个T可以不写，将不对返回参数校验
    return value
    }
    
    getData<String>("您好")；
    泛型类
        class MyList<T> {
            List list =<T> [];
          void add (T value){
            this.list.add(value);
          }
      List getList(){
        return this.list;
      }
    }
    void main() {
      MyList l1 = new MyList();
      MyList l1 = new MyList<String>(); //类型约束
      l1.add(132);
      l1.add("asdf");
      print(l1.getList());
    }

包管理

    import "..." as lib1  //包重命名
    import "..." show  lib1  //包的部分导入
    import "..." hide lib1  //包隐藏部分

空安全

us

    空安全    ？  在2.2版本后类型加入了空安全.
        String ? uesrname = "张三"  // ? 可空类型   username = null
        String ? 方法名（）  //方法可空
    类型断言  ！
        String ? uesrname = "张三" ；
        username = null；
        print(username!.length);  //抛出异常
    late 关键字延迟初始化
    required  必须传入