函数定义

// 指定返回值类型
int getNum() {    // 也可以返回别的类型
var num = 123;
return num;
}

var n = getNum();
print(n);

函数的可选参数

// 返回String类型, []里面代表可选参数
String printUser(String name, int age, [String address, String work]) {
  return "$name --- $age -- $address";
}

void main() {
  print(printUser("panghu", 10, "china"));
}

// 可选参数可以用 = 设置默认值
String printUser(String name, int age, [String address = "未知"]) {
  return "$name --- $age -- $address";
}

void main() {
  print(printUser("panghu", 10)); // panghu --- 10 -- 未知
}

匿名方法/闭包

() {
print("say hello");
}();

// 闭包
fun() {
var a = 123;
return () { // 返回匿名函数
  a++;
  print(a);
};
}

var f = fun();
f();  // 124
f();  // 125
f();  // 126

类

// 类
class Person {
  String name;
  int age;
  // void代表没返回值
  void fun() {
    print("${this.age}---${this.name}");
  }
  // 构造函数, 实例化的时候会自动执行
  Person() {
    print("我被实例化了");
  }
}

void main() {

  // 实例化
  var p = new Person();
  p.name = "panghu";
  p.age = 10;
  p.fun();
}

静态属性/方法

class Person {
  static String name; // 静态变量
  int age;
  static fun() {
//    return age; // 静态方法,无法调用非静态变量
//  print(this.name); // 静态变量无法通过this调用
    print(name);
  }
}

void main() {

//  Person p = new Person();
//  p.fun(); // 静态方法无法实例化调用
//  p.name;  // 静态变量
//  p.age = 100;

  // 静态方法的调用
  Person.name = "panghu";
  Person.fun();
}

连缀操作

class Person {
  String name;
  int age;
  String sex;
}

void main() {
  Person p = new Person();
  // 连缀操作
  p..name = "panghu"
   ..age = 10
   ..sex = "男";
}

继承

class Person {
  String name;
  int age;
  fun() {
    print("${name} --- ${age}");
  }
}
class panghu extends Person { // 继承了Person类

}
void main() {
  panghu p = new panghu();
  p.name = "panghu";
  p.age = 10;
  p.fun();
}

多态

abstract class Animal {   // 抽象类, 无法被实例化
  eat();  // 抽象方法
  fun() {
    print("抽象类里面的普通方法!");
  }
}

class Dog extends Animal {  // 因为继承抽象类,所以必须实现里面的抽象方法
  @override
  eat() {
    print("吃肉");
  }

}

class Cat extends Animal {
  @override
  eat() {
    print("吃鱼");
  }
}

void main() {
  Dog d = new Dog();
  d.eat();
  d.fun();

  Cat c = new Cat();
  c.eat();
  c.fun();

}

接口

abstract class Animal {
  eat();
  fun() {
    print("抽象类里面的普通方法!");
  }
}

class Dog implements Animal { // 接口需要实现里面的所有方法
  @override
  eat() {
    print("吃肉");
  }

  @override
  fun() { // 

  }
}

void main() {
  Dog d = new Dog();
  d.eat();
  d.fun();
}

mixins

做为mixins的类只能继承Object类,不能继承其他类
做为mixins的类不能有构造函数

class A {
  printA() {
    print("printA");
  }
}
class B {
  printB() {
    print("printB");
  }
}

//class c extends A, B{}  // 无法多继承
class c with A, B {}  // mixins可以继承多个类
void main() {
  A a = new A();
  a.printA();
  B b = new B();
  b.printB();
}