02 Dart基础语法

1. Dart的基本用法

• 01_hell  dart

  /**
   * 1.main函数是dart入口
   * 2.dart当中打印信息使用print函数
   */
  
  main(List<String> args) {
    // List<String> args -> 列表<String> - 泛型
    print("Hello World");
  }
  

• 02_声明变量.

  main(List<String> args) {
    // 1.明确的声明
    String name = "why";
  
    // 2.类型推导(var/final/const)
    // 类型推导的方式虽然没有明确的指定变量的类型, 但是变量是有自己的明确的类型
    // 2.1.var声明变量
    var age = 20;
    // age = "abc";
    age = 30;
  
    // 2.2.final声明常量
    final height = 1.88;
    // height = 2.00;
  
    // 2.3.const声明常量
    const address = "广州市";
    // address = "北京市";
  
    // 2.4.final和const的区别
    // const必须赋值 常量值(编译期间需要有一个确定的值)
    // final可以通过计算/函数获取一个值(运行期间来确定一个值)
    // const date1 = DateTime.now(); 写法错误
    final date2 = DateTime.now();
  
    // final用于的更多一点
    // p1和p2是不是同一个对象
    // final p1 = Person("why");
    // final p2 = Person("why");
    // print(identical(p1, p2));
  
    // 在Dart2.0之后, const可以省略
    const p1 = const Person("why");
    const p2 = const Person("why");
    const p3 = const Person("lilei");
  
    print(identical(p1, p2));
    print(identical(p2, p3));
  
    // dynamic/Object
  }
  
  class Person {
    final String name;
    const Person(this.name);
  }
  
  
  

• 03_非零即真.

  main(List<String> args) {
    var flag = "abc";
  
    if (flag) {
      print("执行代码");
    }
  }

• 04_字符串类型

  main(List<String> args) {
    // 1.定义字符串
    var str1 = 'abc';
    var str2 = "abc";
    var str3 = """
    abc
    cba
    nba
    """;
  
    // 2.字符串和表达式进行拼接
    var name = "why";
    var age = 19;
    var height = 1.88;
  
    // 强调: ${变量}, 那么{}可以省略
    var message1 = "my name is $name, age is $age, height is $height";
    var message2 = "name is $name, type is ${name.runtimeType}";
    print(message1);
    print(message2);
  }

• 05_集合类型

  main(List<String> args) {
    // 1.列表List: [];
    var names = ["abc", "cba", "nba", "cba"];
    names.add("mba");
  
    // 2.集合Set: {}; 
    var movies = {"星际穿越", "大话西游", "盗梦空间"};
    names = Set<String>.from(names).toList();
    print(names);
  
    // 3.映射Map
    var info = {
      "name": "why",
      "age": 18
    };
  }

1. Dart的函数使用

• 01_函数的基本使用

  main(List<String> args) {
      print(sum(20, 30));
  }
  
  // 返回值的类型是可以省略(开发中不推荐)
  int sum(int num1, int num2) {
    return num1 + num2;
  }
  

• 02_函数的可选参数

  main(List<String> args) {
    sayHello1("why");
  
    sayHello2("why", 18, 1.88);
  
    sayHello3("why", height: 1.88);
  }
  
  // 必选参数: 必须传
  void sayHello1(String name) {
    print(name);
  }
  
  // dart中没有函数的重载
  // 可选参数: 位置可选参数 - 命名可选参数
  // 注意: 只有可选参数才可以有默认值
  // 位置可选参数: [int age, double height]
  // 实参和形参在进行匹配时, 是根据位置的匹配
  void sayHello2(String name, [int age = 10, double height = 2]) {
  
  }
  
  // 命名可选参数
  void sayHello3(String name, {int age = 10, double height = 3.14}) {
  
  }
  

• 03_函数是一等公民

  main(List<String> args) {
    // 1.直接找到另外一个定义的函数传进去
    // test(bar);
  
    // 2.匿名函数 (参数列表) {函数体};
    test(() {
      print("匿名函数被调用");
      return 10;
    });
  
    // 3.箭头函数: 条件, 函数体只有一行代码
    test(() => print("箭头函数被执行")); 
  }
  
  // 函数可以作为另外一个函数的参数
  void test(Function foo) {
    var result = foo();
  }
  
  
  void bar() {
    print("bar函数被调用");
  }
  

• 04_函数是一等公民

  main(List<String> args) {
    // test((abc) {
    //   print(abc);
    // });
  
    test((num1, num2) {
      return num1 + num2;
    });
  
    var demo1 = demo();
    print(demo1(20, 30));
  }
  
  
  // 封装test函数, 要求: 传入一个函数
  // void test(Function foo) {
  //   foo("why");
  // }
  
  typedef Calculate = int Function(int num1, int num2);
  
  // void test(int foo(int num1, int num2)) {
  //   foo(20, 30);
  // }
  
  void test(Calculate calc) {
    calc(20, 30);
  }
  
  Calculate demo() {
    return (num1, num2) {
      return num1 * num2;
    };
  }
  

