Dart基础

2020-05-26 本文已影响0人 LuckySunSet

内建类型

Number--包含了int 和 double
String
Boolean
List (也被称为 Array)
Map
Set
Rune (用于在字符串中表示 Unicode 字符)
Symbol

变量

1、使用var关键字声明变量

var a = "1111";
print(a.runtimeType)//打印类型
a = 1111;//将num类型赋值给a，编译不通过

输出

String

2、指定类型声明变量，即显式声明

String a = "1111";
a = 1111;//将num类型赋值给a，编译不通过

3、使用任何类的基类Object声明变量，包括Null 和 Founction

Object d = "11111";
print(d.runtimeType);
d = 1111;//更改变量 d 的类型
print(d.runtimeType);

输出

String
int

4、使用 dynamic 声明变量

dynamic a = "1111";
print(a.runtimeType);
a = 1111;
print(a.runtimeType);

输出

String
int

=> var 声明变量时一旦赋值，类型将无法改变

Q：Object和dynamic的区别是什么？

A：dynamic的类型是在变的，Object就是一个Object类型，比如：

Object a = 1;
a = a + 2;//无法通过编译

dynamic a = 1;
a = a + 2;//编译通过，

看下面特殊情形

var a; //声明变量a,但是并未赋值
print(a.runtimeType);
a = 111;
print(a.runtimeType);
a = "111"; //这行代码为什么能够编译通过呢？
print(a.runtimeType);

输出

Null
int
String

这里为什么a="111"不会报错呢？

=>A：这里用var 声明变量a，没有进行赋值操作，不能确定a的类型，所以编译器认为他是动态的dynamic

访问属性

公开的和私有的，前面下划线表示私有的

var _name = "xiaobao";//私有的
var age = 18;//公开

常量

使用过程中从来不会被修改的变量

void main() {
  const a = 1111;
  a = 222; //无法编译通过
  final b = 1111;
  b = 2222; //无法编译通过
  
  const aa1 = AA(); //无法编译通过
  final aa2 = AA();
}

//自定义类
class AA {}

final 只能被设置一次

const 在编译时已经确定值

一般使用场景是：

const可以用于定义编译之前就已经确定的值，比如PI=3.141592654

final可以用于需要运行代码之后才赋值的操作

函数

构造函数的写法

class Animal {
  String name;
  int age;
  //写法1
  Animal(name, age) {
    this.name = name;
    this.age = age;
  }
}

class Animal {
  String name;
  int age;
  //写法2
  Animal(this.name, this.age);
}
//这里的this.name 相当于在函数体中进行赋值操作，这个也适用于一般的函数
//注意，写法1和写法2 构造函数只能存在一种，无法同时声明两个

class Animal {
  String name;
  int age;
  //写法3
  Animal.noAge(this.name);
  Animal.noName(int age){
    this.age=age;
  }
}
//通过 类名.函数名 来进行声明构造函数，可以声明多个构造函数

非构造函数

函数可以作为参数传递给其他函数，函数可以赋值给变量

void main() {
  var func = getAge;
  print(func.runtimeType);
  print(func.call());
}

int getAge() {
  return 11;
}

输出

() => int
11

函数的参数

可选命名参数---Flutter中的Widgets大多数都是可选参数

//可选参数定义,大括号括起来，可选参数和位置无关
setPlay(String withWho,{int playHour, String gameName}) {
  //...
}
//可选参数的使用--可选参数必须带上参数名，比如这里的playHour或者gameName
setPlay("小花",playHour:2,gameName:"躲猫猫");
setPlay("小花",gameName:"躲猫猫",playHour:2);//这里的gameName和playHour位置可以互换
setPlay("小花",gameName:"躲猫猫");
setPlay("小花");

必传参数

//必传参数是基于可选参数做的限制   用 @required 修饰参数
setPlay(String withWho,{int playHour, @required String gameName}) {
}
setPlay("小花",playHour:2,gameName:"躲猫猫");
setPlay("小花",gameName:"躲猫猫");
setPlay("小花");//这行代码无法编译通过，因为gameName是必传的参数

=>一般对于参数较多的情况，都会用可选参数大括号进行包裹，然后再对必传的参数加@required修饰，提高可读性

可选位置参数-->将参数放到 [] 中来标记参数是可选的：

//声明
void play(String name, [String address, int age]) {
}
//使用
play("小花","杭州",12);
play("小花","杭州");
play("小花",12);//无法编译不通过

=>位置参数[ ]，按照位置，前面的一个参数必须设置了值，不能指定参数名

函数扩展extension

extension String2Number on String {
  int toInt() {
    return int.parse("111");
  }
}
//使用
"111".toInt();

继承-extends，接口实现-implements，混入-mixin

如果同时使用了继承，混入和接口实现，并且方法一致，优先级

self>mixin>extends>implement

Future 类似于前端的Promise

getUserInfo().then((value)=>{
    //成功
}).catchError((error)=>{
  //失败
}).whenComplete(()=>{
  //结束
})

Future<String> getUserInfo() async{
    return "aaaa";
}