类、对象、抽象类

使用class关键字声明一个类

可以使用new更上构造函数

所有的对象都继承Object类

//测试
void staticDemo() {
  var s1 = Object();
  s1 = StaticClass();
  //判断类型
  if (s1 is StaticClass) {
    print(s1.sum2(10));
    //链式编程，返回对象本身
    print(s1
      ..currentCount = 15
      ..sum2(20));
  }
}

///类方法
class StaticClass {
  //静态属性，通过类访问
  static int count = 1;
  //实例属性
  int currentCount = 0;

  //常量成员
  static const String str = 'hank';

  //静态方法 通过类访问
  static int sum(int a) {
    return a + count;
  }

  //实例方法
  int sum2(int a) {
    return currentCount + a + count;
  }
}

Dart中默认会生成getter和setter方法，属性和方法都通过.访问。

final、const

final：不会变化的，最终变量。被定义出来之后，只能赋值一次。

?：表示可选参数，可以为空，使用参数的时候需要用到!强制解包。

required：必传参数

class DiscoverCell extends StatelessWidget {
  final String title;
  final String imageName;
  final String? subTitle;
  final String? subImageName;

  DiscoverCell({//大括号表示可选参数
    required this.title, //title必须有
    this.subTitle,
    required this.imageName, //imageName必须有
    this.subImageName,
  })  : assert(title != null, 'title不能为空！'),
        assert(imageName != null, 'imageName不能为空！');

  //后面在使用subTitle和subImageName的时候需要！强制解包
}

使用final声明的一个只能赋值一次的变量！在使用之前必须被赋值

  final c;
  c = 999;
  // c = 222;

当一个对象所有的成员属性都是final的时候，那么这个对象可以被创建为常量对象，用const修饰构造函数。常量对象的创建效率更高。

void test() {
  LGPerson p = const LGPerson(1, 222, 'ddd');
  // p._name = 'hank';//The setter '_name' isn't defined for the class 'LGPerson'.
  // p._age = 18; //The setter '_age' isn't defined for the class 'LGPerson'.
  // p.height = 180; //The setter 'height' isn't defined for the class 'LGPerson'.
  p._run(); //name:ddd age:1 height:222
  p.printP(); //name:ddd age:1 height:222

  LGPerson p1 = LGPerson.withName('ddd', 222, 17);
  p1._run();//name:ddd age:17 height:222
}

class LGPerson {
  final String _name;
  final int age;
  final int height;

  //const修饰构造函数 创建常量对象。
  const LGPerson(this.age, this.height, this._name);
  //命名构造函数。
  LGPerson.withName(this._name, this.height, this.age);

  // {
  //   _name = name;
  //   age = age1;
  // }
  //
  // void changeAge(int age) {
  //   this.age = age;//this表示谁调用，LGPerson。final修饰的不能改变了。
  // }

  void _run() {
    print('name:$_name age:$age height:$height');
  }

  void printP() {
    _run();
  }
}

继承和初始化列表

使用extends继承一个类，子类会继承除了构造方法以外的属性和方法。

Dart是单继承的

void extendsDemo() {
  Person p = Person('cooci', 18, 180);
  p.run();
  //多态
  Person st = Student('hh', 18, 180);
  if (st is Student) {
    st.study();
  }
}

///初始化列表。
///目的：
///1、给final变量赋值
///2、校验传递的值
class Person {
  String name;
  int age;
  final int _height;
  //计算属性
  bool get isFree => _height < 110;

  //初始化列表 冒号:后面
  Person(this.name, this.age, int h)
      : _height = h,
        assert(h >= 0),
        assert(age >= 0) {
    print('name:$name age:$age height:$_height');
  }

  run() {
    print('Im:$this\nname:$name age:$age height:$_height');
  }
}

class Student extends Person {
  final String subName;

  Student(String name, int age, int h)
      : subName = name, //初始化列表必须放在super前面
        super(name, age, h);

  study() {
    print('认真学习');
  }

  @override
  // TODO: implement isFree
  bool get isFree => age < 18;
}

abstract抽象类

抽象类（协议，接口） 抽象类：不能被实例化的类，使用abstract修饰

//测试
abstractDemo() {
  AbstractClass as = SubClass();
  as.sum(10, 20);

  SubClass1 sC = SubClass1();
  sC.sum(10, 20);
  sC.sum1(20, 20);
  sC.sum2(30, 20);
}

abstract class AbstractClass {
  //没有实现的方法就是抽象方法
  //抽象方法只能放在抽象类里面
  int sum(int a, int b);
}

abstract class AbstractClass1 {
  int sum1(int a, int b);
}

abstract class AbstractClass2 {
  int sum2(int a, int b);
}

///抽象类的使用，使用子类
///子类必须实现抽象方法
class SubClass extends AbstractClass {
  @override
  int sum(int a, int b) {
    // TODO: implement sum
    print('a+b=${a + b}');
    return a + b;
  }
}

class a {
  var name;
  run() {}
}

///多继承implements，所有的方法和属性必须都重写
class SubClass1 implements AbstractClass, AbstractClass1, AbstractClass2, a {
  @override
  var name;

  @override
  run() {
    // TODO: implement run
    throw UnimplementedError();
  }

  @override
  int sum(int a, int b) {
    print('subClass1..sum');
    return a + b;
  }

  @override
  int sum1(int a, int b) {
    print('subClass1..sum1');
    return a + b;
  }

  @override
  int sum2(int a, int b) {
    print('subClass1..su2m');
    return a + b;
  }
}