1.  Dart特殊运算符

• 01_赋值运算符

  main(List<String> args) {
    // 1.??=: 
    // 当原来的变量有值时, 那么??=不执行
    // 原来的变量为null, 那么将值赋值给这个变量
    // var name = null;
    // name ??= "lilei";
    // print(name);
  
    // ??:
    // ??前面的数据有值, 那么就使用??前面的数据
    // ??前面的数据为null, 那么就使用后面的值
    var name = null;
    var temp = name ?? "lilei";
    print(temp);
  }

• 02_级联运算符

  main(List<String> args) {
    // var p = Person();
    // p.name = "why";
    // p.run();
    // p.eat();
  
    // 级联运算符
    var p = Person()
              ..name = "why"
              ..eat()
              ..run();
  }
  
  class Person {
    String name;
  
    void run() {
      print("running");
    }
  
    void eat() {
      print("eating");
    }
  }
  
  

• 03_for循环的使用

  main(List<String> args) {
    // 1.基础for循环
    for (var i = 0; i < 10; i++) {
      print(i);
    }
  
    // 2.遍历数组
    var names = ["why", "cba", "cba"];
    for (var i = 0; i < names.length; i++) {
      print(names[i]);
    }
  
    for (var name in names) {
      print(name);
    }
  }

1. Dart面向对象
    

• 01_类的定义

  main(List<String> args) {
    var p = Person("why", 18);
  }
  
  class Person {
    String name;
    int age;
  
    // Person(String name, int age) {
    //   this.name = name;
    //   this.age = age;
    // }
  
    Person(this.name, this.age);
  }
  
  

• 02_类的构造函数

  main(List<String> args) {
    // 1.创建Person对象
    var p = Person.withNameAgeHeight("why", 18, 1.88);
    // print(p.toString());
  
    var p1 = Person.fromMap({
      "name": "lilei",
      "age": 18,
      "height": 1.88
    });
    print(p1);
  
    // 2.知识点: Object和dynamic的区别
    // 父类应用指向子类对象
    // Object和dynamic
    // Object调用方法时, 编译时会报错
    // dynamic调用方法时, 编译时不报错, 但是运行时会存在安全隐患
  
    // Object obj = "why";
    // print(obj.substring(1));
  
    // 明确声明
    // dynamic obj = 123;
    // print(obj.substring(1));
  }
  
  class Person {
    String name;
    int age;
    double height;
  
    Person(this.name, this.age);
    // Person(this.name, this.age, this.height);
  
    // 命名构造函数
    Person.withNameAgeHeight(this.name, this.age, this.height);
    Person.fromMap(Map<String, dynamic> map) {
      this.name = map["name"];
      this.age = map["age"];
      this.height = map["height"];
    }
  
    @override
    String toString() {
      return "$name $age $height";
    }
  }
  

• 03_类的初始化列表

main(List<String> args) {
  var p = Person("why");
}

class Person {
  final String name;
  final int age;

  Person(this.name, {int age}): this.age = age ?? 10 {
    // this.age = 10;
  }

  // 保留
  // Person(this.name, {this.age = 10});
}

• 04_重定向构造函数

  main(List<String> args) {
    var p = Person("why");
    print(p.age);
  }
  
  
  class Person {
    String name;
    int age;
  
    // Person(this.name): age = 0;
    // 构造函数的重定向
    Person(String name): this._internal(name, 0);
  
    Person._internal(this.name, this.age);
  }

• 05_常量构造函数

  main(List<String> args) {
  
    const p1 = Person("why");
    const p2 = Person("why");
    print(identical(p1, p2));
  
  }
  
  class Person {
    final String name;
    // final String age;
  
    const Person(this.name);
    // const Person(this.name, this.age);
  }

• 06_工厂构造函数

  main(List<String> args) {
    final p1 = Person.withName("why");
    final p2 = Person.withName("why");
    print(identical(p1, p2));
  }
  
  // class Person {
  //   final String name;
  //   final String color = "red";
  
  //   const Person(this.name);
  //   const Person(this.color);
  // }
  
  
  // 普通的构造函数: 会自动返回创建出来的对象, 不能手动的返回
  // 工厂构造函数最大的特点: 可以手动的返回一个对象
  class Person {
    String name;
    String color;
  
    static final Map<String, Person> _nameCache = {};
    static final Map<String, Person> _colorCache = {};
  
    factory Person.withName(String name) {
      if (_nameCache.containsKey(name)) {
        return _nameCache[name];
      } else {
        final p = Person(name, "default");
        _nameCache[name] = p;
        return p;
      }
    }
  
    factory Person.withColor(String color) {
      if (_colorCache.containsKey(color)) {
        return _colorCache[color];
      } else {
        final p = Person("default", color);
        _colorCache[color] = p;
        return p;
      }
    }
  
    Person(this.name, this.color);
  }
  
  

