Dart函数、类和对象

函数

1. 内置方法

2. 自定义方法

自定义方法基本格式

返回类型 方法名称(参数1, 参数2, ...) {
    方法体;
    return 返回值;
}

返回类型可以省略

3. 箭头函数

箭头后只能写一行代码

List myList = [1, 5, 6, 9];
var newList = myList.map((e) => e > 5 ? e * 2 : e).toList();
print(newList);  // 输出结果：[1, 5, 12, 18]

4. 闭包

1. 全局变量特点：全局变量常驻内存、全局变量污染全局
2. 局部变量的特点：不常驻内存会被垃圾机制回收、不会污染全局

现在想要实现的功能：

1. 常驻内存
2. 不污染全局

所以产生了闭包，通过闭包可以解决这个问题

闭包：函数嵌套函数，内部函数会调用外部函数的变量或参数，变量或参数不会被系统回收
闭包的写法：函数嵌套函数，并return里面的函数，这样就形成了闭包

fn() {
    var a = 123;
    return() {
        a++;
        print(a);
    };
}

var b = fn();
b();
b();
b();

/* 
返回结果：
124
125
126
*/

类和对象

1. 类的创建

class Person {
  String name;
  int age;
  
  // 默认构造方法
  Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
    
  // 简化构造方法
  // Person(this.name, this.age);
    
  // 命名构造方法
  Person.now() {
      
  }

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

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

void main() {
  var p1 = new Person("张三", 23);
  print(p1.name);
  p1.getInfo();
  p1.setAge(25);
  p1.getInfo();
}

输出结果：

张三

张三----23

张三----25

2. 类的引入

import 'Person.dart'

私有属性和私有方法：使用“_”定义，并且将拥有私有属性或方法的该类抽离成单独文件

类中getter和setter修饰符的方法：

class Rect {
  num height;
  num width;
  Rect(this.height, this.width);
  get area {
    // 计算属性
    return this.height * this.width;
  }

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

void main() {
  Rect r = new Rect(10, 4);
  print("面积:${r.area}");
  r.areaHeight = 6;
  print("面积:${r.area}");
}

3. 类中的初始化列表

使用冒号可以传入初始化列表

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

void main() {
  Rect r = new Rect();
}

输出结果：

2—10

4. 静态成员

1. 使用static关键字来实现类级别的变量和函数
2. 静态方法不能访问非静态成员，非静态方法可以访问静态成员

class Person {
  static String name = "张三";
  int age = 20;

  static void show() {
    print(name);
  }

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

  static void printUserInfo() {
    print(name);
    show();

    // 静态方法无法访问非静态的成员
    // print(this.age);
    // this.printInfo();
    // printInfo();
  }
}

void main() {
  Person.show(); // 调用静态方法不需要实例化
  Person p = new Person();
  p.printInfo();
}

输出结果：

张三

张三

20

张三

5. 对象操作符

类型转换	类型判断	级联操作（连缀）	条件运算符（了解）
as	is	…	?

类型转换

var p;
p = 10;
p = new Person("张三", 20);
(p as Person).printInfo();

级联操作

Person p1 = new Person("张三", 20);
p1.printInfo();

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

输出结果：

张三—20

李四—30

6. 继承

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

使用super实例化子类来给父类的构造方法传参

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

class Web extends Person {
  String sex;
  Web(String name, num age, String sex) : super(name, age) {
    this.sex = sex;
  }
  run() {
    print("${this.name}---${this.age}---${this.sex}");
  }
}

void main() {
  Web w = new Web("张三", 12, "男");
  w.printInfo();
  w.run();
}

输出结果：

张三—12

张三—12—男

重写父类方法

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

class Web extends Person {
  String sex;
  Web(String name, num age, String sex) : super(name, age) {
    this.sex = sex;
  }
    
  @override
  void printInfo() {
    print("${this.name}---${this.age}---${this.sex}");
  }
}

void main() {
  Person p = new Person("李四", 20);
  Web w = new Web("张三", 12, "男");
  p.printInfo();
  w.printInfo();
}

输出结果：

李四—20

张三—12—男

子类调用父类方法

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

class Web extends Person {
  String sex;
  Web(String name, num age, String sex) : super(name, age) {
    this.sex = sex;
  }

  run() {
    print("run");
    super.printInfo();
  }
}

void main() {
  Web w = new Web("张三", 12, "男");
  w.run();
}

输出结果：

run

张三—12