Dart学习笔记

2024-02-24 20:11:40

第一次发博客，整个排版不是很美观，最近一直在研究dart（flutter的灵魂，我是这么认为，光搞组件没啥太大意义），可能是*搞多了，Google陷得有点深，所以把一些自己觉得有用的东西做成个文档，把一些核心的东西写了写，慢慢一点点完善吧，最终做成个完整的学习文档，也算对得起学过dart，另外哪位大神能给我普及普及Dart官网上说的，这鬼东西能和物联网结合，现在应该还没有实例吧

元数据

元数据以@开头，可以给代码标记一些额外的信息
元数据可以用在库、类、构造器、函数、字段、参数和变量声明的前面

@override（重写）

某方法添加该注释后，表示重写了父类中的同名方法

@required（必填）

可以通过@required来注解Dart中的命名参数，用来指示它是必填参数

@deprecated（弃用）

若某类或某方法加上注解之后，表示此方法或类不再建议使用

void main(){
    Phone p=Phone();
    p.active();
}

class Phone{
    @deprecated
    active(){
        turnOn();
    }
    
    turnOn(){
        print('开机');
    }
}

继承

根据类的先后顺序，可以将类分成父类和子类
子类通过extends关键字继承父类
- 继承后，子类可以使用父类中，可见的内容（属性和方法）
子类中，可以通过@override元数据来标记“覆写”方法
- “覆写”方法：子类中与父类中同名的方法
子类中，可以通过super关键字来引用父类中，可见内容
- 属性
- 方法（普通构造函数，命名构造函数）

//简单的继承关系
void main(){
    var f=Father();
    print(f.name);
    
    var s=Son();
    print(s.name);
    s.say();
    
}
class Father{
    String name="刘备";
    num money=1000;
    say(){
        print('我是$name');
    }
}
class Son extends Father{
    @override
    say(){
        print('我是刘禅');
    }
}

//私有属性及方法的访问，Father类
class Father{
	String name='刘备';
	num _money=1000;
	
	say(){
		print('我的名字是$name');
	}
	
	get getMoney(){
		print('国库有$_money');
	}
}

//私有属性及方法访问，Son类
class Son extends Father{
	@override
	say(){
		print('我是刘禅');
		super.getMoney();
	}
	
}

void main(){
    var f=Father();
    var s=Son();
    s._getMoney;  
}

静态属性和方法

Dart中的静态成员
- 使用static关键字来实现类级别的变量和函数
- 静态方法不能访问非静态成员，非静态方法可以访问静态成员（并且不用使用this来指定）
- static 静态方法的优缺点：
  
  特点：1、static修饰的方法和变量，为类所属方法和变量，不会在对象销毁时销毁，所以生命周期较长。
  
  2、被static修饰的内容会随着类的加载而加载，优先于对象存在，成员变量和成员方法可以通过类名直接调用并被该类下所有对象共享。
  
  3、在static方法中，不能出现this，super，因为其优先于对象存在。
  
  使用：在同一类中，当某一数据被所有实例化对象共享时，可以用static修饰。

void main(){
    Person p=Person();
    p.get();
    Person.getInfo();
}

class Person{
    static String name;
    static void getInfo(){
        print('这是一个静态方法');
    }
    void get(){
        getInfo();
    }
}

对象操作符

Dart中的对象操作符：

？条件运算符
as 类型转换
is 类型判断
… 级联操作

class Person{
    String name;
    num age;
    Person(this.name,this.age);
    void printInfo(){
        print('${this.name}-----${this.age}');
    }
}

void main(){
    Person p=Person('冬宝',1);
    p.printInfo();//由于p只指定了类型，并没有实例化，所以会报错，引入条件运算符应用可以进行判断
    p?.printInfo();//当前不会报错，利用？条件运算符先进行判断p是否为空（也就是是否被实例化），如果为空那么不调用方法
    （没啥用，新版本不好使）
        
    if(p is Person){
        p.name='winlong';
    }
    //级联操作符，简化操作对象重新赋值
    p..name='xuena'
     ..age=12
     ..printInfo();
}

类的继承

