Dart编程 - 类

上一页
下一页

Dart 是一种面向对象的语言。它支持面向对象的编程特性，例如类、接口等。在 OOP 中，类是创建对象的蓝图。类封装了对象的数据。Dart 内置支持这种称为类的概念。

声明一个类

使用class关键字在 Dart 中声明一个类。类定义以关键字 class 开头，后跟类名；以及由一对花括号括起来的类体。语法如下：

语法

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

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

类定义可以包括以下内容：

  • 字段 - 字段是在类中声明的任何变量。字段表示与对象相关的数据。

  • Setter 和 Getter - 允许程序初始化和检索类的字段值。每个类都关联一个默认的 getter/setter。但是，可以通过显式定义 setter/getter 来覆盖默认值。

  • 构造函数 - 负责为类的对象分配内存。

  • 函数 - 函数表示对象可以执行的操作。它们有时也称为方法。

这些组件合在一起被称为类的数据成员。

示例：声明一个类

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

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

创建类的实例

要创建类的实例，请使用new关键字后跟类名。语法如下：

语法

var object_name = new class_name([ arguments ])

  • new关键字负责实例化。

  • 表达式的右侧调用构造函数。如果构造函数是参数化的，则应向其传递值。

示例：实例化一个类

var obj = new Car("Engine 1")

访问属性和函数

可以通过对象访问类的属性和函数。使用“.”点表示法（称为句点）来访问类的成员。

//accessing an attribute 
obj.field_name  

//accessing a function 
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 构造函数

构造函数是类的特殊函数，负责初始化类的变量。Dart 使用与类名相同的名称定义构造函数。构造函数是一个函数，因此可以是参数化的。但是，与函数不同，构造函数不能有返回类型。如果不声明构造函数，则会为您提供默认的无参数构造函数。

语法

Class_name(parameter_list) { 
   //constructor body 
}

示例

以下示例显示如何在 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关键字为前缀。以下示例对此进行了说明：

示例

以下示例说明如何在 Dart 中使用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

Dart 类 ─ Getter 和 Setter

Getter和Setter，也称为访问器和修改器，分别允许程序初始化和检索类字段的值。Getter 或访问器使用get关键字定义。Setter 或修改器使用set关键字定义。

每个类都关联一个默认的 getter/setter。但是，可以通过显式定义 setter/getter 来覆盖默认值。getter 没有参数并返回值，而 setter 有一个参数且不返回值。

语法：定义 getter

Return_type  get identifier 
{ 
}

语法：定义 setter

set identifier 
{ 
}

示例

以下示例显示如何在 Dart 类中使用getter和setter：

在线演示 
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

类继承

Dart 支持继承的概念，即程序能够从现有类创建新类。用于扩展以创建新类的类称为父类/超类。新创建的类称为子类/子类。

类使用“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

继承的类型

继承可以分为以下三种类型：

  • 单继承 - 每个类最多可以从一个父类继承。

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

  • 多层继承 - 一个类可以从另一个子类继承。

示例

以下示例显示多层继承的工作方式：

在线演示 
void main() { 
   var obj = new Leaf(); 
   obj.str = "hello"; 
   print(obj.str); 
}  
class Root { 
   String str; 
}  
class Child extends Root {}  
class Leaf extends Child {}  
//indirectly inherits from Root by virtue of inheritance

Leaf类通过多层继承派生自Root和Child类的属性。其输出如下：

hello

Dart – 类继承和方法覆盖

方法覆盖是一种机制，子类通过它重新定义其父类中的方法。以下示例对此进行了说明：

示例

在线演示 
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关键字可以应用于类的成员，即字段和方法。静态变量保留其值，直到程序执行结束。静态成员由类名引用。

示例

在线演示 
class StaticMem { 
   static int num;  
   static disp() { 
      print("The value of num is ${StaticMem.num}")  ; 
   } 
}  
void main() { 
   StaticMem.num = 12;  
   // initialize the static variable } 
   StaticMem.disp();   
   // invoke the static method 
}

它应该产生以下输出：

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
打印页面
上一页
下一页
广告
© . All rights reserved.