Flutter学习基础之Dart初探一、常量const和finalconst：一开始就得赋值final：可以开始不赋值共

一、常量

const和final
- const：一开始就得赋值
- final：可以开始不赋值

共同点：都是只能赋一次值

二、类型

注意：Dart是强类型脚本语言，没有===，其中的==需要判断类型是否一致

常用数据类型：

Number（数值）
- int
- double（整型，浮点型）
Strings（字符串）
- String
Booleans（布尔）
- bool
List（数组）
- 在Dart中，数组为列比对象，通常称为列表
Maps（字典）
- 与js中的Map类型对象一致，键值对相关的对象，可为任何类型

String中用$a的形式使用变量

String字符串中有三个单引号/双引号，表示多行字符串

Maps对象中用[]获取属性值

判断类型： is关键词

let str = 'this';
str is String

（2.1）类型转换

Number转String，toString()
String转Number
- int.parse() //浮点型会报错
- double.parse()

判断是否为空： str.isEmpty

判断是否为NaN：num.isNaN

三、运算符

基本与其他语言一致

特殊：

~/ 取整

??运算符：当变量为null，undefined值赋予默认值

四、数组常用属性与方法

常用属性：
- length 长度
- reversed 翻转返回类似python元组（需要toList()）
- isEmpty 是否为空
- isNotEmpty 是否不为空
常用方法：
- add(value) 增加
- addAll(list) 拼接数组
- indexOf(value) 查找
- remove(value) 删除
- removeAt(index) 删除
- fillRange(startIndex,endIndex,newValue) 修改，类似splice
- insert(index,value) 插入一个
- insertAll(index,list) 插入多个
- toList() 转换成list类型
- join(str) 合并，返回字符串
- split(str) 切割，返回数组
- forEach
- map
- where 类似filter
- any 类似some
- every

new Set()：去重之后的数组

五、映射（Maps）是无序的键值对

常用属性：
- keys 获取所有keys值
- values 获取所有values值
- isEmpty 是否来空
- isNotEmpty 是否不为空
常用方法：
- remove(key) 删除指定key的数据
- addAll({...}) 合并映射给映射内增加属性
- containsValue 查看是否包含映射内的值value 返回true/false
- forEach
- where
- any
- every

六、方法定义

方法名前的类型表示返回值的类型，void表示任何类型

//void：没有返回值，int n：传入参数必须要int
//参数，[]：可选参数
// 可使用=，加入默认参数
// {}：命名参数
void func(int n,[String str,bool status]){}

七、类

（7.1）类的基本写法与构造函数，普通函数的调用

关键字：class

class Person{
    String name;
    int age;
    //Person(this.name,this.age);  //简写
    //构造函数，实例化对象时调用
    Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    Person.showMsg(){
        print('命名构造函数');
    }
    //重定向构造函数，this(name,age);
    //作用：声明完之后，调用其他构造函数
    Person.user(name,age):this(name,age);
    
    //常量构造函数,并且声明所有类的变量为final
    const Person(this.name,this.age);
    
    //通过实例化对象调用
    void printInfo(){
        print('类内部普通函数');
    }
} 
vaid main(){
    Person p1 = new Person('张三',20);
    
    //调用命名构造函数
    Person p2 = new Person.showMsg();
        
    //调用普通函数
    p1.printInfo();
}

（7.2）私有属性

没有其他OOP语言的的public,private,protected修饰符

使用 _ 定义私有属性，私有方法，前提：类必须在单独抽离一个文件

class Animal{
    String _name; //私有属性
    void _privateFun(){
        print('私有')
    }
    //可通过间接调用私有属性，方法
    getPrivate(){
        print(this._name);
        this._privateFun();
    }
}

（7.3）set，get方法

get方法通过读取属性的形式调用

class Rect{
    num height;
    num width;
    Rect(this.height,this.width);
    //实例化前做操作
    //Rect():height=10,width=2{}
    get area{
        return this.height * this.width;
    }
    set areaHeight(int value){
        this.height = value;
    }
}
main(){
    Rect r = new Rect(10,2);
    r.areaHeight = 4;
    print(r.area); // 40
}

八、静态成员类的继承

静态成员关键字：static
规则:
- 静态方法内不能访问非静态成员，但可以访问静态成员
- 非静态方法都能访问
继承关键字：extends
- 子类能访问父类的成员，除了构造函数
- 使用super调用父类构造函数，并传参
- 覆写需＋@override
- super.fun()调用父类方法，this.name调用父类的属性

注意：无法实现多继承，但可以使用mixins实现类似多继承

class Fater{
    //static String name; //静态属性
    String name;
    int age;
    Fater(this.name,this.age);
    printInfo(){
        print('输出');
    };
}
class Son extends Father{
    String sex;
    Son(String name,int age,String sex):super(name,age){
        this.sex = sex;
    };
    //覆写父类的方法
    @override
    printInfo(){
        print('子类输出');
    }
    printSonMsg(){
        print(this.name);
        super.printInfo();
    }
}