面向对象的三大特性：封装、继承、多态
Dart中的类继承：
- 子类使用extends关键词来继承父类
- 子类会继承父类里面可见的属性和方法，但不会继承构造函数
- 子类能复写父类的方法，getter和setter
- 子类调用父类方法格式为super.xxx();

class Person{
    String name;
    num age;
    
    void printInfo(){
        print('${this.name}-----${this.age}');
    }
}

class Student extends Person{
    
}

void main(){
    var s=Student();
    print(s.name);
    s.printInfo();
}

class Person {
  String name;
  num age;

  Person(this.name, this.age);

  void printInfo() {
    print('${this.name}-----${this.age}');
  }
}

class Student extends Person {
  String sex;
  Student(name, age,sex) : super(name, age){
      this.sex=sex;
  };//继承父类构造函数,注意参数的互相传递,同时子类的构造方法也可以创造自己的属性，并传值
}

void main() {
  Student s = Student('国珍', 59);//实例化子类给父类传参
  print(s.name);
  s.printInfo();
}

抽象类

Dart中抽象类：Dart抽象类主要用于定义标准，子类可以继承

抽象类，也可以实现抽象类的接口

抽象类通过abstract 关键字来定义
Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法
如果子类继承抽象类必须得实现里面的抽象方法
如果把抽象类当做接口实现必须得实现抽象类里面定义的所有属性和方法
抽象类不能被实例化，只有继承它的子类可以

extends抽象类和implements的区别：

如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类
如果只是把抽象类当做标准的话我们就用implements实现抽象类

案例：定义一个Animal类要求它的子类必须包含eat方法

abstract class Animal {
  eat();
}

class Dog extends Animal {
  @override
  eat() {
    print('Dog is eating');
  }

  run() {
    print('这是一个普通方法');
  }
}

void main(List<String> args) {
  var d = Dog();//抽象类无法直接被实例化，只有它的子类可以被实例化
  d.eat();
  d.run();
}

多态

Dart中的多态：

允许将子类类型的指针赋值给父类类型的指针，同一个函数调用会有不同的执行结果
子类的实例赋值给父类的引用
多态就是父类定义一个方法不去实现，让继承它的子类去实现，每个子类有不同的表现

abstract class Animal {
  eat();
}

class Cat extends Animal {
  @override
  eat() {
    print('小猫吃鱼');
  }

  run() {
    print('小猫跑得快');
  }
}

void main(List<String> args) {
  Animal c = Cat();
  c.eat();
  //c.run();访问不到，因为子类实例赋值给了父类引用，所以Animal类型的c只能使用父类的方法
}

接口

和Java一样，dart也有接口，但是和Java还是有区别的。

首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现

同样使用implements关键字进行实现

但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部

需要覆写一遍

而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类

建议使用抽象类定义接口

接口就是：约定，规范

需求：定义一个DB库，支持MySQL，msSQL，MongoDB

MySQL，msSQL，MongoDB三个类里面都有同样的方法

abstract class DB {
  connection();
}

class MySQL implements DB {
  @override
  connection() {
    print("连接");
  }
}

void main(List<String> args) {
  var m = MySQL();
  m.connection();
}

一个类实现多个接口

在OOP中一个类可以实现多个接口，打个比方就是一台电脑可以插好几个USB设备（移动硬盘，U盘，电子书等等），并且必须重写接口中的所有方法（也就是你这台电脑插了好多个设备你得能识别，并且让这些设备可用），但是注意多个类不能同时实现一个接口，打个比方多态电脑不能同时使用一个U盘。

abstract class Run{
    jogging();
    crashing();
}

abstract class Eat{
    slowlyEat();
    quicklyEat();
}

class Person implements Run,Eat{
    @override
    jogging(){
        print('散步');
    }
    @override
    crashing(){
        print('冲刺');
    }
    @override
    slowlyEat(){
        print('细嚼慢咽');
    }
    @override
    quicklyEat(){
        print('大口朵颐');
    }
}
void main(){
    var p=Person();
    p.jogging();
    p.crashing();
    p.slowlyEat();
    p.quicklyEat();
}

码农公寓

元数据