Flutter记录的第一天 Dart语法学习（二）

dart特性

代码居多可复制自行运行学习。

1、方法

///方法定义
///返回类型  方法名（参数1,参数2,...）{
///	方法体...
///	return 返回值
///}
void main(List<String> args) {
  String person= getPerson("huangxiaoguo", 25);
  print(person);//name=huangxiaoguo,age=25
}
String getPerson(String name,int age){
  return "name=$name,age=$age";
}

///方法特性
///方法也是对象，并且有具体的类型Function
///返回值类型、参数类型都可省略
///箭头语法：=> expr 是{return expr;}缩写。只适用于一个表达式
///方法都有返回值。如果没有指定，默认return null 最后一句执行
void main(List<String> args) {
  printPerson("张三", 18);

  print(printPerson("张三", 18));

  String person = getPerson("huangxiaoguo", 25);
  print(person);
}
printPerson(name, age) {
  print("name=$name,age=$age");
}
getPerson(name, age) => "name=$name,age=$age";

//name=张三,age=18
//name=张三,age=18
//null
//name=huangxiaoguo,age=25


///可选参数
///可选命名参数:{param1,param2,…}
///可选位置参数:[param1,param2,…]
///如果存在具体参数，可选参数声明，必须在参数后面
void main(List<String> args) {
  printPerson("张三");
  printPerson("张三", age: 28);
  printPerson("张三", age: 28, gender: "huang");
  printPerson("张三", gender: "huang", age: 28);
  print("---------------------------------------------");
  printPerson2("张三");
  printPerson2("张三", 28);
  printPerson2("张三", 28, "huang");
}
// 可选命名参数(常用)
printPerson(String name, {int age, String gender}) {
  print("name=$name,age=$age,gender=$gender");
}
// 可选位置参数
printPerson2(String name, [int age, String gender]) {
  print("name=$name,age=$age,gender=$gender");
}
//name=张三,age=null,gender=null
//name=张三,age=28,gender=null
//name=张三,age=28,gender=huang
//name=张三,age=28,gender=huang
//---------------------------------------------
// name=张三,age=null,gender=null
//name=张三,age=28,gender=null
//name=张三,age=28,gender=huang


/// 默认参数值
///使用 = 在可选参数值指定默认值
///默认值只能是编译时常量
void main(List<String> args) {
  printPerson("张三");
  printPerson("张三", age: 28);
  printPerson("张三", age: 28, gender: "huang");
  printPerson("张三", gender: "huang", age: 28);
}
// 可选命名参数(常用)
printPerson(String name, {int age=66, String gender="Name"}) {
  print("name=$name,age=$age,gender=$gender");
}
//name=张三,age=66,gender=Name
//name=张三,age=28,gender=Name
//name=张三,age=28,gender=huang
//name=张三,age=28,gender=huang

/// 方法对象
///方法可作为对象赋值给其他变量
///方法可作为参数传递给其他方法
void main(List<String> args) {
  var func = printHello;
  Function func1 = printHello;
  func();
  func1();
  var list = [1, 2, 3, 4];
  list.forEach(print);
  var list2 = ['h', 'e', 'l', 'l', 'o'];
  print(listTimes(list2, times));
}
void printHello() {
  print("Hello");
}
List listTimes(List list, String times(str)) {
  for (var i = 0; i < list.length; i++) {
    list[i] = times(list[i]);
  }
  return list;
}
String times(str) {
  return str * 3;
}
//Hello
//Hello
//1
//2
//3
//4
//[hhh, eee, lll, lll, ooo]


///匿名方法
///（参数1,参数2,....）{
///	方法体...
/// 	return 返回值
/// }
/// 可赋值给变量，通过变量进行调用
///可在其他方法中直接调用或传递给其他方法
///
void main(List<String> args) {
  var func = () {
    print("Hello");
  };

  func();
  var func1 = (str) {
    print("Hello-------$str");
  };

  func1("huangxiaoguo");

  // 通过()进行调用，不推荐使用
  (() {
    print("通过()进行调用，不推荐使用");
  })();

//匿名方法传参
  var list2 = ['h', 'e', 'l', 'l', 'o'];
  print(listTimes(list2, (str) {
    return str * 3;
  }));
}

List listTimes(List list, String times(str)) {
  for (var i = 0; i < list.length; i++) {
    list[i] = times(list[i]);
  }
  return list;
}
//Hello
//Hello-------huangxiaoguo
//通过()进行调用，不推荐使用
//[hhh, eee, lll, lll, ooo]


///闭包
///闭包是一个方法（对象）
///闭包定义在其他方法内部
///闭包能够访问外部方法内的局部变量，并持有其状态

