Dart编程类

Dart是一种面向对象的语言。它支持面向对象的编程功能，如类，接口等。OOP方面的类是创建对象的蓝图。类为对象封装的数据。Dart为这个名为class的概念提供了内置支持。

声明类

使用class关键字在Dart中声明一个类。类定义以关键字class开头，后跟类名 ; 并且由一对花括号{}包围的类体。下面给出了相同的语法

语法

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

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

类定义可包括以下内容

  • <fields>字段 - 字段是类中声明的任何变量。字段表示与对象有关的数据。
  • <getters/setters>get和set方法 - 允许程序初始化和检索类字段的值。默认的getter/setter与每个类相关联。但是，可以通过显式定义setter/getter来覆盖默认值。
  • <constructors>构造函数 - 负责为类的对象分配内存。
  • <functions>函数 - 函数表示对象可以采取的操作。它们有时也被称为方法。

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

示例：声明一个类

class Car {  
   // 字段
   String engine = "E1001";  

   // 方法
   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 {  
   // 字段
   String engine = "E1001";  

   // 函数（方法）
   void disp() {
      print(engine);
   }
}

上述代码的输出如下

E1001

构造方法（函数）

构造函数是类的特殊函数，负责初始化类的变量。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方法，也称为存取和存取器，允许该程序初始化并分别检索类字段的值。使用get关键字定义getter或访问器。Setter或mutator是使用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凭借多层次继承的派生从根和子类的属性。其输出如下

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