dart总结(三.类,接口,继承,多态,mixins和枚举详解)

最新推荐文章于 2024-05-30 16:17:46 发布

原创

最新推荐文章于 2024-05-30 16:17:46 发布 · 948 阅读

4 ·

CC 4.0 BY-SA版权

本文详细介绍了Dart编程中的Object类、类的声明与构造函数、静态属性和方法、抽象方法与接口、多态、继承、mixins以及枚举的使用。通过实例展示了如何声明、实例化和操作这些概念，帮助读者深入理解Dart的面向对象特性。

Object类

Dart中所有的东西都是对象，所有的对象都继承自Object类.

普通类的声明

特点:用new关键字实例化

  class Class01{
   
   
    //变量
    int a;
    String b;
    var c=3;
    //函数
    void fun01(int d){
   
   
    }
    String fun2(){
   
   
      return b;
    }
  }
void main(){
   
   
//记住练习类要在main函数外面创建,里面会报错
  var class01= new Class01();
  print(class01.c);//3
  class01..a=1..b="b";//..级联操作符可以连续调用类的属性进行赋值
  print(class01.a);//1
  print(class01.b);//'b'
}

类属性和类方法(也叫静态属性和静态方法)

特点:使用static关键字来声明

main(List<String> args) {
   
   
  // static关键字声明的类属性和类方法不用实例直接可以使用类名点的方法来调用.
  Person.courseTime = "8:00";
  print(Person.courseTime); //8:00

  Person.gotoCourse();//去上课
}

class Person {
   
   
  // 成员变量
  String name;

  // 静态属性(类属性)
  static String courseTime;

  // 对象方法
  void eating() {
   
   
    print("eating");
  }

  // 静态方法(类方法)
  static void gotoCourse() {
   
   
    print("去上课");
  }
}

默认构造函数

class Class02{
   
   
  //变量
  int a =3;
  //未声明构造函数,有下面默认构造函数
  Class2(){
   
   }
}

void main (){
   
   
 var class02=new Class02();//正常实例化
 print(class02.a);//3
}

自定义构造函数

class Class03{
   
   
  int a;
  String b;
  // 自定义构造函数
  Class03(int a,String b){
   
   
    this.a=a;
    this.b=b;
  }
}

void main (){
   
   
 var class03=new Class03(1, "a");
 print(class03.a);//1
 print(class03.b);//a
}

上面简写

class Class03{
   
   
  int a;
  String b;
  // 自定义构造函数简写
  Class03(this.a,this.b);
}
void main (){
   
   
  var class03 =new Class03(1, "a");
  print(class03.a);//1
 print(class03.b);//a
}

命名构造函数

其实就是一种可以为类声明多个不同的构造函数.

class Class03{
   
   
  int a;
  String b;
  Class03(int a,String b){
   
   
    this.a=a;
    this.b=b;
  }
  Class03.fun1(int a){
   
   
    this.a=a;
  }
  Class03.fun2(String b){
   
   
    this.b=b;
  }
}

void main (){
   
   
  var class03=new Class03(4, "d");
  var class04=new Class03.fun1(5);
  var class05=new Class03.fun2('d');
  print(class04.a);//5
  print(class05.b);//'d'
}

静态构造函数(也叫常量构造函数)

特点:
1.用final关键字修饰变量,
2.用const修饰构造函数,
3.实例化使用的是const关键字(并不是new关键字)
4.可以创建相同的对象.

class Class04{
   
   
  // 用final修饰常量
  final int a;
  final String b;
  // 用const 修饰构造函数
  const Class04(this.a,this.b);
  //普通函数
  void fun01(){
   
   
    print("aa");
  }
}

void main (){
   
   
  var class04=const Class04(1, "a");
  print(class04.a);//1
  class04.fun01();//aa
}


main(List<String> args) {
   
   
  var p1 = const Person('why');//赋值时const关键字可以省略
  var p2 = const Person('why');
  print(identical(p1, p2)); // true
}

class Person {
   
   
  final String name;

  const Person(this.name);
}

重定向构造函数

class Class05{
   
   
  int a;
  String b;
  Class05(int a,String b){
   
   
    this.a=a;
    this.b=b;
  }
  Class05.fun1(int a){
   
   
    this.a=a;
  }
  // 重定向构造函数
  Class05.fun2(String b):this.fun1(33);//重定向到函数fun1
  Class05.fun3(String b):this(33,"ccc");//重定向到构造函数Class05
}

void main (){
   
   
 var class05 =new Class05(55, "fff");
 print(class05.a);//55
 var class06=new Class05.fun2("hhh");
 print(class06.a);//33,被重定向到了fun1
 var class07=new Class05.fun3("hhh");
 print(class07.a);//33,被重定向到了构造函数Class05
 print(class07.b);//ccc,被重定向到了构造函数Class05

工厂构造函数

特点:
1.使用facory关键字声明构造函数;
2.跟普通构造函数区别,在factory构造函数里需要手动return一个对象;

class Class06 {
   
   
  int a;
  static Class06 instance; //这里用static关键字创建一个单例
  factory Class06(int a) {
   
   
    //这里的构造函数用factory修饰，使用new时，不再是创建一个全新的实例了，而是通过函数体内return获取到实例
    if (instance == null) {
   
   
      instance = new Class06.fun1(a);
    }
    return instanc