void main(List<String> args) {
  var func = a();
  for (var i = 0; i < 5; i++) {
    func();
  }
  print("-------------------------");
  var func1 = b();
  for (var i = 0; i < 5; i++) {
    func1();
  }
}

a() {
  int count = 0;
  printCount() {
    print(count++);
  }
  return printCount;
}

b() {
  int count = 10;
  return () {
    print(--count);
  };
}
//0
//1
//2
//3
//4
//-------------------------
//9
//8
//7
//6
//5

2、类

///类
///属性默认会get  set
///使用  final   属性只有get
///属性和方法通过.访问
///方法不能被重载
void main (){
  var person = new Person();
  person.name;

  person.work();
}

class Person{
  String name;
  int age;
  final address;

  void work(){
    print(name+age);
  }
}

///计算属性
void main (){
  var rect = new Rectangle();
  rect.width = 20;
  rect.height = 20;

  print(rect.area);

  rect.area = 200;
  print(rect.width);
}
class Rectangle{
  num width,height;

  num get area => width * height;
      set area(value){
        width = value / 20;
      }
}

///构造方法
/// 构造方法不能重载
class Person{
  String name;
  int age;

  final String gen;
  //默认
  Person(){}

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

  //final   可以在构造方法中初始化
  Person(this.name , this.age, this.gen){
  }

  ///多构造方法写法
  Person.withName(this.name){
  }

}

///常量构造方法
///使用const声明构造方法，所以变量都是final
///const  声明可以省略
/// const person = const Person("aa",12);
/// const person = Person("aa",12);
class Person{
  final String name;
  final int age;

  const Person(this.name , this.age);

  void work(){
    print(name+age);
  }
}

///工厂构造方法
///可以返回对象
class Node {
  String name;
  int age;

  factory Node(String name) {
    return Node._a(name, 1);
  }

  Node._a(this.name,this.age);  // 私有构造方法
}

///静态 static   和java 一样
void main(){
  Page.scrollDown();
}

class Page{
  static int currentPage = 1;

  //方法是静态   里面成员也必须是静态
  static void scrollDown(){
    currentPage = 1;
    print("scrollDown...$currentPage");
  }

  //方法不是静态，可以访问静态成员
  void scrollUp(){
    currentPage++;
    print("scrollUp...$currentPage");
  }
}

///对象操作符
void main(){
  Person person;
  person?.work();// ?.  如果person是空不继续执行

  //as 如果person是Person类型的话  as 可以转换
  var person;
  person = "";
  person = new Person();
  (person as Person).work();

  //is   是否是Person对象
  if(person is Person){
    person.work();
  }

  //..级联操作符
  var person = new Person();
  person..name = "tome"
        ..age = 18
        ..work();
}
class Person{
  String name;
  int age;

  void work(){
    print("work...")
  }
}

3、面向对象编程

///继承
/**
 * 使用关键字extends继承
 * 子类继承可见的属性和方法，不会继承构造方法
 * 子类能复写父类方法、getter和setter
 * 单继承，多态性
 */

/**
 * 继承中的构造方法
 * 子类的构造方法默认会调用父类的无名无参构造方法
 * 如果父类没有无名无参构造方法，这需要显示调用父类构造方法
 * 在构造方法参数后使用：显示调用父类构造方法
 */
void main(){
    var student = new Student();
    student.age = 18;
    student.name = "Tome";

    Person person = new Student();
}

class Student extends Person{
  void study(){
    print("Student ...");
  }
}

class Person{
  var age;
  var name;

  void run(){
    print("Person ...");
  }
}

///抽象类
/**
 * 抽象类使用abstract表示，不能直接被实例化
 * 抽象方法不用abstract修饰，无实现
 * 抽象类可以没有抽象方法
 */

///接口
/**
 * 类和接口是统一的，类就是接口
 * 每个类都隐式的定义了一个包含所以实例成员的接口
 * 如果复用已有的类的实现，使用继承（extends）
 * 如果只是使用已有类的外在行为，使用接口（implements）
 */

///Mixins
/**
 * Mixins类似于多继承，是多类继承中重用一个类代码的方式
 * 做完Mixin的类不能有显示声明构造方法
 * 作为Mixin的类只能继承Object
 * 使用关键字with连接一个或者对个mixin
 */
class A{
  void a(){
    print("a()")
  }
}
class B{
  void a(){
    print("a()")
  }
}
class C{
  void a(){
    print("a()")
  }
}

class D extends A with B,C{
}

//两个表达式一样
class Car = D with A;
class Car extends D with A{

}