函数

main(List<String> args) {
  sayHello("name");

  sayHello2("name", 18, 1.88);
  sayHello2("name", 18);

  sayHello3("name", age: 20, height: 1.88);
  sayHello3("name", age: 20);//参数可省略
}

必选参数

void sayHello(String name) {
  print(name);
}

可选参数

只有可选参数可以给默认值

位置可选参数

[] 里面可省略

void sayHello2(String name, [int age = 10, double height = 1.0]) {
    
}

命名可选参数

{} 里可省略，但调用必须是标签参数调用

void sayHello3(String name, {int age = 20, double height = 2.0}) {
    
}

类

类的构造方法

main(List<String> args) {
  var p = Person("Joho", 30);

  var p2 = Person("Joho", 30);

  var p3 = Person.withNameAndAge("Joho", 18);

  var map = {'name': 'kobe', 'age': 30};
  var p4 = Person.fromMap(map);
}

class Person {
  String name;
  int age;
  double height;
}

普通构造方法

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

语法糖

  Person(this.name, this.age);

命名构造方法

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

map 构造

Person.fromMap(Map<String, Object> map) {
    this.name = map["name"];
    this.age = map["age"];
  }

初始化列表

class Person {
  final String name;
  final int age;
  
  //类的初始化列表
  
  Person(this.name) : age = 10;
  //或
  Person(this.name, {this.age = 10});
}

类的继承

关键字： extends

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

class Student extends Person {
  String id;
  // 继承父类 name、age 属性，调用 super 构造方法
  Student(this.id, String name, int age) : super(name, age);
}

抽象类的使用

关键字： abstract

abstract class Shape {
  double area();
  String getInfo() {
    return "shape";
  }
}

class Square extends Shape {
  @override
  double area() {
    return 100.0;
  }

  @override
  String getInfo() {
    return "square";
  }
}

总结

• 继承自抽象类后，必须实现抽象类的所有抽象方法
• 抽象类不能实例化

为什么 Map 可以实例化

var map = Map();
map["name"] = "Joho";
print(map);

Map 是抽象类，但却可以实例化，原因在于 external factory Map();

external 关键字 可以把 声明和 实现分离，需配合注解 @patch 实现

@patch 可以针对不同平台进行实现

见： map_patch.dart

隐式接口

dart 没有 interface、protocol 这样的关键字表示接口，但是默认的所有类都相当于接口，dart 不支持多继承
在开发中，通常使用 abstract 用于给别人实现的类声明为抽象类

main(List<String> args) {
  final sm = SuperMan();
  sm.run();
  sm.fly();
}

abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

class SuperMan implements Runner, Flyer {
  @override
  run() {
    print("SuperMan is running");
  }

  @override
  fly() {
    print("SuperMan is flying");
  }
}

mixin 混入

在通过 implements 实现某个类时，类中所有的方法都必须被重新实现，但是某些时候，一个类可能希望直接复用之前类的实现方案，这就需要借助于 mixin 关键字，

借助于 mixin 关键字定义一个类，借助于 with 关键字来进行混入。

main(List<String> args) {
  final sw = SuperWoman();
  sw.run();
  sw.fly();
}

mixin Runner {
  run();
}

mixin Flyer {
  fly();
}

// implements 的方式必须要对其中的方法进行 onverride
class SuperMan implements Runner, Flyer {
  @override
  run() {}

  @override
  fly() {}
}

// with 关键字 则不需要 override 
class SuperWoman with Runner, Flyer {
  run() {
    print("Superwoman is running");
  }

  fly() {
    print("Superwoman is flying");
  }
}