Dart学习笔记

叁歲伎倆 2023-02-16 12:07 5阅读 0赞

### Dart学习笔记 ###

*   *  变量定义
     *  final与const
     *  数组类型
     *  Map类型
     *  函数定义
     *  入口函数
     *  类与构造函数
     *  抽象类
     *  继承与实现
     *  mixin继承
     *  泛型
     *  类型转化与类型判断
     *  异常处理

## 变量定义 ##

Dart中，不像其他语言存在基本类型与类类型，Dart中所有类型（包括int等）都是继承自Object的类型  
字符串字符为UTF16编码，小数都为double类型，函数类型为Function，布尔类型为bool

*  type variable = val  
    在定义时指定固定类型type，则该变量类型固定，且只能接收特定类型赋值  
    比较特殊的，如果type是Object或者dynamic，则该变量可以接收任意类型数值赋值，比如
    
        int age = 22
        dynamic magic = 1;
        magic = "text";	//OK
        Object obj = 2.0;
        obj = true;	//OK
 *  var variable = val  
    Dart支持类型推断，如果使用关键字var定义变量，则会推断为赋值的数值类型，比如
    
        var age = 22;	//int 类型
 *  变量如果没有初始化，默认值为null(即便是基本类型)，比如
    
        int value1;
        print("value1 = $value1");	//内置的print函数执行格式化输出，通过$变量名输出对象
        //output:	value1 = null

## final与const ##

final表示运行期常量，在运行时初始化。  
const表示编译器常量，在编译前必须指定好初始值。  
final修饰的变量只允许被赋值一次，const修饰的变量必须在初始化时赋值，且也不能再次赋值，比如

const a = 1;	//自动类型推断
    final b = new DateTime.now();	//自动类型推断
    const int c = 2;
    final String d = "yyt";

## 数组类型 ##

Dart使用List定义数组，可以指定数组元素泛型，不指定默认为Object  
List可以在定义时初始化，则长度为初始化元素集合长度，也可以通过构造函数指定  
通过下标可以直接访问元素，通过add方法在末尾新增元素  
通过\[\]运算，可以得到一个动态修改长度的List，通过length 属性可以修改长度，比如

List<String> names = ["aaa","bbb"];	//capacity is 2
    List list = List(5);	//capacity is 5	
    list.add(1);
    list[0] = 2;
    List dynamicList = [];	//capacity is dynamic
    dynamicList.length = 5;// now capacity is 5

## Map类型 ##

Dart通过Map定义键值对，键值对采用键型下标访问元素  
与List相同Map也可以指定泛型，不指定为<Object,Object>，比如

Map map = {
    "name": "yyt",
    "age": 22,
    3:"text"
    };
    map[3] = 5;
    Map<String,String> strs = {
    	"a" : "a"
    };

## 函数定义 ##

Dart的函数定义语法为 returnType name (varible…)，比较独特的为形参的两种定义方式，以及Dart允许将函数作为形参（函数类型为Function）

*  可选参数  
    returnType name (\{type1 variable1 , type2 variable2\})\{\}  
    通过一个\{\}将多个形参定义包围，代表所有参数都为可选参数，没传递的参数默认为null  
    此种类型定义在调用时传递参数需要指定入参的变量名，入参与形参对应关系和位置无关，比如
    
        // 函数定义
        void show({var name, var age}) {
         if(name != null) {
           print("name = $name");
         }
         if(age != null) {
           print("age = $age");
         }
        }
        // 函数调用
        show(name: "yyt");
        // 输出结果
        name = yyt
 *  位置参数  
    returnType name (type1 variable1 , \[type2 variable2\])\{\}  
    位置参数语法与普通语言差别不大，如果某些形参是可选形参，则必须使用\[\]包含，同时理所应当的，必传参数需要放在所有可选参数之前，比如
    
        // 函数定义
        void show(var name, [Function f]) {
         print("name = $name");
         if(f != null) {
           f();
         }
        }
        // 函数调用
        show("yyt");
        // 输出结果
        name = yyt
 *  嵌套函数  
    Dart支持在函数内部定义函数，比如
    
        void f1(){
        	void f2(){}
        	f2();
        }

## 入口函数 ##

与其他语言相同，Dart使用main函数作为入口函数

void main(){}

