Dart基础语法
基本数据类型
Dart 属于强类型语言(在Dart2.0之前,Dart是一门弱类型语言。2.0以后变更为强类型语言(注:官网原文是 Dart 2.0 has a sound type system))。同时属于动态类型语言(动态类型语言指只有在运行的时候才会检查数据类型,静态类型语言指编译期间就会检查数类型),支持闭包。
2.0之后Dart依旧可以使用类型推断等弱类型语言的特性。可以使用
var
定义变量,和Kotlin类似,声明变量后,Dart会自动推导数据类型,var
实际上是编译器的语法糖。关键字dynamic
表示动态类型,被编译后实际是一个object
类型,在编译期间不进行类型检查
var a;
a = 12;
///等同于
dynamic a = 12;
///a都是可变类型
a = "123";
print(a);//打印输出“123”
print(a + 1);//做为强类型语言 当a赋值String类型后 执行a+1操作的时候 会报错类型错误 1是int类型
-
Dart
中number类型分为int
和double
,其中java
中的long
对应的也是Dart
中的int
类型。Dart
中没有float
类型。switch
支持String
类型。
变量
很多和Kotlin类似,比如不需要设置
set
get
方法、数组等于集合:var list = [];
和List lsit = new List()
可以简单认为是一个样的。Dart
中所有的数据类型、类都继承与Object
,默认值都是NULL
。final
和const
都表示常量;同时static const
组合表示静态常量。final
在运行的时候确定值,const
在编译期确定值。number 类型在作为字符串使用时,和Java不一样,需要先转换为字符串类型。如
int i = 0; print(i+'123');
,这样会抛类型错误,需要int i = 0; print(i.toStirng()+'123');
。所以在使用时,需要注意不要把 number 类型当做String
使用。
方法
??
和??=
操作符,如:AA ?? "999"
表示如果AA为空,返回999;AAA ?= 999
如果AAA为空,把999赋值给AAA。和Kotlin一样,方法可以设置默认值和指定名称。不同的是默认值需要使用
{}
包裹,默认值可以不指定参数类型。只有默认值需要指定名称,而且是必须。
///var3可以省略String 不指定类型
getVar(String var1, String var2, {String var3 = "123"}) {}
///调用
getVar("1", "2", var3: "456");
Dart没有
public
、private
等修饰符关键字,_
下划线直接代表private
,有@protected
注解。Dart默认构造函数只能有一个,但是可以通过
Model.empty()
方法创建不同参数的类。empty()
方法名可自定义。
class User {
String userName;
int userAge;
///也可以通过设置参数默认值
User(this.userName, {this.userAge = 18});
///空构造函数
User.empty();
///userName单个参数的构造函数
User.forName(this.userName);
User.forAge(this.userAge);
@override
String toString() {
return "userName:" + (userName ??= "null") + " age:" + userAge.toString();
}
}
void main() {
///打印 userName:null age:null
print(User.empty().toString());
///打印 userName:李华 age:null
print(User.forName("李华").toString());
///打印 userName:null age:18
print(User.forAge(18).toString());
///打印 userName:小明 age:22
print(User("小明", userAge: 22).toString());
///打印 userName:李华 age18
print(User("李华").toString());
///打印 userName:小明 age26
print(User("小明", userAge: 26).toString());
}
异步
常用的异步处理方式是使用
async
和await
关键字,使用async
来表示此函数是一个异步函数,await
用于等待结果返回,此时会阻塞后面的代码。。代码实例:
request()
方法模拟网络请求,去调用getData()
方法,getData方法延迟2秒后返回一个字符串,request方法等待2秒后获取字符串打印出来。这是async
函数没有返回值的情况。
request() async {
String string = await getData();
print(string);
}
getData() {
Future.delayed(Duration(seconds: 2));
return "123";
}
///调用request 2秒后打印123
request();
-
async
标注的函数其返回值类型是Future<T>
。在异步任务完成后会回调then()
。
Future<String> request() async {
String string = await getData();
return string;
}
getData() {
Future.delayed(Duration(seconds: 2));
return "123";
}
///调用
Future<String> result = request();
//注册监听
result.then((value) {
print(value);
});
///注意
///request返回的是Future对象 不是String
///所以不能这样写
/// String result = request();
/// print(result);
///
接口与继承
-
Dart 没有
interface
关键字。在 Dart 中所有的类都隐含的定义了一个接口。也就是说 所有的类都能当做接口去实现。
class Animal {
void eat() {
print("Animal Eat");
}
void run() {
print("Animal Run");
}
}
class Cat implements Animal {
@override
void eat() {
print("Cat Eat");
}
@override
void run() {
print("Cat Run");
}
}
Cat cat = new Cat();
cat.run();
cat.eat();
///打印输出
///Cat Run
///Cat Eat
如果你想 创建类 A 来支持 类 B 的 api,而不想继承 B 的实现, 则类 A 应该实现 B 的接口。
-
多继承的实现:mixins
xiaobai品种的狗继承了Animal,同时通过 with
关键字来实现多继承自 Dog
,在这里 Dog
类就是mixin。
class Animal {
void eat() {
print("Animal Eat");
}
}
///普通的类也能被with实现多继承
//class Dog {
// void wang() {
// print("Dog wang~wang~wang~~~");
// }
//}
///mixin关键字声明的类无法被继承 无法创建,可以当做接口实现
mixin Dog {
void wang() {
print("Dog wang~wang~wang~~~");
}
}
class XiaoBai extends Animal with Dog {}
XiaoBai xiaoBai = new XiaoBai();
xiaoBai.eat();
///打印输出Animal Eat
on
固定子类使用的类型,使用Dog
的子类必须继承与Animal
,
class Animal {
void eat() {
print("Animal Eat");
}
}
///定义一个mixin 并且子类必须继承Animal
mixin Dog on Animal{
void wang() {
print("Dog wang~wang~wang~~~");
}
}
class Vegetation{}
///此时XiaoBai继承与Vegetation会报错,因为dog已经限制了子类必须继承Animal
class XiaoBai extends Vegetation with Dog {}
初学小白的个人学习笔记,欢迎大佬检查,如有不对请指出。