Dart - 类

Dart是一种面向对象的语言，它支持面向对象的编程函数，如类，接口等，就OOP而言， class类是用于创建对象， class类封装对象的数据。

声明类

使用 class 关键字在Dart中声明一个 class ，类定义以关键字class开头，后跟类名，class的主体被一对大括号包围。

class class_name {  
   <fields> 
   <getters/setters> 
   <constructors> 
   <functions> 
}

class 关键字后跟类名称，命名类时必须考虑标识符规则。

示例  -  声明类

class Car {  
   //field 
   String engine="E1001";  
   
   //function 
   void disp() { 
      print(engine); 
   } 
}

该示例声明了一个 Car 类。该类具有一个名为 engine 的字段， disp()是一个简单的函数，可打印 engine 字段的值。

创建类

要创建类的，请使用 new 关键字，后跟类名称。

var object_name=new class_name([ arguments ])

示例  -  实例化类

var obj=new Car("Engine 1")

访问属性和函数

可以通过对象访问类的属性和函数，使用"."点表示法来访问类的数据成员。

//访问属性
obj.field_name  

//访问函数
obj.function_name()

请看以下示例，以了解如何在Dart中访问属性和函数-

void main() { 
   Car c= new Car(); 
   c.disp(); 
}  
class Car {  
   //field 
   String engine="E1001";  
   
   //function 
   void disp() { 
      print(engine); 
   } 
}

上面代码的输出如下-

E1001

构造器

构造函数是类的特殊函数，负责初始化类的变量， Dart定义了一个与该类同名的构造函数。

Class_name(parameter_list) { 
   //构造函数体
}

以下示例显示如何在Dart中使用构造函数-

void main() { 
   Car c=new Car('E1001'); 
} 
class Car { 
   Car(String engine) { 
      print(engine); 
   } 
}

它应该产生以下输出-

无涯教程网

E1001 

构造函数

Dart提供了命名构造函数，以使类可以定义多个构造函数。命名构造函数的语法如下所示-

语法 - 定义构造函数

Class_name.constructor_name(param_list)

以下示例显示了如何在Dart中使用命名构造函数-

void main() {           
   Car c1=new Car.namedConst('E1001');                                       
   Car c2=new Car(); 
}           
class Car {                   
   Car() {                           
      print("Non-parameterized constructor invoked");
   }                                   
   Car.namedConst(String engine) { 
      print("The engine is : ${engine}");    
   }                               
}

它应该产生以下输出-

无涯教程网

The engine is : E1001 
Non-parameterized constructor invoked

This关键字

this 关键字引用该类的当前，在这里，参数名称和类别字段的名称是相同的，因此，为避免歧义，该类的字段以 this 关键字为前缀。

void main() { 
   Car c1=new Car('E1001'); 
}  
class Car { 
   String engine; 
   Car(String engine) { 
      this.engine=engine; 
      print("The engine is : ${engine}"); 
   } 
} 

它应该产生以下输出-

无涯教程网

The engine is : E1001

Getter和Setters 

Getters 和 Setters ，也称为 accessors 和 mutators ，允许程序初始化和检索类的值字段，获取器或访问器是使用 get 关键字定义的，设置器或更改器是使用 set 关键字定义的。

语法  -  定义访问器

Return_type  get identifier 
{ 
} 

语法  -  定义设置器

set identifier 
{ 
}

以下示例说明了如何在Dart类中使用 getters 和 setters -

class Student { 
   String name; 
   int age; 
    
   String get stud_name { 
      return name; 
   } 
    
   void set stud_name(String name) { 
      this.name=name; 
   } 
   
   void set stud_age(int age) { 
      if(age<= 0) { 
        print("Age should be greater than 5"); 
      }  else { 
         this.age=age; 
      } 
   } 
   
   int get stud_age { 
      return age;     
   } 
}  
void main() { 
   Student s1=new Student(); 
   s1.stud_name='MARK'; 
   s1.stud_age=0; 
   print(s1.stud_name); 
   print(s1.stud_age); 
} 

该程序代码应产生以下输出-

Age should be greater than 5 
MARK 
Null 

类继承

使用" extends"关键字从另一个类继承，子类继承父类的构造函数，但继承所有属性和方法。

class child_class_name extends parent_class_name 

注意-Dart不支持多重继承。

示例  -  类继承

在下面的示例中，我们声明了一个 Shape 类，该类由 Circle 类扩展，由于类之间存在继承关系，因此子类，即 Car 类可以隐式访问其父类数据成员。

void main() { 
   var obj=new Circle(); 
   obj.cal_area(); 
}  
class Shape { 
   void cal_area() { 
      print("calling calc area defined in the Shape class"); 
   } 
}  
class Circle extends Shape {}

它应该产生以下输出-

无涯教程网

calling calc area defined in the Shape class

继承类型

继承可以是以下三种类型-

• Single           -  每个类最多可以从一个父类扩展。

• Multiple       -  一个类可以从多个类继承， Dart不支持多重继承。

• Multi-level  -  一个类可以从另一个子类继承。

以下示例显示了多级继承的工作方式-

void main() { 
   var obj=new Leaf(); 
   obj.str="hello"; 
   print(obj.str); 
}  
class Root { 
   String str; 
}  
class Child extends Root {}  
class Leaf extends Child {}  
//通过继承间接从Root继承

Leaf 类通过多级继承从Root和Child类派生属性，其输出如下-

hello

方法覆盖

方法覆盖是子类在其父类中重新定义方法的机制，以下示例说明了相同的内容-

void main() { 
   Child c=new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} 
}  
class Child extends Parent { 
   @override 
   void m1(int b) { 
      print("value of b ${b}"); 
   } 
}

它应该产生以下输出-

无涯教程网

value of b 12

覆盖方法时，函数参数的数量和类型必须匹配，如果参数数量或数据类型不匹配，则Dart编译器将引发错误。下图说明了相同的内容-

import 'dart:io'; 
void main() { 
   Child c=new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} 
} 
class Child extends Parent { 
   @override 
   void m1(String b) { 
      print("value of b ${b}");
   } 
}

它应该产生以下输出-

无涯教程网

value of b 12

Static关键字

可以将 static 关键字应用于类的数据成员，即 fields 和 methods ，static 变量将保留其值，直到程序完成执行，static 成员由类名称引用。

class StaticMem { 
   static int num;  
   static disp() { 
      print("The value of num is ${StaticMem.num}")  ; 
   } 
}  
void main() { 
   StaticMem.num=12;  
   //初始化静态变量 
   StaticMem.disp();   
   //调用静态方法
}

它应该产生以下输出-

无涯教程网

The value of num is 12

Super关键字

super 关键字用于引用类的直接父级，关键字可用于引用变量，属性或方法的超类版本。以下示例说明了相同的内容-

void main() { 
   Child c=new Child(); 
   c.m1(12); 
} 
class Parent { 
   String msg="message variable from the parent class"; 
   void m1(int a){ print("value of a ${a}");} 
} 
class Child extends Parent { 
   @override 
   void m1(int b) { 
      print("value of b ${b}"); 
      super.m1(13); 
      print("${super.msg}")   ; 
   } 
}

它应该产生以下输出-

无涯教程网

value of b 12 
value of a 13 
message variable from the parent class