## 类与构造函数 ##

Dart的类可以被继承(extends)，也可以被实现(implements)  
Dart也提供复杂结构类型的定义语法，通过class关键字  
类中成员定义语法为 \[static\] type variable，被static修饰成员代表静态成员，是共享变量  
类除了可以使用默认的同名无返回值函数作为构造函数，还可以定义 类名.xyzxxx格式的无返回值函数作为构造函数，比如

class A {
    	static int a = 1;
    	int b = 2;
    	A(int b){
    		this.b = b;
    	}
    	A.b(this.b);	//简略写法，功能等价于入参赋值给成员b
    }
    A a = A(1);
    A a = A.b(2);

## 抽象类 ##

Dart中使用abstract class定义抽象类  
抽象类中可以定义没有方法体的抽象方法  
抽象类不能被实例化

abstract class Study {
      void study();
    }

## 继承与实现 ##

抽象类与类都可以被作为接口进行实现，当一个类被用来实现，其成员仅结构起作用，而方法实现都无关系（因为实现类不能复用代码，必须重新实现该成员结构）  
一个类 / 抽象类可以实现多个抽象类，但是只能继承一个类 / 抽象类  
Dart中通过extends关键字进行继承，Dart允许通过mixin实现伪多继承

*  继承构造  
    子类构造函数默认继承父类构造函数（隐式调用）  
    通过在子类构造函数形参列表后使用:可以修改要使用的父类构造函数，比如
    
        class A {
        	int b = 2;
        	A (int b) {
        		this.b = b;
        	}
        	A.b(this.b);	
        }
        class SubA {
        	SubA(int b) : super.b(b) {
        	}
        }
 *  继承与实现  
    继承一个类 / 抽象类，则会自动继承其所有结构（代码复用）。  
    而实现一个 类 / 抽象类 ，代码不会复用，需要在实现类中编写满足被实现 类/抽象类 所有成员的成员结构进行实现，比如
    
        // 父类1
        class SupperClass1{
            void say(){
            }
        }
        // 子类1通过extends 继承父类1的方法
        class SubClass1 extends SupperClass1{
        }
        SubClass1 s1 = SubClass1();
        s1.say();	//OK , extends
        
        // 父类2
        class SupperClass2{
            void say(){
            }
        }
        // 子类2通过implements 实现父类2，要满足父类2的规范
        class SubClass2 implements SupperClass2{
           @override
        	void say(){
        	//必须创建say方法
            }
        }
        SubClass2 s2 = SubClass2();
        s2.say();	//OK , implements

## mixin继承 ##

Dart提出mixin多继承，通过with关键字关联多个类 / 抽象类 进行mixin继承  
mixin继承解决多继承同名同类型成员冲突的规则是，如果当前类中，包含该同名同类型成员，则使用当前类成员，否则使用离with关键字最优、实现了该同名同类型成员的类中的成员，比如

class A {
    	void say(){}
    }
    abstract class B {
    	void say();
    }
    class C with A,B{
    }
    class D with A,B,C{
    	void say(){}
    }
    
    C c = C();
    c.say();	//use say function in B
    D d = D();
    d.say();	//use say function in D

## 泛型 ##

Dart也支持类似于java的类泛型和方法泛型，比如  
tips：方法泛型的作用就是为了在调用指定方法时传递，覆盖类泛型

class A<T>{
    	T val;
    	void f<K,T>(K k,T t){
    	}
    }

## 类型转化与类型判断 ##

Dart使用as进行对象的强制类型转化，失败会抛出异常  
Dart使用is进行对象的类型判断，返回布尔类型数值，比如

class A{}
    class B{
    	int age;
    }
    A a = A();
    bool val = (a is B);
    (a as B).age = 5;	//error

## 异常处理 ##

Dart支持类似java的异常处理机制(try-catch-finally)  
finally可以没有，即便在try或者catch中调用return，finally也会在方法返回前执行

void doSth() => throw Exception("error!");
    try {
      doSth();
    } on Exception catch(e) {
      print(e);
    } finally { 
      print("finally");
    }

更多文章，请搜索公众号歪歪梯Club  
![更多资料，请搜索公众号歪歪梯Club][Club]

[Club]: https://img-blog.csdnimg.cn/20200521183346518.jpg