当前位置：首页 > article >正文

【Flutter】Dart：类

article 2024/12/28 23:31:16

在 Dart 中，类（Class）是面向对象编程的核心概念之一，提供了一种封装数据和功能的方式。理解 Dart 中的类以及它的相关特性是开发 Flutter 应用的基础。本教程将深入介绍 Dart 中类的定义、属性、构造函数、方法、接口、Mixin 以及枚举类，帮助你在 Flutter 应用开发中高效使用类。

Dart 中类的定义

在 Dart 中，类的定义使用关键字 class，类通常包含属性（变量）和方法（函数）。一个简单的类定义如下：

class Person {
  String name = '';
  int age = 0;

  void introduce() {
    print('My name is $name and I am $age years old.');
  }
}

在这个 Person 类中，name 和 age 是属性，introduce() 是类中的方法。我们可以通过创建该类的对象来访问这些属性和方法。

创建对象

void main() {
  Person person = Person();
  person.name = 'John';
  person.age = 25;
  person.introduce();  // 输出: My name is John and I am 25 years old.
}

属性

类的属性是它的成员变量，用于存储对象的状态或数据。在 Dart 中，属性既可以是实例变量，也可以是类变量（静态变量）。

实例变量

实例变量是属于对象的，每个对象都有独立的实例变量。它们在类的定义中直接声明，且可以通过对象访问。

class Car {
  String model;
  int year;

  Car(this.model, this.year);
}

静态变量

静态变量属于类而不是对象，它在类级别上共享。静态变量使用 static 关键字声明。

class Car {
  static int totalCars = 0;
  String model;
  int year;

  Car(this.model, this.year) {
    totalCars++;
  }
}

示例

void main() {
  Car car1 = Car('Tesla Model S', 2020);
  Car car2 = Car('BMW M3', 2021);

  print(Car.totalCars);  // 输出 2，表示已经创建了两个 Car 对象
}

构造函数

构造函数是用于创建类对象的方法。它通常用于初始化对象的属性。在 Dart 中，构造函数与类名相同。构造函数可以有多种形式：默认构造函数、命名构造函数、工厂构造函数等。

默认构造函数

当我们为类创建对象时，默认构造函数会被自动调用。以下是通过构造函数初始化类的属性的示例：

class Person {
  String name;
  int age;

  Person(this.name, this.age);  // 默认构造函数
}

命名构造函数

命名构造函数允许我们为一个类定义多个构造函数，每个构造函数有不同的名称。这样可以灵活地创建对象。

class Point {
  double x;
  double y;

  Point(this.x, this.y);

  // 命名构造函数
  Point.origin() {
    x = 0;
    y = 0;
  }
}

初始化列表

构造函数中的初始化列表允许在构造函数体执行之前初始化属性。它通常用于 final 变量。

class Rectangle {
  final int width;
  final int height;
  final int area;

  Rectangle(this.width, this.height) : area = width * height;
}

工厂构造函数

工厂构造函数用于控制对象的创建，并且可以返回现有对象而不是每次都创建新对象。使用 factory 关键字定义。

class Singleton {
  static final Singleton _instance = Singleton._internal();

  factory Singleton() {
    return _instance;
  }

  Singleton._internal();  // 私有构造函数
}

方法

类中的方法是可以执行某些操作的函数。Dart 中的方法可以像函数一样接收参数和返回值。可以在方法中定义常规方法、静态方法和 getter/setter。

实例方法

实例方法是作用于对象实例的方法。

class Circle {
  double radius;

  Circle(this.radius);

  double getArea() {
    return 3.14 * radius * radius;
  }
}

静态方法

静态方法与静态变量类似，属于类而不是对象。它们使用 static 关键字定义。

class MathUtil {
  static int square(int x) {
    return x * x;
  }
}

void main() {
  print(MathUtil.square(5));  // 输出 25
}

Getter 和 Setter

Dart 中可以为属性定义 getter 和 setter 方法，允许控制对属性的访问和修改。

class Student {
  String _name;

  // getter
  String get name => _name;

  // setter
  set name(String name) {
    _name = name;
  }
}

接口（Interface）

在 Dart 中，所有的类都隐式实现了接口，因此可以通过实现某个类来创建接口。接口用于定义一组方法，这些方法必须由实现该接口的类提供。

class Animal {
  void speak() {
    print('Animal is making a sound');
  }
}

class Dog implements Animal {
  @override
  void speak() {
    print('Dog barks');
  }
}

在上面的例子中，Dog 实现了 Animal 的接口，并且必须提供 speak 方法的实现。

Mixin

Mixin 是一种在 Dart 中实现代码复用的方式。它允许类在不继承的情况下获得其他类的功能。Mixin 使用 mixin 关键字定义，并通过 with 关键字使用。

mixin Swimmer {
  void swim() {
    print('Swimming');
  }
}

class Human with Swimmer {}

void main() {
  Human human = Human();
  human.swim();  // 输出: Swimming
}

Mixin 的主要作用是让类可以共享行为，而不必使用复杂的继承层次。

枚举类（Enum）

枚举（enum）用于定义一组常量，常用于表示固定集合的值。Dart 中使用 enum 关键字定义枚举类型。

enum Weather { sunny, rainy, cloudy }

void main() {
  var today = Weather.sunny;

  switch (today) {
    case Weather.sunny:
      print('It\'s a sunny day!');
      break;
    case Weather.rainy:
      print('It\'s raining!');
      break;
    case Weather.cloudy:
      print('It\'s cloudy!');
      break;
  }
}

在这个例子中，Weather 枚举类定义了三种天气情况，switch-case 语句可以根据不同的枚举值执行不同的逻辑。

类的继承

继承是面向对象编程的重要特性之一。在 Dart 中，类可以通过继承其他类来扩展或修改其行为。继承使用 extends 关键字实现。

class Animal {
  void sleep() {
    print('Sleeping');
  }
}

class Dog extends Animal {
  void bark() {
    print('Barking');
  }
}

void main() {
  Dog dog = Dog();
  dog.sleep();  // 输出: Sleeping
  dog.bark();   // 输出: Barking
}

Dog 类继承了 Animal 类，因此它可以访问 Animal 中的 sleep 方法。

抽象类

抽象类（Abstract Class）是不能被实例化的类，通常用于定义一组共同的行为，由子类具体实现。抽象类使用 abstract 关键字定义。

abstract class Shape {
  void draw();  // 抽象方法
}

class Circle extends Shape {
  @override
  void draw() {
    print('Drawing a circle');
  }
}

void main() {
  Circle circle = Circle();
  circle.draw();  // 输出: Drawing a circle
}