Flutter Dart语法

中文网

Dart语言
1、强类型语言、静态类型
2、面向对象 oop
3、JIT&AOT
JIT：即时编译，开发期间，更快的编译，更快的重载
AOT：事前编译，release期间，更快更流畅

知识体系：

常用数据类型

• 数字【num int double】
• 字符串 【string】
• 布尔 【bool】
• 集合 【List map】
• var 【任何数据类型 运行时数据类型】
• 类型转换

方法

class FunctionLearn {
  int sum(int a, int b) {
    return a + b;
  }

  // 匿名方法
  anonymousFunction() {
    var list = ['a', 'b'];
    list.forEach((i) {
      print(list.indexOf(i).toString() + ':' + i);
    });
  }
}

class TestFunction {
  void start() {
    FunctionLearn functionLearn = FunctionLearn();
    print(functionLearn.sum(1, 2));
    functionLearn.anonymousFunction();
  }

  // 私有方法
  _learn() {
    print('私有方法');
  }
}

泛型

import 'package:flutter_dart_learn/oop_learn.dart';

class TestGeneric {

  void start() {
    Cache<String> cache1 = Cache();
    cache1.setItem('cache1', '1'); // 类型检查
    var str = cache1.get('cache1');
    print(str);

    Member<Student> member = Member();
    print(member.fixName());
  }
}

/// 泛型
class Cache<T> {

  static final Map<String, Object> _cached = Map();

  void setItem(String key, T value) {
    _cached[key] = value;
  }

  T get(String key) {
    return _cached[key];
  }
}

// 泛型约束
class Member <T extends Person> {
  T _person;

  String fixName() {
    return 'fixname: ${_person.name}';
  }

}

类型

import 'package:flutter/material.dart';

/// 常用数据类型
class DataType extends StatefulWidget {
  @override
  _DataTypeState createState() => _DataTypeState();
}

class _DataTypeState extends State<DataType> {
  @override
  Widget build(BuildContext context) {
    _numType();
    _stringType();
    _boolType();
    _listType();
    _mapType();
    _tips();
    return Container(child: Text("查看控制台"),);
  }

  void _numType() {
    num num1 = -0.1;
    num num2 = 1;

    int int1 = 1;
    double d1 = 1.98;

    print("num:$num1 num:$num2 int:$int1 double:$d1");
    print(num1.abs());
    print(num1.toInt());
  }

  void _stringType() {
    String str1 = "字符串1", str2 = "字符串2";
    String str3 = "str1:$str1 str2:$str2";
    String str4 = 'str1' + str1 + 'str2' + str2;
    print('str1 : $str1' + str2 + " " + str3 + ' ' + str4);
  }

  void _boolType() {
    bool success = true, fail = false;
    print(success);
    print(fail);
  }

  void _listType() {
    List list = [1, 2, 3, '集合'];
    print(list);
    List<int> list1 = [1, 2, 3];
    List<int> list2 = [];
    list2 = list; /// 报错 非泛型不是泛型子类

    list.add('2');
    list.addAll(list1);

    List list4 = List.generate(3, (index) => index * 2);
    print(list4);

    /// 遍历
    for (int i = 0; i < list4.length; i++) {
      print(list4[i]);
    }

    for (var o in list4) {
      print(o);
    }

    list4.forEach((value) {
      print(value);
    });
  }

  void _mapType() {
    Map map = {'1':'a', '2':'b'};
    Map ages = {};
    ages['1'] = '22';

    /// 遍历
    ages.forEach((k, v) {
      print('$k, $v');
    });

    Map ages2 = ages.map((k, v) {
      return MapEntry(v, k);
    });

    print(ages);
    print(ages2);

    for (var k in ages.keys) {
      print('$k, ${ages[k]}');
    }

  }

  /// dynamic var object

  void _tips() {
    /// dynamic 动态数据类型
    dynamic x = 'hallo';
    print(x.runtimeType); // String
    print(x); // hallo

    x = 123;
    print(x.runtimeType); // int
    print(x); // 123

    /// var 关键字
    var y = 'hallo';
    print(y.runtimeType); // String
    print(y); // hallo

    /// object dart基类
    Object o1 = 'hello';
    print(o1.runtimeType); // String
    print(o1); // hello
  }
}

面向对象

class Person {

  String name;
  int age;
  Person(this.name, this.age);

  /// 多态 重写父类方法
  @override
  String toString() {
    return 'Person{name: $name, age: $age}';
  }


}

class Student extends Person {
  String _school; /// 下划线标记私有变量
  final String city; // 可选参数
  String country; // 默认参数
  String name;
  Student(this._school, String name, int age, {this.city, this.country='China'})
      : name='$country.$city',
        super(name, age){
      print('构造方法体不是必须的');
  }

  /// 命名构造方法
  Student.cover(Student stu, this.city) : super(stu.name, stu.age) {
    print('命名构造方法');
  }

  /// 命名工厂构造方法
  factory Student.stu(Student student) {
    return Student(student._school, student.name, student.age);
  }

  // get set
  // ignore: unnecessary_getters_setters
  String get school => _school;
  // ignore: unnecessary_getters_setters
  set school(String value) {
    _school = value;
  }

  // 静态方法
  static doPrint(String str) {
    print('do pring: $str');
  }
}

/// 工厂构造方法 单例
class Logger {
  static Logger _cache;

  factory Logger() {
    if (_cache == null) {
      _cache = Logger._internal();
    }
    return _cache;
  }

  Logger._internal();

  void logs(String msg) {
    print(msg);
  }
}

abstract class Study {

  void study();
}

class StudyFlutter extends Study {

  @override
  void study() {
    // TODO: implement study
  }

}

/// mixins 多个类层次结构中重用代码的一种方法 with 不是多继承

// ignore: camel_case_types
class roger extends Person with Study {
  roger(String name, int age) : super(name, age);
  @override
  void study() {
    // TODO: implement study
  }
}

技巧

/// 封装 继承 多态
/// 一个方法小于100行

void main() {
  /// 安全调用
  ///
  List list;
  print(list?.length);

  print(list?.length ?? 0);

  if ([null, 0, ''].contains(list[0])) {}
}