2023-05-21 dart语法

2023-05-21 本文已影响0人 coder_feng

变量与类型

变量
类型变量名 = 值；
如果一个变量在定义之后没有赋值，则默认等于null
类型
基本类型 bool,num(int & double),String ,enum
泛型 List Map
var
1.接受任何类型的变量
2.一旦赋值，无法改变类型，由此可看是一个强类型语言
dynamic 与Object

	Object	dynamic
不同点	只能使用Object属性与方法	编译器会提供所有可能的组合
相同点	可以在后期改变赋值类型	可以在后期改变赋值类型

dynamic a = 'str';
print(a.length);//正确

Object a = 'str';
print(a.length);//错误

dynamic 很容易引起运行时错误

左对齐	右对齐	居中对齐
单元格	单元格	单元格
单元格	单元格	单元格

控制流语句

条件判断
if 与其他语言差别不大
Debug模式下接受bool类型，Release接受任何类型(但是除了bool类型，其他都判断为false)
switch 语句
非空case在执行完之后必须以break、return、continue的方式结束
空case继续执行
循环语句
for 与其他语言差别不大
while 可以看做减缓版的for
do-white 先执行一次，然后再判断
跳转语句
break 结束整个循环
continue 结束当前循环

函数

声明
没有显示声明返回值类型默认当做dynamic
函数返回值没有类型判断
语法简写
=> 表示
函数变量
作为参数

void main() {
  var calPower = (n) {
    return n * n;
  };
print(calPowder(5));
}

参数传递
层层传递

void main() {
  printPower(calPower(8));
}
void printPowder(var power) {
  print(power);
}
int calPower(int n) {
  return n * n;
}

可选位置参数
可以用[]来标记可选的参数位置

void main() {
  int m1 = calMultiplication(4);
print(m1);//16

int m2 = calMultiplication(4,5);
print(m2);
}

int calMultiplication(int 1,[int 5]) {
  if(b != null) {
    return a * b;
  }else {
      return a * a;
    }
}

可选命名参数
可以用 {} 来标记可选的命名参数

void main() {
  int m1 = calMultiplication(4);
print(m1);//16

int m2 = calMultiplication(4,b: 5);
print(m2);
}

int calMultiplication(int 1,[int 5]) {
  if(b != null) {
    return a * b;
  }else {
      return a * a;
    }
}

类和对象

定义
class
构造函数
与类同名

class Person {
  int age;
  String name;

  Person(int age, String name) {
    this.age = age;
    this.name = name;  
  }

  int howOld() {
    return age;
}

空的构造函数

class Person {
  int age;
  String name;

  int howOld() {
    reutrn age;
  }
}

没有析构函数 => 垃圾回收
命名构造函数
更加方便

class Person {
    int age;
    String name;
    Person(this.age,this.name);
    Person.fromList(List<dynamic>list) {
        age = list[0]
        name = list[1]
    }

    int howOld() {
        return age;
    }
}

void main() {
    Person a = new Person(20,'小A');
    print(a.howOld());

    Person b = new Person.fromList([30,'小B']);
    print(b.howOld());
}

继承与多态

继承
继承一个基类: extends
调用基类方法： super
多态
没有很大差别

class Person {
    int age;
    String name;
    Person(this.age,this.name);
    Person.fromList(List<dynamic>list) {
        age = list[0]
        name = list[1]
    }

    int howOld() {
        return age;
    }
}

class Male extends Person {
    Male(int age, String name) : super(age,name);

    @override
    int howOld() {
        return age + 1;
    }
}

void main() {
    Person a = new Person(20,'小A');
    print(a.howOld());

    Person b = new Person.fromList([30,'小B']);
    print(b.howOld());

    Person c = new Male(20,'小C');
    print(c.howOld());
}

抽象类与接口

抽象类
关键字： abstract
不能实例化
抽象函数：声明但不实现
派生类必须重写抽象类所有的抽象函数

abstract class Person {
    String getName();

    int getAge() {
        return 20;
    }
}

class Male extends Person {
    String getName() {
        return '小A'；
    }
}

void main() {
    Person a = new Person();

    Person b = new Male();
    print(b.getName());
}

接口
关键字： implements
Dart每个类都是接口
必须实现构造函数外所有的成员函数

abstract class Person {
    String getName();

    int getAge() {
        return 20;
    }
}

class Male extends Person {
    String getName() {
        return '小A';
    }
}

class AA implements Male {
    @override 
    int getAge() {
        return 20;
    }

    @override
    String getName() {
        return 'AA';
    }
}

静态与权限

静态与非静态的成员、成员函数

	静态	非静态
修饰	无	static
属于	对象	类
访问	成员、静态成员、成员函数、静态成员函数	只能访问静态成员和静态成员函数

权限
无关键字
使用符号"_" 标识权限
不存在针对类的访问权限，只有针对包(package) 的

异步支持

Future + async + await

异步运算async -> 延迟队列(await) -> 等待结果(Future)

简介一个异步支持
async 与 await(await 关键字必须在async函数内部使用)

void main() {
  String data = '初始化data';
  getData(data);
}

getData(String data) async {
  print(data); //初始化data

  data = await Future.delayed(Duration(seconds: 2),() {
    return '网络数据';
  }) as String;
  
  print(data);//网络数据
}

Future
表示异步操作的最终完成(或失败)
只会有一个结果
返回值仍然是Future类型

Future.then

void main() {
  Future<String> future = getData();
  future.then((data) {
    print(data);
  });
}

Future<String> getData() async {
  return await Future.delayed(Duration(seconds: 2),() {
    return '网络数据';
  });
}

异常错误

void main() {
  Future<String> future = getData();
  future.then((data) {
    print(data);
  }).catchError((e) {
      print(e);
  });
}

Future<String> getData() async {
  return await Future.delayed(Duration(seconds: 2),() {
    throw AssertionError("Error");
  });
}

void main() {
  Future<String> future = getData();
  future.then((data) {
    print(data);
  },onError: (e) {
      print(e);
  });
}

Future<String> getData() async {
  return await Future.delayed(Duration(seconds: 2),() {
    throw AssertionError("Error");
  });
}

Future.whenComplete
标识无论成功或者失败，都会调用
Future.wait
等待多个异步执行任务执行结束后再执行
接受一个Future数组参数

void main() {
  Future.wait([
    Future.delayed(new Duration(seconds: 2),() {
      return "hellow";
    }),
    Future.delayed(new Duration(seconds: 2),() {
      return " worrld";
    })
  ]).then((reuslts) {
    print(reuslts[0] + reuslts[1]);
  }).catchError((e) {
    print(e);
  });
}

文档学习

语法概览
语法概览
博客
简书博客

2023-05-21 dart语法

变量与类型

控制流语句

函数

类和对象

继承与多态

抽象类与接口

静态与权限

异步支持

文档学习

猜你喜欢

热点阅读