Dart 编程 - 类
Dart 是一种面向对象语言。它支持面向对象编程功能，如类、接口等。就 OOP 而言，类 是创建对象的蓝图。类 封装了对象的数据。Dart 为这个称为 类 的概念提供内置支持。
声明类
使用 class 关键字在 Dart 中声明 类。类定义以关键字 class 开头，后跟 类名；类主体用一对花括号括起来。其语法如下 −
语法
class class_name {
<fields>
<getters/setters>
<constructors>
<functions>
}
class 关键字后面是类名。命名类时必须考虑标识符的规则。
类定义可以包含以下内容 −
字段 − 字段是类中声明的任何变量。字段表示与对象相关的数据。
Setter 和 Getter − 允许程序初始化和检索类字段的值。每个类都关联一个默认的 getter/setter。但是，可以通过明确定义 setter/getter 来覆盖默认的 getter/setter。
构造函数 − 负责为类的对象分配内存。
函数 − 函数表示对象可以采取的操作。它们有时也被称为方法。
这些组件组合在一起称为类的数据成员。
示例：声明一个类
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")
访问属性和函数
可以通过对象访问类的属性和函数。使用"."点符号（称为句点）访问类的数据成员。
//访问属性 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 构造函数
构造函数是类的一个特殊函数，负责初始化类的变量。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 关键字作为前缀。以下示例解释了相同的 −
示例
以下示例解释了如何在 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 或访问器。使用 set 关键字定义 Setter 或更改器。
每个类都关联一个默认的 getter/setter。但是，可以通过明确定义 setter/getter 来覆盖默认的 getter/setter。getter 没有参数并返回一个值，而 setter 有一个参数并且不返回值。
语法：定义 getter
Return_type get identifier
{
}
语法：定义 setter
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
类继承
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 {}
//通过继承间接继承自 Root
类 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
