Flutter从入门到实战
一共分为23个系列
①(Flutter、Dart环境搭建篇) 共3个内容 已更新
②(Dart语法1 篇) 共4个内容 已更新
③(Dart语法2 篇) 共2个内容 已更新
④(Flutter案例开发篇) 共4个内容 已更新
⑤(Flutter的StatelessWidget 共3个内容 已更新
⑥(Flutter的基础Widget篇) 共2个内容 已更新
⑦(布局Widget篇) 共1个内容 已更新
⑧(Flex、Row、Column以及Flexible、Stack篇) 共1个内容 已更新
⑨(滚动的Widget篇) 共4个内容 已更新
⑩(Dart的Future和网络篇) 共3个内容 已更新
⑪(豆瓣案例-1篇) 共3个内容 已更新
⑫(豆瓣案例-2篇) 共3个内容 已更新

官方文档说明

官方视频教程
Flutter的YouTube视频教程-小部件

①、Dart的面向对象

1.重定向构造函数

// 使用构造函数的重定向
  var p = Person("yh");
  print(p.age);

class Person {
  String name;
  int age = 199;
  // 构造函数 并且给age默认值
  // Person(this.name) : age = 10;

  // 构造函数的重定向
  Person(String name) : this._inernal(name, 20);
  Person._inernal(this.name, this.age);
}

2.常量构造函数

基本上只会写一个常量构造函数
因为函数不支持函数重载

使用 const 定义的函数
通过常量构造函数创建出来的对象是相同的

// 使用常量构造函数
  const p1 = Person("yh");
  const p2 = Person("yh");
  const p3 = Person("ys");
  print(identical(p1, p2)); // true
  print(identical(p1, p3)); // flase 


class Person {
    
    
  final String name;
  // final String age;

// 常量构造函数
  const Person(this.name);
  // const Person(this.name,this.age); // 不支持函数重载

}

3.工厂构造函数

工厂构造函数 需要(可以)手动返回一个对象
为什么要什么工厂构造函数 。 因为类无法重载两个构造函数。但是需要满足这个需求就需要到工厂构造函数

3.1 为什么要使用工厂构造函数

因为类无法重载两个构造函数。但是需要满足这个需求就需要到工厂构造函数

class Person {
    
    
  final String name;
  final String color = "red";

// 无法重载两个构造函数 满足不了需求 只能使用工厂构造函数
  const Person(this.name);
  const Person(this.color);

}

3.2工厂构造函数的使用

// 使用工厂构造函数 判断2个对象是否为同一个对象
  final p1 = Person.withName("yh");
  final p2 = Person.withName("yh");
  print(identical(p1, p


class Person {
    
    
  String name = "";
  String color = "";
  // static 静态 Map 映射
  static final Map<String, Person> _nameCache = {
    
    };
  static final Map<String, Person> _colorCache = {
    
    };

// 普通的构造函数:会自动返回创建出来的对象,不能手动的返回
// 工厂构造函数 最大的特点: 可以手动的返回一个对象
 // 这个其实是一个缓存机制。多占内存Map。
 // 减少创建对象和销毁的过程

  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);
}

4.类的setter和getter

setter 和 getter的作用
设置 和 获取

  var p = Person();
  // 直接访问属性
  p.name = "宇夜iOS";
  print(p.name);
  
// ✨ setter 和 getter的使用
  // 通过getter和setter访问
  p.setName = "宇夜iOS-1";
  print(p.getName);

// 人类
Person {
    
    
  String name = "";

  // setter
  // set setName(String name) {
    
    
  //   this.name = name;
  // }

  // // getter
  // String get getName {
    
    
  //   return name;
  // }

// 箭头函数的 setter 和 getter
  set setName(String name) => this.name = name;
  String get getName => name;
}

5.类的继承

继承使用关键字 extends

class Animal {
    
    
  int age;
  Animal(this.age);
}

class Person extends Animal {
    
    
  String name;
  // 初始化列表
  Person(this.name, int age) : super(age);
}

6.抽象类的使用

1. 抽象类使用 关键字 abstract
2. 抽象类 可以没有方法实现\也可以有方法实现
3. 继承于抽象类的类 必须实现抽象类的方法
4. 抽象类不能实例化

// 第1、2、4点
//  Shape 是一个抽象类
// 可以没有方法实现\也可以有方法实现
abstract class Shape {
    
    
  int getArea();
  String getInfo() {
    
    
    return "形状";
  }
  // 4.抽象类不能实例化
  // factory Shape() {
    
    
  //   return null;
  // }
 }
 
// 第3点
// 继承 Shape的抽象类 的类
// 必须重写抽象类的方法
class Recatangle extends Shape {
    
    
  // 重写
  @override
  int getArea() {
    
    
    return 100;
  }
}

6.系统的抽象类

Map 和 List 抽象类 为什么能实例化
因为 通过工厂构造函数进行实例化
它们有实现吗？ 没有 因为使用了external关键字

1. external关键字的作用是 : 将方法的声明和方法的实现分离
2. 方法的实现 通过一个注解 @patch 去实现
3. 具体的实现要去看系统的源码了
4. Map的实现源码在
   4.1 具体看flutter的源码. 在 /Users/liyuhong/development/flutter/bin/cache/dart-sdk/lib/collection 这个就是集合类的源码 linked_hash_map.dart
   4.2 通过 LinkedHashMap<K, V>() 进行初始化 最终的实现在 > linked_hash_map.dart 里面实现
   最终的代码实现

     external factory LinkedHashMap(
    {
          
          bool Function(K, K)? equals,
    int Function(K)? hashCode,
    bool Function(dynamic)? isValidKey});
   

   4.3 也可以通过打印runtimeType的真实类型
   print(map.runtimeType); // _InternalLinkedHashMap<dynamic, dynamic>

// 抽象类 通过工厂构造函数进行实例化
final map = Map();

7.隐式接口

Dart 中没有哪一个关键字是来定义接口的
没有这些关键字 interface / protocol
默认情况下 所有的类都是隐式接口
Dart支持单继承
当一个类当做接口使用时,那么实现这个接口的类,必须实现这个类中所有的方法

class Runner {
    
    
  void running() {
    
    }
}

class Flyer {
    
    
  void flying() {
    
    }
}

class Animal {
    
    
  void eating() {
    
    
    print("动物吃东西");
  }

  void running() {
    
    
    print("running");
  }
}

// implements 相当于superMan  要去实现 Runner、Flyer两个类的方法
class superMan extends Animal implements Runner, Flyer {
    
    
  @override
  void edting() {
    
    
    super.eating();
  }

  @override
  void flying() {
    
    }
}

8.mixin混入的使用

当一个类当做接口使用时,那么实现这个接口的类,不必实现这个类中所有的方法

// 混入的使用

  final sm = superMan();
  sm.running();
  sm.flying();
  // 输出superMan running、Flyer flying

mixin Runner {
    
    
  void running() {
    
    
    print("Runner running");
  }
}

mixin Flyer {
    
    
  void flying() {
    
    
    print("Flyer flying");
  }
}

class Animal {
    
    
  void eating() {
    
    
    print("Animal 动物吃东西");
  }

  void running() {
    
    
    print("Animal running");
  }
}

//  混入的写法: 1.定义可混入的类时,不能用class, mixin
// 2.with进行混入
class superMan extends Animal with Runner, Flyer {
    
    
  @override
  void edting() {
    
    
    super.eating();
  }

  void running() {
    
    
    print("superMan running");
  }
}

9.类属性和类方法

// 使用
  Person.courseTime = "9:00"; //   设置类属性
  print(Person.courseTime); // 访问类属性
  Person.gotoCourse();	 // 调用类方法
  ;

class Person {
    
    
  // 成员变量
  String name = "";

  // 静态属性(类属性)
  static String courseTime = "";

  // 对象方法
  void eating() {
    
    
    print("eating");
  }

  // 静态方法(类方法)
  static void gotoCourse() {
    
    
    print("去上课");
  }
}

10.枚举的使用

枚举使用关键字 enum

// 使用枚举 
  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 }

②、Dart 库的使用

1. 使用系统的库

使用 import 关键字导入系统库

// import 'dart:io'; // 文件操作
// import 'dart:isolate'; // 创建线程
// import 'dart:async'; // 异步
import 'dart:math'; // 数学

2. 使用自定义的库

先定义一些库
比如算数的加减、打印一个日期的库

math_utils.dart 计算两个数的加法、乘法、对比两个数

int sum(num1, num2) {
    
    
  return num1 + num2;
}

int mul(num1, num2) {
    
    
  return num1 * num2;
}

int min(int num1, int num2) {
    
    
  return num1 > num2 ? num1 : num2;
}

date_utils.dart 返回一个日期字符串

String dateFormat() {
    
    
  return "2020-12-12";
}

2.1 导入自定义库 并且使用

import ‘utils/utils.dart’; // 其中utils是一个文件夹

import 'utils/utils.dart';

void main(List<String> args) {
    
    
  print(sum(20, 30));
  print(mul(20, 30));

  print(dateFormat());
  print(min(20, 30));
}

2.2 多库的引入

定义一个库文件 把所有的自定义库引入进来

utils.dart

// 多个库的导入
export 'math_utils.dart';
export 'date_utils.dart';

2使用自定义库的效果图

3.使用第三方库

通过 pub.dev网站查找第三方库
并且创建一个 pubspec.yaml文件
并且设置几个参数

1. name: xxx 我这里填写我的名字 yhios
2. descreption: xxx 这里填写描述 a dart library
3. dependencies: xxx 这里填写 第三方库的安装指令 -- http: ^0.13.4
   然后去 pub.dev 去查找库
   填写pubspec.yaml参数 并且安装第三方库

3.1 填写 pubspec.yaml文件的第三方库信息

name: yhios
descreption: a dart library
dependencies: 
  http: ^0.13.4

3.2 终端进行安装第三方库的指令

pub get 
或者
dart get

小贴士

拷贝一份相同的代码 快捷键 shift + option + ↓