Dart基本语法入门

Dart 是由谷歌开发的面向对象的计算机编程语言，主要用于web、服务器、移动应用和物联网的开发

在dart中每行代码结束时都需要添加分号

入口

Dart程序的运行入口
在一个dart文件中 只允许最多一个入口函数

	main() {
	}
	//或者
	void main() {
	}

变量

对于变量的声明 dart存在类型校验 区分大小写
可以使用var关键字也可以使用变量类型进行变量声明

	var str = 'zhangsan';
	String str = 'zhangsan';

常量

对于常量的声明 在dart中有两种关键字const和final
const一开始就需要赋值
final一开始可以不赋值 只能赋值赋值一次
final不仅有const的编译时常量的特性，最重要的是它是运行时常量
final是惰性初始化，即在运行时第一次使用之前才初始化

数据类型

数值类型

num、int、double

字符类型

String
对于字符串来说，可以使用单引号、双引号和三引号，使用三引号时会保留文本的格式
对于字符串的拼接可以使用$也可以使用+

	String str1 = "zhangsan";
	String str2 = 'zhangsan';
	print('${str1} 就是 ${str2}');

布尔类型

bool

映射类型

Map

	var map1 = {'name': 'zhangsan'};
	var map2 = new Map();
	//获得map1中的name
	var name = map1['name'];
	//获得map1的keys列表
	var keys = map1.keys.toList();
	//获得map1的values列表
	var values = map1.values.toList();

列表类型

List、Set

	var list1 = ['zhangsan', 'lisi'];
	var list2 = new List();
	//获得list1的长度
	var length = list1.length;
	//获得list1的第一个元素
	var name = list1[0];

类型判断

可以通过is关键字进行类型判断

	var str = 'zhangsan';
	if(str is String) {
		print('str 是 String类型');
	} else {
		print('str 不是 String类型');
	}

获得某个对象的类型

	obj.runtimeType.toString();

类型转换

可以使用as关键字进行类型转换

	(p as Person).eat();

Num转String

	int a = 123;
	String b = a.toString();

String转Num

	String str = '123';
	int a = int.parse(str);
	double b = double.parse(str);

非空判断

	var str = 'zhangsan';
	if(str.isEmpty) {
		print('str 为空');
	}

运算符

算术运算符 加上=组成复合赋值运算符

描述	符号	描述	符号
加	+	减	-
乘	*	除	/
取余	%	取整	~/

关系运算符

描述	符号	描述	符号
相等	==	不等	!=
大于	>	小于	<
大于等于	>=	小于等于	<=

逻辑运算符

描述	符号	描述	符号
取反	!	并且	&&
或者	||

赋值运算符
赋值=
空赋值?=
空判断??

	int b = 123;
	b??=23;
	/// 表示如果b为空时，将23赋值给b 否则不进行赋值
	
	var c = a??b;
	///表示如果a为空 则返回b 否则返回a

三目运算符

	var d = a ? b : c;

循环

	for(int i = 0;i < 5;i++) {
	}
	
	while(true){
	
	}
	
	do{
	
	}while(true);

	var myList = ['zhangsan', '李四'];
	for(var item in myList) {
	}

	myList.forEach((item){
	
	});
	
	var newList = myList.map((item){
		return item;
	}).toList();

	//筛选满足条件的组成新数组
	var newList = myList.where((item){
		return item == 'zhangsan';
	});
	
	//判断数组中是否存在满足条件的对象
	bool flag = myList.any((item){
		return item == 'zhangsan';
	});
	
	//要求该数组中的所有元素都满足条件 否则返回false
	bool flag = myList.every((item) {
		return item == 'zhangsan';
	});

函数定义

在dart中 支持函数的嵌套使用

无参 无返回值

	void fun1(){
	
	}
	///或
	fun1() {

	}

无参 有返回值

	String fun1() {
		return 'zhangsan';
	}
	///或
	fun1() {
		return 'zhangsan';
	}

有参

	String fun1(String name, int age){
		return 'zhangsan';
	}
	///或 没有了参数的类型校验
	String fun1(name, age) {
		return 'zhangsan';
	}

可选参数[]

可选参数放在参数列表的最右边，可指定默认值

	void fun1(String name, int age, [String phone, int sex = 0]) {
	}

命名参数{}

可指定默认值
命名参数是可选的 可使用@request添加在参数之前 标识某个参数必填

	void fun1({String name, int age}) {
	
	}
	///调用方式 
	fun1(
		name: 'zhangsan'
	);

方法参数

方法可作为参数传入方法

	fun1() {

	}
	
	fun2(fun) {
		fun();
	}
	//调用方法
	fun2(fun1);

