炫酷的dart

花了几个小时简单了解了下dart

准备为flutter的学习打基础

总览

int 的默认值是 null
类里面的属性为null编译不给过

命名规则

类:大驼峰
公共方法属性:小驼峰
私有属性方法:_小驼峰

操作符

~/ 整除

5 ~/ 2 //返回2

??= 如果空则赋值，2.x好像失效了

int b;
b??=23；

..级联运算符

.运算符可以调用类里面的成员,如果返回的是同一类则可以链式调用
而..就很炫酷了,你可以省略掉类名连续调用,也就说不用特意为了链式调用设计成让方法返回类型本身

▼ 折叠代码 [共 21 行]

void main() {
  A()
    ..print1()
    ..print2()
    ..print3();
}
 
class A {
  print1() {
    print(1);
  }
 
  print2() {
    print(2);
  }
 
  print3() {
    print(3);
  }
}

三目运算

bool flag = true;
int num = flag ? 1 : 2;

??运算符

var a;
var b = a ?? 10; //a为空返回10

包导入

导入后即可方法文件内的类和函数

import 'lib/Persion.dart'

变量定义

使用var或者具体类型声明

▼ 折叠代码 [共 7 行]

var a = 1;
int b = 1;
 
//使用 final或const定义不可变
//final 可以变一次，const 编译时常量
//使用 late 修饰表示一个可空的变量

一些类型

▶ 展开代码 [共 33 行]

double c = 1.0;
String d = '${a}'; //$是模板插值，字符串可以使用''或者""
 
//可空
String? name;
 
//list
var list = [1,"2","3"];
list.add("aa");
list.add(1);
 
//强制类型的list
List<int> list = [];
List<int> list = [1,2, 3];
 
//maps
var p = {"name": "jake", "age": 11};
 
var p2 = new Maps();
p2["age"] = 1;
 
//类型判断，转换
var str = "";
print(str is String);
try {
  print(double.parse(str));
} catch (e) {
  print(e);
}
print(1.toString());
print(''.isEmpty);
print(data.runtimeType); //查看类型

枚举

enum Color { red, green, blue }

类

属性成员初始化不可以为空，为空无法通过编译

▶ 展开代码 [共 38 行]

void main() {
  Persion.eat();
  new Persion.eat();
}
 
class Person {
  String name = "";
  int age = 0;
 
  //静态成员，通过类名获取
  static int aaa = 1;
 
  //构造函数初始化赋值,第一次看这个写法非常疑惑，后来才想起c#写构造函数赋值的痛处
  Person(this.name, this.age) {}
 
  //构造器初始化列表，这倒是不太习惯
   Person()
      : name = "1",
        age = 2 {
    print(222);
  }
 
  //命名构造函数
  Person.eat() {
    print("这是命名构造函数");
  }
 
  //getter setter
  get height {
    return 1;
  }
 
  String _sex = "";
  set sex(String value) {
    _sex = value;
  }
}

类型初始化

初始化类 new Person(),或者省略new直接 Person()

继承 extends

super表示父类的构造函数

▼ 折叠代码 [共 17 行]

void main() {
  Person p = Man(1);
  print(p.name);
}
 
//继承
class Man extends Person {
  Man(int age) : super(age);
}
 
class Person {
  String name = ";";
  Person(int age) {
    print("父类的构造器");
  }
}

抽象类

▼ 折叠代码 [共 14 行]

abstract class Animal {
  eat();
  void run(){
    print("run")
  }
}
 
class Dog extends Animal {
  @override
  eat() {
    print("我吃屎");
  }
}

接口 implements

实现多个接口使用逗号分割 class A implements B,C

▼ 折叠代码 [共 10 行]

abstract class ORM {
  add();
  delete();
  update();
}
 
class Mysql implements ORM {
 //必须完全实现上面三个方法
}

mixins 不是继承也不是接口，我称他为：类合并器

▼ 折叠代码 [共 19 行]

void main() {
  C().printInfo();
}
 
//合并2个类的成员，相同会被后面的覆盖
class C with A, B {}
 
class A {
  void printInfo() {
    print('A');
  }
}
 
class B {
  void printInfo() {
    print('B');
  }
}

方法

void 是返回类型，可以不写，编译器会自动推断你的返回值

▼ 折叠代码 [共 13 行]

//[]包裹的是可选参数和默认参数
void printInfo(String name, [int? age, int height = 10]) {
  print("${name},${age},${height}");
}
 
//{}包裹的是命名参数
void printInfo2(String name, {int? age, int height = 10}) {
  print("${name},${age},${height}");
}
printInfo("tom"); //tom,null,10
printInfo2("jake56", age: 20, height: 111); //jake56,20,111
 

方法当参数传入

▼ 折叠代码 [共 15 行]

//方法当参数传入
void doWork1() {
  print("--1");
}
 
void doWork2(String name) {
  print(name);
}
 
void wrap(fn1, fn2(String n), String name) {
  fn1();
  fn2(name);
}
wrap(doWork1, doWork2, "aa"); //先打印--1，再打印aa

箭头函数， =>只能接一行戴安

var a = 1;sau
var fn1 = (int n) => print(a += n);
fn1(5);

定义完函数直接调用

((n) {
print(n);
})(200);

泛型

▼ 折叠代码 [共 10 行]

void main() {
  getData<int>(12);
  getData<String>('AA');
}
 
//泛型方法
T getData<T>(T value) {
  return value;
}

不学了 不学了 头秃了