dart基础
数据类型
num
int
int d=1
int b=-1double
double a=3.14 //双精度浮点数
num N=-3.0 //既可以是int,也可以是double
//求绝对值
n=N.abs();
//数据类型转换
n=N.toInt();//转换为整数
n=N.toDouble();//转换为双精度浮点数
n=N.toString();//转换为字符串String
//定义字符串的方式
String str="123";
String str='123';
String str='123',stri="321"
//定义复合的字符串
String strin="str:$str"//这里的$str取到了变量str的值
//常用方法
String str="12345";
str.substring(1,5)//裁切字符串范围：[1,5),字符串起始从0开始
str.indexOf("23")//获取2的下标
str.empty()//判断字符串是否为空bool
bool success=true;
List
//集合的初始化方式
List list1=[1,2,3,"集合"]//默认泛型为Dynamic(动态数据类型)
List<int> list2=[1,2,3,4]
List list4=List.generate(3,(index) => index*2);//3=List总长度;index=下标;index*2=值为当前下标*2
//list4=[0,2,4]
//添加单个元素
list2.add(100);
//添加集合中的所有元素
List<int> list3=[4,3,2,1]
list3.addAll(list2);
//遍历集合
//方式1
for(int i=0;i<list.length;i++){
print(list[i]);
}
//方式2
for(var o in list){
print(o);//打印的是元素的值
}
//方式3
list.forEach((x){
print(x);
});
//移除元素
list.remove(index);
Map
//map的key是唯一的，如果key重复，那么后面添加的key会替换前面的
//map初始化
Map names={"姓名1":"小明","姓名2":"小红"};
Map ages={};
ages["年龄1"]=16
ages["年龄2"]=18
//map的遍历
ages.forEach((key,value){
print("key:$key,value:$value);
});
//通过遍历一个map生成另一个map
Map ages2=ages.map((key,value){
return MapEntry(key,value+1);
});
//遍历key
for(key in ages.keys){
print("key:$key value:${ages[key]}")//表达式需要使用${}获取
}
//显式通过泛型规定map的数据类型
Map<String,int> ages3={};dynamic
- 是所有dart对象的基础类型，通常不会直接使用它；通过它定义的变量会关闭类型检查
var
- 这是一个关键字，系统会自动推断类型的runtimeType
Object
- 它是dart对象的基类，当
Object o=xxx;时，系统会认为o是一个对象；与dynamic的最大区别在于类型检查
- 它是dart对象的基类，当
方法
方法的构成与声明
//返回值类型+方法名+参数
int sum(int val1,int val2){
var result=val1+val2;
return result;
}
//也可以不显性的指明返回值类型
sum(int val1,int val2){
var result=val1+val2;
return result;
}
//没有返回值
sum(int val1,int val2){
var result=val1+val2;
print(result);
}
//参数类型可以省略
//可选参数,这里的isTrue为可选参数，参数类型为bool，默认值为false
void sum(val1,val2,{bool? isTrue=false}){
if(isTrue ?? false){//这里的空安全检查代表当isTrue为空时，取false
var result=val1+val2;
print("result:$result")
}
}入口方法
void sum(val1,val2,{bool? isTrue=false}){
if(isTrue ?? false){//这里的空安全检查代表当isTrue为空时，取false
var result=val1+val2;
print("result:$result")
}
}
//main方法为主入口方法
void main(){
sum(1,2,isTrue: true);
}实例方法
实例方法是一个普通函数，通过
对象名.方法名访问class FunctionLearn{
void sum(val1,val2,{bool? isTrue=false}){
if(isTrue ?? false){//这里的空安全检查代表当isTrue为空时，取false
var result=val1+val2;
print("result:$result")
}
}
}
//调用方法
FunctionLearn f=FunctionLearn();//实例化对象
f.sum(1,2,isTrue: true);
私有方法
通过在方法名前添加
_来标识该方法为私有方法，只有在类的内部能够调用，作用域为当前类class animal{
void _eat(){
print("吃饭");
}
}匿名方法
List<String> list=["123","321"];
list.forEach(/*(x){
print(x);
}*/);//这里被注释的部分即为匿名方法
//当匿名方法的参数列表中的某个参数不需要使用时，可以使用_来忽略
静态方法
//使用static标识的方法，可以直接使用类名.方法名调用
class Number{
static int doSum(int v1,int v2){
return v1+v2;
}
}
//调用
var n=Number.doSum(1,2);
面向对象
dart中，所有类的父类都是Object
私有变量的作用域为当前文件
class Person{
String? name; //空安全，可以为空
int? age;
Person(this.name,this.age);
}
class Student extends Person{
String? _school;
String? city;
String? country;
String? fullname;
//构造方法：
//name,age交给父类进行初始化，{}代表可选参数，?代表可以为空
Student(this._school,String? name, int? age,{this.city,this.country="China"})
: funName="$country.$city",super(name,age){}//构造方法体可以省略
}构造方法
1.普通构造方法
2.命名构造方法
3.工厂命名构造方法
4.工厂构造方法
class Person{
String? name; //空安全，可以为空
int? age;
Person(this.name,this.age);
}
class Student extends Person{
String? _school;
String? city;
String? country;
String? fullname;
//构造方法：
//name,age交给父类进行初始化，{}代表可选参数，?代表可以为空,
//:代表初始化列表，在构造方法执行前初始化某些变量
Student(this._school,String? name, int? age,{this.city,this.country="China"})
: funName="$country.$city",super(name,age){}//构造方法体可以省略
//命名构造方法可以为类实现多个构造方法,但是它没有返回值 [类名.方法名]
Student.cover(Student stu):super(stu.name,stu.age){
print("命名构造方法");
}
//命名工厂构造方法：factory [类名.方法名]
//可以有返回值，而且不需要将类的final变量作为参数，是一种灵活获取类对象的方式
//命名参数city:s.city，通常用于可选参数。
//代表将s.city的值赋值给city这个变量，目的是可以让调用者明确指出哪些参数被传递了
factory Student.create(Student s){
return Student(s._school,s.name,s.age,city:s.city,country:s.country);
}
}
class Logger{
static Logger? _cache;
factory Logger(){
//避空赋值运算符 (??=)，当_cache为null时，则将右边的表达式结果赋值给左边
//当_cache不为null则无需操作，目的是保证_cache不为null
//扩展:!在dart中有两个含义，在变量之前代表取反例如!_cache；
//在变量之后代表断言该变量非空，例如_cache!
_cache??=Logger()._create();
return _cache!;
}
Logger._create();
}
void main(){
//调用构造方法实例化对象
Student st=Student("清华","xiaoMing",24);
//调用命名构造方法
Student s=Student.cover(st);
}getter和setter
//get方法/set方法
class Person(){
String? _school;
//get
String? get school => _school;
//set
set school(String? value){
this._school=value;
}
}
//其他文件中访问
void main(){
//get
Person p=Person();
print(p.school);
//set
p.school="xxx";
}抽象类和抽象方法
//抽象类使用abstract关键字
//抽象类中没有方法体的方法均为抽象方法
//抽象类可以包含有方法体的方法
//继承抽象类需要实现它的抽象方法
//抽象类可以被其他类使用implements关键字实现
//实现抽象类之后，必须重写抽象类的所有方法
//抽象类无法被实例化，只能实例化其子类
abstract class Study{
void study();
}mixins
mixins是一种特殊的类，无法被实例化但是可以被其他类使用
mixins是在多个类层次结构中重用代码的一种方式（多继承的一种方式）
要使用mixins,在with关键字后面跟一个或多个mixin的名字（用逗号隔开）。
并且with要用在extends关键字之后
mixins的特征：实现mixin，就创建一个继承Object类的子类（不能继承其他类），不声明任何构造方法，不调用super
abstract class Study(){
void study(){
print("study");
}
}
class Test extends Person with Study(){
void s(){
study();
}
}dart泛型
///主要解决类、接口、方法的复用性
//泛型类
class Cache<T>{
final Map<String,T> _cached={};
void setItem(String key,T value){
_cached[key]=value;
}
T? getItemByKey(String key){
return _cached[key];
}
}
//泛型可以约束参数类型
class Member<T extends Person>{
final T _person;
Member(this._person);
String fixedName(){
return "fixed:${_person.name}";
}
}