泛型方法

	T fun1<T>(T t){
		return t;
	}
	//调用方法
	fun1('zhangsan');
	fun1<int>(12);

箭头函数

箭头函数只能写一句

	list.forEach((item)=>print(item));

匿名函数

	var fun1 = (String name) {
		return '我是 ${name}'
	}

自执行函数

	((){
		print('自执行');
	})();
	
	///带参
	((int n){
		print(n);
	})(12);

异步函数

async用于声明异步函数 只有在async方法中才能使用await关键字
await等待异步方法执行完成

	fun1() async {
		var res = await Uri.http('xxx', 'xxx');
		return res;
	}

类

万物皆对象 都继承自Object类
在一个dart文件中可以有多个类

	class Person{
		///属性
		String name;
		int age;
		
		//构造方法
		Person() {
		}
		
		//在构造时进行赋初值
		Person() : name='zhangsan',age=10 {
		}
		
		Person(String name, int age) {
			this.name = name;
			this.age = age;
		}
		///简写
		Person(this.name, this.age);

		//命名构造 可以有多个命名构造方法
		Person.create(){
			print('命名构造');
		}
	
		eat() {
			print('开饭了');
		}
	}

实例化

实例化时 new关键字可以省略

	var person1 = new Person();
	var person2 = Person('zhangsan', 20);
	var person3 = Person.create();

getter/setter

	class Area {
		num height;
		num width;
		
		Area(this.height, this.width);
		
		//相当于属性 不能与属性重名
		//调用方式 area.areaHeight = 6;
		set areaHeight(value) {
			this.height = value;
		}

		//没有()
		//调用方式 print(area.area);
		get area{
			return this.height * this.width;
		}
	}

连级操作

	Person p = new Person();
	p..name = 'zhangsan'
		..age = 10
		..eat();

继承

使用extends来实现继承 在dart中只支持单继承
子类会继承父类中课件的属性和方法 但是不会继承构造函数 可使用super
子类能重写父类的方法、getter/setter

	class Dog extends Animal{
	}

混合

使用with实现类似于多继承的功能

条件
	作为父类的类只能直接继承自Object 不能继承其他类
	作为父类的类不能有显式构造函数
	这种不是继承 也不是接口 是一种特性

	class A {
	}
	class B {
	}
	class C{
	}
	
	//A类和B类的所有公开方法 D类都可以方法
	class D with A,B{
	}
	
	//不影响继承与实现
	//当A类和B类中具有同名的属性或方法时 在使用E类去调用时 会调用 with 最后声明的类的属性或方法
	//此时 print(E is A);print(E is B);print(E is C); 均为true
	class E extends C with A,B {
	}

抽象类/接口

主要用于定义标准
通过abstract关键字来定义 子类可以extends继承于抽象类 也可以implements实现抽象类
抽象方法不能使用abstract进行声明 没有方法体的方法为抽象方法
子类继承抽象类则必须实现抽象类中的所有抽象方法
抽象类无法被实例化

Dart支持多实现

如果要复用抽象类中的方法，并且需要使用抽象方法实现约束，就继承抽象类
如果只是将抽象类用于约束，就实现抽象类

abstract class A {
}
abstract class B {
}
class C implements A,B {
}

泛型类

	class A<T> {
	}
	A a = new A<String>();

引入

使用import关键字引入dart文件

	import 'xxxxxx/Person.dart';
	
	Person p = new Person();

重命名

通过as关键字实现引入文件的重命名

	import 'xxx/Person.dart' as P;
	
	//使用方法
	P.Person p = new P.Person();

部分引入

通过show关键字实现部分引入

	import 'xxx/Utils.dart' show md5;
	
	md5('xxx');

部分隐藏

通过hide实现部分隐藏 隐藏后无法被调用

	import 'xxx/Utils.dart' hide md5;

懒加载引入

使用deferred as实现懒加载引入 在调用之前需要先使用异步方法loadLibrary()加载资源后才能使用

	import 'xxx/Utils.dart' deferred as utils;
	
	fun() async {
		await utils.loadLibrary();
		utils.md5('xxx');
	}

引入第三方库

首先需要在根目录新建一个pubspec.yaml文件
在dependencies标签下添加需要引入的第三方库

	name: 'test'
	description: '测试'
	dependencies:
		http: xxxxxx

使用 pub get命令进行依赖安装
常用的第三方库

http://pub.dev/packages
http://pub.flutter-io.cn/packages
http://pub.dartlang.org/flutter

访问修饰符

使用_将一个属性或方法定义为私有 前提是需要将这个类单独抽离成一个文件