九、抽象类，多态，接口

（9.1）抽象类

抽象类是主要用于定义标准，子类继承抽象类，也可以实现抽象类

抽象类关键字：abstract

规则：
- Dart抽象类不能用abstract声明，Dart中没有方法体的方法即是抽象类
- 子类继承抽象类，必须实现里面的抽象方法（覆写需+@override）
- 抽象类无法直接被实例化
- 抽象类可以定义抽象方法，普通类不行

//抽象类
abstract class Person(){
    eat(); //抽象方法
}

（9.2）多态

规则：
- 子类的实例赋值给父类的引用
- 父类定义一个方法不去实现，让继承它的子类实现，每个子类有不同的表现

十、接口

接口：没有公共方法的抽象类

定义接口的关键字：没有

实现的接口关键字：implements

实现接口的类，规则：
- 必须实现接口的属性和方法
- 如果需要方法需要传值，接口中也需要规定传值

一个类实现多个接口

class A{String name;printA();}
class B{printB();}
class C implements A,B{
    @override
    String name;
    
    @override
    printA(){};
    
    @override
    printB(){};
}

（9.4） extends抽象类与implements的区别

extends：复用抽象类的方法（公共方法），并且要用抽象方法约束自类
implements：抽象类当作标准（没有公共方法）

十一、mixins

实现类似多继承的功能

mixins关键词：with

Dart2.x中的条件：

mixins的类只能继承自Object，不能继承其他类
mixins的类不能有构造函数
一个类可以mixins多个mixins类
mixins绝不是继承，，也不是接口，是一种全新的特性

class A { void printA(){print("A")};}
class B { void printB(){print("B")};}
class C with A,B{} //拥有A,B的方法与属性（其中A，B类为mixins的类）

class D {
    String name;
    D(this.name);
    void printD(){
        print("D");
    }
}
//如果需要继承有构造函数的类，通过extends实现
class E extends D with A,B{
    E(String name,int age):super(name);
}

mixins的实例类型是其超类的子类型(此处的D,A,B都是)

十二、泛型

作用：解决类接口方法的复用性，对不特定数据类型的支持（类型校验）

泛型方法

T getData<T>(T value){
    return value;
}
main(){
    getData<String>('aaa'); //<String>规定传入String类型参数
}

对不特定数据类型的支持

List list = new List<int>();
//list.add("123"); //报错
list.add(123);

泛型类（接口类似）

class PrintClass<T>{
    List list = new List<T>();
    void add(T value){
        this.list.add(value);
    }
}
main(){
    PrintClass p = new PrintClass(); //没有对类型进行校验，可以操作任何类型
    PrintClass p = new PrintClass<String>(); //只能操作String类型数据
}

十三、库

自定义库
- import 'lib/xxx.dart';
系统内置库
- import 'dart:math'; （类似Math，可以直接使用min(a,b),max(a,b)）
- import 'dart:io'; （类似原生xhr）
- import 'dart:convert'; （解码）
第三方库（Pub包管理系统中的库）
- 包管理库的网站
- 项目根目录建pubspec.yaml
- 文件中配置名称，描述，依赖等
- 运行pub get获取包下载到本地
- 引入库 import 'port:...' as http;使用
- 【shift】+用右键 => 打开目标目录命令窗口

import 'dart:io';
import 'dart:convert';
void main() async{
    var result = await getDataFromApi();
    print(result);
    
    getDataFromApi() async{
        //1.创建HttpClient对象
        var httpClient = new HttpClient();
        //2.创建Uri对象
        var uri = new Uri.http('这里填api接口');
        //3.发起请求，等待请求
        var request = await httpClient.getUrl(uri);
        //4.关闭请求，等待响应
        var response = await request.close();
        //5.解码响应内容
        return await response.transform(utf8.decoder).join(); //使用到convert库
    }
}

async和await

套娃式写法

- async让方法变成异步，await等待异步方法执行完成

- 只有async方法才能使用await调用方法
- 如果调用别的async方法必须使用await关键字

十四、库重命名,部分引入

重命名关键字：as

import 'lib/Person1.dart'
import 'lib/Person2.dart' as lib;
main(List<String> args){
    Person p1 = new Person("张三",21);
    lib.Person p2 = new lib.Person("张三",21);
}

部分引入关键字
- 导入需要的部分：show
- 隐藏不需要的部分：hide

十五、延迟加载

也称懒加载，减少App的启动时间

懒加载关键字：deferred as

import 'package:deferred/hello.dart' deferred as hello;

当需要要使用的时候，需要是使用loadLibrary()来加载

greet() async{
    await hello.loadLibrary();
    hello.printGreeting();
}

Flutter学习基础之Dart初探