目录
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()
例
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() {
CarConstruction newCar = new CarConstruction("E00011");
}
class CarConstruction {
CarConstruction(String engine) {
print("CarConstruction - engine:${(engine)}");
}
}
输出结果
CarConstruction - engine:E00011
命名的构造函数
Dart提供了命名构造函数，以使类定义多个构造函数。
语法
Class_name.constructor_name(param_list)
示例
以下示例显示如何在Dart中使用命名构造函数：
void main() {
CarNomenclative carNomenclative1 = new CarNomenclative.namedConst("carNomenclative - engine");
CarNomenclative carNomenclative2 = new CarNomenclative.speedConst(100);
CarNomenclative carNomenclative3 = new CarNomenclative();
}
class CarNomenclative {
CarNomenclative() {
print("Non-parameterized constructor invoked");
}
CarNomenclative.namedConst(String engine) {
print("The engine is: ${(engine)}");
}
CarNomenclative.speedConst(double speed) {
print("The speed is: ${(speed)}");
}
}
输出结果为:
The engine is: carNomenclative - engine
The speed is: 100.0
Non-parameterized constructor invoked
this 关键字
this关键字指向类的当前实例。这里，参数名称和类字段的名称是相同的。因此，为了避免歧义，类的字段以this关键字为前缀。
示例
以下示例说明如何在Dart中使用this关键字：
void main(){
CarThis newCar = CarThis("E1001");
}
class CarThis {
String engine;
CarThis(String engine) {
this.engine = engine;
print("The engine is : ${(engine)}");
}
}
输出结果
The engine is : E1001
getter和setter方法
getter和setter方法，也称为存取和存取器，允许该程序初始化并分别检索类字段的值。使用get关键字定义getter或访问器。Setter或mutator是使用set关键字定义的。
默认的getter / setter与每个类相关联。但是，可以通过显式定义setter / getter来覆盖默认值。getter没有参数并返回一个值，setter有一个参数并且不返回值。
语法
//定义一个getter
Return_type get identifier
{
}
//定义一个setter
set identifier
{
}
示例
void main() {
Student s1 = new Student();
s1.stud_name = 'MARK';
s1.stud_age = 0;
print(s1.stud_name);
print(s1.stud_age);
}
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 <= 5) {
print("Age should be greater than 5");
} else {
this.age = age;
}
}
int get stud_age {
return 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.calArea();
}
class Shape {
void calArea() {
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 leaf = new Leaf();
leaf.str = "hello";
print("leaf.str: ${(leaf.str)}");
}
class Root {
String str;
}
class Child extends Root {}
class Leaf extends Child {}
类Leaf凭借多层次继承的派生从根和子类的属性。其输出如下：
leaf.str: hello
方法重写
方法重写是子类在其父类中重新定义方法的机制。
示例
void methodOverriding() {
Children children1 = new Children();
children1.m1(10);
}
class Parent {
void m1(int a) {
print("value of a ${a}");
}
}
class Children extends Parent {
@override
void m1(int b) {
print("value of b ${b}");
}
}
输入结果为：
value of b 10
注意：重写方法时，函数参数的数量和类型必须匹配。如果参数数量或其数据类型不匹配，Dart编译器会抛出错误。
示例
void methodOverriding() {
Children children1 = new Children();
children1.m1(10);
}
class Parent {
void m1(int a) {
print("value of a ${a}");
}
}
class Children extends Parent {
@override
void m1(String b) {
print("value of b ${b}");
}
}
输出如下报错：
Compiler message:
lib/Class.dart:181:18: Error: The parameter 'b' of the method 'Children.m1' has type 'String', which does not match the corresponding type, 'int', in the overridden method, 'Parent.m1'.
Change to a supertype of 'int', or, for a covariant parameter, a subtype.
void m1(String b) {
^
lib/Class.dart:175:8: Context: This is the overridden method ('m1').
void m1(int a) {
^
lib/Class.dart:171:16: Error: The argument type 'int' can't be assigned to the parameter type 'String'.
children1.m1(10);
^
static关键字
static关键字可以应用于一类，即，数据成员字段和方法。静态变量保留其值，直到程序完成执行。静态成员由类名引用。
示例
void staticKeyword() {
StaticMem.num = 12;
StaticMem.disp();
}
class StaticMem {
static int num;
static disp() {
print("The value of num is ${StaticMem.num}") ;
}
}
输出结果为:
The value of num is 12
super关键字
super关键字用来指一类的直接父类。关键字可用于引用变量，属性或方法的超类。
示例
void superKeyword() {
NewChild newChild = new NewChild();
newChild.m1(12);
}
class NewParent {
String msg = "message variable from the parent class";
void m1(int a){
print("value of a ${(a)}");
}
}
class NewChild extends NewParent {
@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
1291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