• 07_类的setter和getter

  main(List<String> args) {
    final p = Person();
  
    // 直接访问属性
    p.name = "why";
    print(p.name);
  
    // 通过getter和setter访问
    p.setName = "lilei";
    print(p.getName);
  }
  
  
  class Person {
    String name;
  
    // setter
    set setName(String name) => this.name = name;
    // getter
    String get getName => name;
  }

• 08_类的继承

  main(List<String> args) {
    
  }
  
  class Animal {
    int age;
  
    Animal(this.age);
  }
  
  class Person extends Animal {
    String name;
  
    Person(this.name, int age): super(age);
  }

• 09_抽象类的使用

  main(List<String> args) {
    final s = Shape();
  
    final map = Map();
    print(map.runtimeType);
  }
  
  
  // 注意二: 抽象类不能实例化
  abstract class Shape {
    int getArea();
    String getInfo() {
      return "形状";
    }
  
    factory Shape() {
      return null;
    }
  }
  
  
  // 注意一:继承自抽象类后, 必须实现抽象类的抽象方法
  // class Rectangle extends Shape {
  //   @override
  //   int getArea() {
  //     return 100;
  //   }
  // }
  

• 10_隐式接口

  main(List<String> args) {
    
  }
  
  // Dart中没有哪一个关键字是来定义接口的
  // 没有这些关键字interface/protocol
  // 默认情况下所有的类都是隐式接口
  // Dart支持单继承
  // 当将一个类当做接口使用时, 那么实现这个接口的类, 必须实现这个接口中所有方法
  
  class Runner {
    void running() {
  
    }
  }
  
  
  class Flyer {
    void flying() {
  
    }
  }
  
  class Animal {
    void eating() {
      print("动物次东西");
    }
  
    void running() {
      print("running");
    }
  }
  
  class SuperMan extends Animal implements Runner, Flyer {
    @override
    void eating() {
      super.eating();
    }
  
    @override
    void flying() {
    }
  }
  
  
  
  

• 11_mixin混入的使用

  main(List<String> args) {
    final sm = SuperMan();
    sm.running();
    sm.flying();
  }
  
  mixin Runner {
    void running() {
      print("runner running");
    }
  }
  
  
  mixin Flyer {
    void flying() {
      print("flying");
    }
  }
  
  class Animal {
    void eating() {
      print("动物次东西");
    }
  
    void running() {
      print("animal running");
    }
  }
  
  class SuperMan extends Animal with Runner, Flyer {
    @override
    void eating() {
      super.eating();
    }
  
    void running() {
      print("SuperMan running");
    }
  }
  
  
  

• 12_类属性和类方法

  main(List<String> args) {
    Person.courseTime = "8:00";
    print(Person.courseTime);
  
    Person.gotoCourse();
  }
  
  
  class Person {
    // 成员变量
    String name;
  
    // 静态属性(类属性)
    static String courseTime;
  
    // 对象方法
    void eating() {
      print("eating");
    }
  
    // 静态方法(类方法)
    static void gotoCourse() {
      print("去上课");
    }
  }

• 13_枚举的使用

  // 枚举: enum
  main(List<String> args) {
    final color = Colors.red;
  
    switch (color) {
      case Colors.red:
        print("红色");
        break;
      case Colors.blue:
        print("蓝色");
        break;
      case Colors.green:
        print("绿色");
        break;
    }
  
    print(Colors.values);
    print(Colors.red.index);
  }
  
  enum Colors {
    red,
    blue,
    green
  }
  
  
  
  
  

  1.Dart中库的使用

• 系统库

  // import 'dart:io';
  // import 'dart:isolate';
  // import 'dart:async';
  // import 'dart:math';
  
  // 1.系统的库: import 'dart:库的名字';
  
  import 'dart:math';
  
  main(List<String> args) {
    final num1 = 20;
    final num2 = 30;
    print(min(num1, num2));
  }
  
  

• 自定义库

  /**
   * 1.补充一: as关键字给库起别名
   * 2.补充二: 默认情况下载导入一个库时, 导入这个库中所有的内容
   *    * show: 执行要导入的内容
   *    * hide: 隐藏某个要导入的内容, 导入其它内容
   * 3.公共的dart文件的抽取: export
   * 4.
   */
  
  // import 'utils/math_utils.dart' as mUtils;
  // import "utils/math_utils.dart" show sum, mul;
  // import "utils/math_utils.dart" hide mul;
  // import 'utils/date_utils.dart';
  import "utils/utils.dart";
  
  main(List<String> args) {
    // print(sum(20, 30));
    print(sum(20, 30));
    // print(mul(20, 30));
    print(dateFormat());
  
    min(20, 30);
  }
  
  // void sum(num1, num2) {
  //   print(num1 + num2);
  // }
  

• 第三方库

  import 'package:http/http.dart' as http;
  
  main(List<String> args) async {
    var url = 'http://123.207.32.32:8000/home/multidata';
    var response = await http.get(url);
    print('Response status: ${response.statusCode}');
    print('Response body: ${response.body}');
  }