声明：该文章为学习笔记,部分例子值是为了展示dart语法,没有实际意义，只是初步对dart有一个认识，为Flutter打基础。
一、环境搭建
官网：https://www.dartlang.org
具体请教谷歌或度娘
二、数据类型
2.1、变量和常量
使用关键字var声明变量,关键字const声明常量1
2
3
4
5
6
7
8
9
10
11
12
13main(List<String> args) {
var length = 100;
print(length);/// 输出100
length = 50;
print(length);/// 输出50
const size = 10;
print(size);/// 输出510
size = 20;/// 编译器报错 常量值不可修改
}
2.2、数值型(num)int整型
整数型，值通常位于-263~263之间double浮点型1
2
3
4
5
6
7
8
9
10void main(List<String> args) {
int age = 100;
print("age:$age");///age:100
num height = 120;
print("height:$height");///height:120
num money = 100.00;
print("money:$money");///money:100.0
}
简单的运算1
2
3
4
5
6
7
8
9///一些简单的运算
int x = 10;
int y = 3;
print("x + y = ${x + y}");///加 13
print("x - y = ${x - y}");///减 7
print("x * y = ${x * y}");///乘 30
print("x / y = ${x / y}");///除 3.333....
print("x ~/ y = ${x ~/ y}");///除 结果取整 3
print("x % y = ${x % y}");///余 1
简单的方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22///一些简单的方法和属性
int z = -5;
print("3是基数:${x.isEven}");// 是否是奇数 true
print("10是偶数:${y.isOdd}");// 是否是偶数 true
print("-5是负数:${z.isNegative}");// 是否为负数 5
print("-5的绝对值:${z.abs()}");// 绝对值 5
print("24和36的最大公约数：${24.gcd(36)}");//返回此整数和[other]的最大公约数。
print("10的2次幂对30取模：${10.modPow(2, 30)}"); /// 10^2 % 30 = 10
print("10大于2:${10.compareTo(2)}");/// 数值比较 1大于 0等于 -1小于
print("10转换为double:${x.toDouble()}");/// 10.0
print("10转换为string:${x.toString() is String}");/// is判断是否是某一
个类型 结果true
double dx = 10.5;
print(dx.ceil());///返回不小于this的最小整数。 11
print(dx.ceilToDouble());///返回不小于this的最小整数double值。 11.0
print(dx.floor());///返回不大于this的最小整数。 10
print(dx.floorToDouble());///返回不大于this的最小整数double值。 10.0
/// round() roundToDouble() 返回最接近此的整数
print(3.5.round());// roundToDouble() 返回最接近此的整数。 4
print(-3.5.round());//返回最接近此的整数。-4
更多请自行查看API文档
2.3、布尔型
只有true和false,用bool关键字声明1
2
3
4
5
6
7
8
9void main(List<String> args) {
bool success = false;
print(success); ///false
int x = 10;
int y = 3;
success = x > y;
print(success);//true
}
2.4、字符串
Dart 字符串是 UTF-16 编码的字符序列。 可以使用单引号''或者双引号""来创建字符串1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41///字符串
void main(List<String> args) {
String str = "this is a dart String";
print(str);
///使用三个单引号或者双引号也可以 创建多行字符串对象：
str = """这是第一行
这是第二行""";
String str2 = '''这是第一行
这是第二行''';
str = "Hello";
str2 = "Dart";
///字符串拼接
str = str + str2;
print(str);///HelloDart
///常用方法
print(str.toUpperCase());//转大写 HELLODART
print(str.toLowerCase());//转小写 hellodart
print(str.length);///长度 9
print(str.startsWith("He"));///以He开头 true
print(str.endsWith("He"));///以He结尾 false
print(str.contains("He"));///字符传中是否有He true
print(str.replaceFirst("l", "W"));///将第一个l替换为W
print("".isEmpty);///是否为空 true `isNotEmpty`
print(str.substring(2));///从第3个字符开始截取 下标索引 'lloDart'
print(str.substring(2,6));///从第3个字符开始截取到第6个字符为止 [2,6) 下标索引 'lloD'
print(str.indexOf("l"));///第一个'l'出现尾位置 索引 2
print(str.replaceRange(2, 6, "Google"));///将2-6位置字符替换为Google HelloDart => HeGoogleart
String str3 = "\tDart is fun\n";
/// trim() trimLeft() trimRight()
str3 = str3.trim();
print(str3);///去除首尾的空 'Dart is fun'
String a = "10";
int b = int.parse(a);//String 转 int
print(b);
}
更多的方法请查询API文档，或查看源码。
2.5、Map集合Map是一个键值对相关的对象。键和值可以是任何类型的对象。键不能重复，值可以重复。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50///Map
void main(List<String> args) {
var map = {
"name": "dart",
"company": "google",
"age": 8
};
print(map);///{name: dart, company: google, age: 8}
Map user = new Map();
user["name"] = "dart";
user["age"] = 8;
user["age"] = 10;
print(user);///{name: dart, age: 10}
Map<String,String> user1 = new Map<String,String>();
user1["name"] = "dart";
/// user1["age"] = 8;/// error A value of type 'int' can't be assigned to a variable of type 'String'.
print(user1);///{name: dart}
///获取值
print(user["name"]);///dart
///修改值
user["name"] = "Flutter";
print(user);//{name: Flutter, age: 10}
print(user.length);//长度
print(user.isEmpty);//是否为空 false
///添加合并两个map
Map user2 = new Map();
user2["email"] = "dart@gmail.com";
user2["phone"] = "911";
user.addAll(user2);
print(user);///{name: Flutter, age: 10, email: dart@gmail.com, phone: 911}
///删除一个值
user.remove("phone");
print(user);///{name: Flutter, age: 10, email: dart@gmail.com}
///遍历 传入的是一个匿名函数
user.forEach((key,value) =>
print("key=$key,value=$value")
);
// key=name,value=Flutter
// key=age,value=10
// key=email,value=dart@gmail.com
}
2.6、列表
在 Dart 中数组就是List对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28///列表
void main(List<String> args) {
var arr = [2,3.3,"dart",true];
print(arr);//[2, 3.3, dart, true]
print("arr的长度是：${arr.length}");//4
print("arr是否是空：${arr.isEmpty}");//false
print("arr[2]:${arr[2]}");//dart
print("arr拼接为字符串:${arr.join()}");//23.3darttrue
print("arr中是否有dart元素：${arr.contains("dart")}");//true
//遍历
arr.forEach((v) => print(v));
//固定长度
List arr2 = new List(2);
arr2[0] = 20;
arr2[1] = "google";
print(arr2);//[20, google]
//遍历
for(int i = 0; i < arr2.length; i++){
print(arr[1]);
}
//固定类型
List<String> arr3 = new List<String>();
arr3.add("google");
// arr3.add(10);//不能添加
print(arr3);//[google]
}
2.7、Set
同为数据列表，与List比较，List中可以有重复的数据，而Set没有顺序且不能重复的集合,所以不能通过索引获取值1
2
3
4
5
6
7
8
9
10
11
12
13
14
15void main(List<String> args) {
var arr = new Set();//Set没有固定的元素，所以不能指定长度
arr.add("dart");
arr.add(2);
arr.add(2);
print(arr);//{dart, 2}
print("arr的长度是：${arr.length}");//2
print("arr是否是空：${arr.isEmpty}");//false
print("arr拼接为字符串:${arr.join()}");//dart2
print("arr中是否有dart元素：${arr.contains("dart")}");//true
print("arr中索引为1的元素：${arr.elementAt(1)}");//2
//遍历
arr.forEach((v) => print(v));
}
2.8、Dynamic
动态的数据类型1
2
3
4
5
6
7
8
9
10
11
12
13
14void main(List<String> args) {
dynamic age = 20;
dynamic name = "dart";
dynamic height = 10.2;
dynamic success = true;
print(age is int);
age = "google";
print(age is int);
print(name is String);
print(height is double);
print(success is bool);
}
三、控制语句
3.1、if and esle1
2
3
4
5
6
7
8
9
10
11
12void main(List<String> args) {
int score = 65;
if (score >= 80) {
print("优秀");
} else if(score >= 70){
print("良好");
}else if(score >= 60){
print("中等");
}else{
print("不及格");
}
}
3.2、for loop1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21void main(List<String> args) {
for(int i = 1; i < 10; i++){
for(int j = 1; j < 10; j++){
print("$i * $j = ${i * j}");
}
}
// continue 跳出当次循环 break结束循环
var list = [1, "dart", 30, 12.6];
for(int n = 0; n < list.length; n++){
var val = list[n];
if("dart" == val){
continue;
}
if(30 == val){
break;
}
print(val);
}
}
3.3、while and do-whilewhile循环在执行循环之前先判断条件是否满足,而do-while循环是先执行循环代码再判断条件1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18void main(List<String> args) {
int i = 1;
while(i < 10){
int j = 1;
while(j < 10){
print("$i * $j = ${i * j}");
j++;
}
i++;
}
int a = 3;
int step = 0;
do{
step ++;
print("执行$step次");//执行1次
}while(a < 2);
}
3.4、switch and caseDart 中的 Switch 语句使用 ==比较 integer、string、或者编译时常量。比较的对象必须都是同一个类的实例1
2
3
4
5
6
7
8
9
10
11
12
13
14void main(List<String> args) {
var cmd = "close_win";//close_io
switch (cmd) {
case "close_win":
case "close_io":
print("close");
break;
case "open":
print("open");
break;
default:
print("default");
}
}
四、异常
代码中可以出现异常和捕获异常。异常表示一些未知的错误情况。如果异常没有捕获，则异常会抛出，导致抛出异常的代码终止执行。throw 抛出一个异常try{} catch(e){} 捕获异常1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26void main(List<String> args) {
int a = 1;
var arr = [1, 2, 3];
try {
if(a == 1){
throw new Exception("a can't eq 1");
}
if(a == 2){
throw new NumException("自定义异常......");
}
print(arr[3]);
} catch (e) {
print(e);
}
}
class NumException implements Exception{
NumException([this.msg=""]);
final String msg;
String toString() {
if (msg == null) return "NumException";
return "Exception: $msg";
}
}
五、方法
Dart是一个真正的面向对象语言，方法也是对象并且具有一种类型Function。方法可以赋值给变量，也可以当做其他方法的参数。 也可以把 Dart 类的实例当做方法来调用1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37void main(List<String> args) {
String name ="小明";
int age = 10;
String email = "xiaoming@qq.com";
createUser(name, age, email);
createUserOpt();
createUserOptName(name: name,email: email);
createUserPos(name, age);
var f = (val){
print("value : $val");
};
callFunction(f);
}
///参数必需
void createUser(String name,int age,String email) {
print("name:$name,age:$age,email:$email");
}
///可选参数
void createUserOpt([String name,int age,String email]) {
print("name:$name,age:$age,email:$email");
}
///可选命名参数 默认参数值
void createUserOptName({String name,int age = 20,String email}) {
print("name:$name,age:$age,email:$email");
}
///可选位置参数
void createUserPos(String name,[int age,String email]) {
print("name:$name,age:$age,email:$email");
}
///方法作为参数
void callFunction(void f(int age)){
f(100);//执行传入的方法
}
六、类
Dart是一个面向对象编程语言，同时支持基于mixin的继承机制。每个对象都是一个类的实例，所有的类都继承于Object。
基于Mixin的继承意味着每个类（Object 除外）都只有一个超类，一个类的代码可以在其他多个类继承中重复使用。
使用new关键字和构造函数来创建新的对象。构造函数名字可以为ClassName或者 ClassName.identifier。
6.1、类的定义
1 | void main(List<String> args) { |
6.2、抽象类
使用abstract修饰符定义一个抽象类,抽象类不能被实例化。通常用来定义接口，以及部分实现。如果希望实例化抽象类，可使用工厂构造函数方式。抽象类通常有抽象方法（没有实现体的方法）1
2
3
4
5
6
7
8
9
10
11
12
13
14/// 不可实例化
abstract class AbstractContainer {
/// 抽象方法
void updateChildren();
}
/// 可以势力化
class SpecializedContainer extends AbstractContainer {
void updateChildren() {
}
void doSomething();
}
6.3、隐式接口
每个类都隐式的定义了一个包含所有实例成员的接口，且这个类实现了这个接口。如果你想创建类A来支持类B的api，而不想继承B的实现， 则类A应该实现B的接口。
可以通过implements关键字来实现一个或者多个接口，并实现每个接口定义的API1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40void main(List<String> args) {
// Person person = new Person(name:"张三");
// person.run();
// Employee emp = new Employee();
// emp.run();
// person = new Employee(name:"李四",phone: "15198989999");
// person.run();
greetBob(new Person(name:"川普"));
greetBob(new Employee(name:"李四",phone: "15198989999"));
}
greetBob(Person person) => person.run();
class Person{
final String name;
Person({this.name});
void run(){
print("Person[$name] runing...");
}
}
///继承
class Employee implements Person{
final String name;
final String phone;
Employee({
this.name,
this.phone
}
):super();
void run(){
print("Employee [$name] runing...");
}
}
6.4 枚举
枚举类型通常称之为enumerations或者enums， 是一种特殊的类，用来表现一个固定 数目的常量。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21void main(List<String> args) {
List<Color> colors = Color.values;
print(colors[0] == Color.red);
Color aColor = Color.blue;
switch (aColor) {
case Color.red:
print('Red as roses!');
break;
case Color.green:
print('Green as grass!');
break;
default:
print(aColor);
}
}
enum Color {
red,
green,
blue
}
6.5、泛型
将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17void main(List<String> args) {
List<String> list = ["A","B"];
Result result = new Result(code: "0000",msg: "请求成功!",data: list);
print(result.toString());//[code=0000,msg:请求成功!,data:[A, B]]
}
class Result<T>{
String code;
String msg;
T data;
Result({this.code,this.msg,this.data});
String toString(){
return "[code=$code,msg:$msg,data:$data]";
}
}
