dart语言学习(新人总结)

dart语言的学习～

语法跟c类似
整除~/
int, double 等继承于num
都是类名
is可以判断是否是继承关系
int a
if(a is int)可以这样做类型检测(而且多重继承的依然可以检测)
is!就是不属于
as类型转换。比如 double p=1.2 print(p as int);
late String a；定义时不会分配内存，不初始化
函数和c++几乎完全一样
print('${name}'); 或$name
自动类型var 很好用
Object可以定义为任意类型，而且可以动态改变类型
dynamic也是，var为定义类型时就是dynamic，但是推荐用Object
Object会在编译阶段检查类型，而dynamic不会在编译阶段检查类型。abstract 抽象类继承时需要覆盖所有功能函数
const && final 常量声明
编译期就能初始化的就用const, 如果常量是运行时期初始化的就用final

list set && map

void main()    {
  List<int>a=[1,2,3,4];
  Set<int>st={};
  Map<int,int>mp={1:1,2:1,3:1};
  var mp_1 ={
    1:2,
    3:4,
  };// 还可以这样定义，系统会自动推断类型（这个有点秀呀）
  a.add(5);
  a.insert(0,8);// 第index个数后面插入数据
  print(a);
  a.remove(8); // 删掉值为8的
  a.removeAt(0);// 删掉第index下标的
  print(a);
  print(a.contains(4));// 含有
  print(a.length);
  print(a.sublist(1,4)); // 左闭右开
  print(a.getRange(1,4));// 好像是同上
  for(int i=0;i<a.length;i++) 
    print(a[i]);
  for(var i in a)
    print(i);
  a.forEach( (i) => print(i) );
  a.sort( (a,b)=>(a>b?1:-1)) ;
  a.clear();
  
  
  st.addAll(a);
  print(st.contains(2));
  st.remove(2);
  for(var i in st){
    print(i);
  }
}

// 空安全。断言assert 异常捕获 try catch finally && 运算符重载

const double pi=3.141592;//  常量 更加严格，编译时就要确定的值
final pa=1.2; // 变量
// const pc=pa*pi; // 出错 pa 不是编译时就确定的值
class Point{
  double x,y;
  Point(this.x,this.y);
  Point operator + (Point a){
      return Point(x+a.x,y+a.y);  
  }
  Point operator - (Point a){
    return Point(x-a.x,y-a.y);
  }
}

void main()    {
  int x=1;
  int fl = 1;
  late String s;
  // 空安全。断言assert  异常捕获 try catch finally
  fl ??= 10; // ??= 如果没赋值才进行赋值 
  int p1=0,p2=8;
  int a = p1??p2; // 前者是空就返回后者，否则前者 感觉适用于安全性的初始化对象
  /*
  for(int i=1;i<=5;i++){
    assert(x==1); // false 时中断 //只在检查模式下生效
    print('qwd');
  }*/
  int num1=12;
  try{
     int num2=num1~/2;
  }catch(e){
    print(e.toString());
  }finally{ //  只要执行try 或 catch 就一定会执行
    print("zhixing ");
  }
 
  Point p=new Point(1,1);
  Point p4=new Point(1,2);
  Point p3=p+p4;
  
  print(p.x);
  var number1 = p?.x;
  // var number2 = p.x?.1;
  var choice = a ?? 8;
  
}

class
	可用finla && const 修改内部成员的权限
	构造函数有很多种
	Student(this.a,this.b);最方便
	get(访问器) 就相当于是个函数·
	set(value)  存取器 ，好像是自动同步实现的，修改成员属性是对应set函数会自动运行
class   继承：
	1.extends 继承所有api以及实现
	
	2.implements:  继承api但不继承实现,需要重写父类所有方法(包括变量),可以多类继承(除了这个好像没啥别的用处~)
	
	3.mixin 公用方法 加个with即可（像是一个修饰器），方便带有mixin属性并且有他的属性和函数功能

const pi=3.141592;
mixin Musical{
  bool Piano=false;
  bool Guitar=false;
  void getshow(){
    if(Piano) print('i can play piano');
    if(Guitar) print('i can play guitar');
  }
  
}

class People{
  int age=0;
  int id=0;
  String name="";
  People(this.age,this.id,this.name);
  void getage(){
    print('people age:${age}');
  }
  void getid(){
    print('people id:${id}');
  }
  void getname(){
    print('people name : ${name}');
  }
}
class Teacher with Musical{
  int age=0;
  int id=0;
}
class Dog{
  int val=0;
}
class Stu implements People,Dog{
  int age=0;
  int id=0;
  String name="";
  int val=0;
  //People(this.age,this.id,this.name);
  void getage(){
    print('people age:${age}');
  }
  void getid(){
    print('people id:${id}');
  }
  void getname(){
    print('people name : ${name}');
  }
}


class Circle{
  double x,y;
  double r;
  Circle (this.x,this.y,this.r);
  get area{
    return pi*r*r; 
  }
  set init(value){
    this.r=value;
  }
  
}


void main()    {
  var circle_1=Circle(1,2,3);
  
  print('${circle_1.x},${circle_1.y},area:${circle_1.area}');
  circle_1.init=4;
  print('${circle_1.x},${circle_1.y},area:${circle_1.area}');
  
  Stu student = new Stu();
  print(student.age);
  student.getage();
  
  Teacher tea=new Teacher();
  tea.Guitar=true;
  tea.getshow();
  
}

回调地狱
一个异步请求套着一个异步请求，一个异步请求依赖于另一个的执行结果，使用回调的方式相互嵌套。这会导致代码很丑陋，不方便后期维护