Dart中的办法

  • 办法也是一个目标:运用场景作为参数传递
  • 返回值和参数类型能够省掉
  • 当办法的执行句子只有一句的时分:能够运用箭头函数 => 表达式
  • 可选参数:传递参数的时分有必要带上形参的名字
  • 匿名办法:没有办法名称的办法
  • 闭包 closure
    • 界说在函数里的函数就是闭包, 闭包也是一个目标.
    • 闭包的作用: 能够拜访外部函数的局部变量.
void testClosure() {
    var func = funA();
    func();
    func();
    func();
    func();
    var func2 = funA();
    func2();
    func2();
    func2();
    func2();
}
funA() {
    int count = 0; // 被拜访的变量不会被释放
    return () => print(count++); // 这个匿名函数就是一个闭包
}

执行结果

跟着测试代码学会Dart2.x的面向对象

Dart的OOP

终端创立一个根据OC的Flutter项目flutter create -objc dart_oop

类和目标

  • 运用class关键字声明一个类
  • 能够运用new跟上结构函数
  • 所有的目标默许都承继Object类
  • Dart中会默许生成getter和setter办法
  • 特点和办法都经过点语法.拜访
  • final润饰的特点有必要界说初始值
  • 办法名相同, 参数不相同, 办法不能重载!

类的结构函数

  • 一旦界说了结构函数, 默许的结构函数就失效了
  • 当一个目标所有的成员特点都是final的时分, 这个目标能够被创立为常量目标
  • 结构函数前加上const, 常量目标
void main() {
    JHPerson p = JHPerson();
    p.name = 'Jack';
    p.age = 22;
    p.run();
}
class JHPerson {
    final String name2 = 'Jack2'
    String? name;
    int? age;
    int _weight; // 不能被外界跨文件拜访, 加上_, 同一份文件能够拜访
    final height;
    // 初始写法
    JHPerson(int age, String name, int weight) {
        name = name;
        age = age; // 这样写会重名
        _weight = weight;
        final height;// 外面不允许修正
    }
    // 语法糖写法, 
    JHPerson(this.name, this.age, this._weight, this.height);
    // 命名结构函数
    JHPerson.bigName(this.name, this._weight);
    // const润饰结构函数, 创立常量目标
    const JHPerson(this.name, this._weight);
    void run() {
        print('$age 岁的 $name 在奔跑‍♀️')
    }
    void _go() {
        print('$_weight 斤的 $name 在Go')
    }
    void printP() {
        _go();
    }
    void addAge(int age) {
        this.age = age;
    }
}

Dart的工厂结构&单例目标&初始化列表

factory_class.dart

class FactoryClass {
    // 需要一个单列目标
    static FactoryClass? _instance;
    factory FactoryClass() => _instance ??= FactoryClass._init();
    //{
    //    if (_instance == null) {
    //      _instance = FactoryClass._init();
    //  }
    //  
    //  return _instance!;
    //    }
    // 私有的命名结构函数
    FactoryClass._init();
}

初始化列表

  • 意图:
  • 给final变量赋值
  • 校验传递的参数值
void personDemo() {
    Person p = Person('jack', -1, -2);
}
class Person {
    String name;
    init age;
    final height;
    Person(this.name, this.age, int h)
        : height = h,
          assert (h >= 0),
          assert (age >= 0 ){
              print('name:$name age:$age height:$height');
          }
}

类办法和目标操作符

  • 类办法, 静态的static
  • 静态特点用类名拜访
void staticDemo(){
        //StaticClass st;
        //st.count;
    StaticClass.count = 12;
    print(StaticClass.sum(1));
    StaticClass st = StaticClass();
    st.currentCount = 10;
    StaticClass.count = 11;/ /静态的, 在内存中只有一份
    print(st.sum2(20));
    StaticClass st2 = StaticClass();
    st2.currentCount = 1;
    print(st2.sum2(20));
}
class StaticClass {
    // 静态特点
    static int count = 1;
    // 实例特点
    int currentCount = 0;
    static const String str = 'jack';
    // 静态办法
    static int sum(int a) {
        return a + count;
    }
    // 实例办法, 能够拜访非静态成员
    int sum2(int a) {
        return currentCount + a + count;
    }
    var s1 = Object();
    s1 = StaticClass();
    print((s1 as StaticClass).sum2(10));// 强制类型转换
    // s1 = null;
    print(s1.sum2(10));
    if (s1 is StaticClass) {
        print(s1.sum2(10));
        print(s1..currnetCount = 15..sum2(20));// 链式编程, 接连调用. 返回值是目标自身
    }
}

Dart的承继

  • 运用extends承继一个类
  • 子类会承继除了结构办法以外的特点和办法
  • Dart是单承继的
  • 默许承继Object
  • 承继的子类会承继默许结构办法
  • 假如结构办法有参数/有名字, 要主动调用
  • 初始化列表要写在super前面
void extendsDemo() {
    Student st = Student();
    st.run();
    st.sutdy();
    st.name = 'Jack';
    st.age = 18;
    print(st.isFree);
    Person st1 = Studyent();
    st1.run();
    if (st1 is Student) {
        st1.sutdy();
        st1.age = 17;
        print(st1.isFree);
        print(st1);
    }
}
class Student extends Person {
    final String subName;
    Student.withName(String? name) : subName = name!, super.withName(name);
    Student() : super.init();
     study() {
         print('写作业');
     }
     @override
     bool get isFree => age! < 18;
     @override
     run() {
         print('学生在跑');
     }
     @override
}
class Person {
    Person.init();
    String? age;
    int? age;
    int? _height;
    bool get isFree => _height! < 120;
    run() {
        print('人在跑');
    }
}

Dart的笼统类接口

  • 有点相似协议接口
  • 是不能被实例化的类abstract润饰
  • 承继一个笼统类, 有必要要实现里边的笼统办法
abstractDemo() {
    AbstractClass as = SubClass();
    as.sum(10, 20);
    SubClass1 sc = SubClass1();
    sc.sum(10, 20);
    sc.sum1(10, 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) {
        print('a + b = ${a + b}');
        return a + b;
    }
}
class SubClass1 implements AbstractClass, AbstractClass1, AbstractClass2 {
    @override
    int sum(int a, int b) {
        print(subClass..sum);
        return 0;
    }
    @override
    int sum1(int a, int b) {
        print(subClass..sum1);
        return 0;
    }
    @override
    int sum2(int a, int b) {
        print(subClass..sum2);
        return 0;
    }
}

Dart的(多承继)Mixins混入

  • 混入, 相似多承继
  • 作为混入类, 是不能实现结构办法的.
mixinDemo() {
    D d = D();
    d.a();
    d.b();
    d.c();
}
operatorDemo() {
    OperatorClass op1 = OperatorClass(18);
    OperatorClass op2 = OperatorClass(19);
    print(op1 > op2);
}
class OperatorClass {
    int age;
    OperatorClass(this.age);
    bool operator >(OperatorClass other) => this.age > other.age;
}
class A {
    a() => print('a....');
}
class B {
    b() => print('b....');
}
class C {
    a() => print('c....'); // 跟A同名的, C在后面, 会掩盖
}
// class D extends A with B, C {}
classD= A with B,C;// 简写