[Dart] Definition und Verwendung der 006-Klasse
Artikelverzeichnis
Bei der Programmierung
类besteht der Zweck der Programmierung darin, eine Kapselung zu organisieren数据und功能zu fungieren, die eine Lösung für eine bestimmte Art von Problem oder einen bestimmten Link in der Lösung bereitstellt.
1. Klassendefinition
1. Übersicht
Klassen classwerden durch Schlüsselwörter gefolgt von Wörtern definiert 类的名称. Nach dem Namen {}wird der Umfang der Klassendefinition durch ein angegeben, in dem die Klassen 成员变量und definiert sind 成员方法.
class ${
className}{
// 类体
}
2. Einfache Definition und Instanziierung
Codebeispiel
void main(List<String> arguments) {
// 实例化对象
Student student = Student('张三', 18);
// 访问成员变量
print(student.name);
print(student.age);
// 修改成员变量
student.name = '李四';
student.age = 20;
// 再次访问成员变量
print(student.name);
print(student.age);
}
/// 学生类
class Student {
/// 名字
String name;
/// 年龄
int age;
Student(this.name, this.age);
}
Operationsergebnis
张三
18
李四
20
3. Mitgliedsmethode
Codebeispiel
void main(List<String> arguments) {
// 实例化对象
Student student = Student('张三', 18);
// 调用成员方法，获取学生的基本信息描述
String info = student.getStudentInfo();
// 打印信息
print(info);
}
/// 学生类
class Student {
/// 名字
String name;
/// 年龄
int age;
Student(this.name, this.age);
/// 获取学生的基本信息描述
String getStudentInfo() {
return '姓名：${
this.name}，年龄：${
this.age}';
}
}
Operationsergebnis
姓名：张三，年龄：18
Schreiben von Pfeilfunktionen
/// 获取学生的基本信息描述
String getStudentInfo() => '姓名：${
this.name}，年龄：${
this.age}';
4. Schlüsselwörter abrufen und festlegen
Überblick
getDer Unterschied zur setSchlüsselwortänderung besteht darin 成员方法, dass sie im Wesentlichen nur eine Kurzform sind und häufig für 成员变量die Wartung von verwendet werden. Es ist nur ein syntaktischer Zucker, aber im Wesentlichen ist es immer noch eine Methode.
Codebeispiel
void main(List<String> arguments) {
// 实例化对象
Student student = Student('张三', 18);
// getName
print(student.getName);
// setName
student.setName = '李四';
print(student.getName);
// getStudentInfo
print(student.getStudentInfo);
}
/// 学生类
class Student {
/// 名字
String name;
/// 年龄
int age;
Student(this.name, this.age);
/// 获取名字的get方法
String get getName => name;
/// 设置名字的set方法
set setName (String name) => this.name = name;
/// 获取学生基本信息
String get getStudentInfo => '姓名：$name，年龄：$age';
}
Operationsergebnis
张三
李四
姓名：李四，年龄：18
Zweitens die Konstruktionsmethode der Klasse
1. Funktionen
Als besondere Funktion weist die Konstruktionsmethode einige einzigartige Definitionsmerkmale auf:
- [1] Zum Zeitpunkt der Deklaration gibt es keinen Konstruktor
返回值. - [2] Die Konstruktionsmethode
可以hat keinen Methodenkörper. - [3] Es kann in der Parameterliste übergeben
this.成员und Mitgliedsvariablen zugewiesen werden.
2. Die Konstruktionsmethode der Vollversion
Vereinfachte Version
Student(this.name, this.age);
Vollversion
Student(String name, int age)
: this.name = name,
this.age = age;
3. Benannte Parameter verwenden
Student(this.name, {
required int thisAge }) : age = thisAge;
4. Namensstruktur
Eine Klasse mit mehreren Konstrukten!
/// 学生类
class Student {
/// 名字
String name;
/// 年龄
int age;
/// 默认对象
Student.defaultObj(): name = "訾博", age = 27;
/// 二倍年龄
Student.doubleAge(this.name, int age): age = age * 2;
}
3. Unveränderliche Mitglieder und statische Mitglieder in der Klasse
1. Unveränderliche Mitglieder
Als wir die Mengendefinition früher eingeführt haben, wissen wir, dass
finaldie durch Schlüsselwörter geänderten Mitglieder nur einmal zugewiesen werden können. Wenn eine Mitgliedsvariable einer Klassefinalmit geändert wird, bedeutet dies, dass dieses Mitglied nicht geändert werden darf.
Codebeispiel
void main(List<String> arguments) {
// 实例化对象
Student student = Student('张三', 18);
student.name = "訾博";
}
/// 学生类
class Student {
/// 名字
final String name;
/// 年龄
final int age;
Student(this.name, this.age);
}
Fehler melden
2. Statische Mitglieder
Auf statische Mitglieder
类wird direkt zugegriffen, sie sind nicht an sie angehängt对象.
Codebeispiel
void main(List<String> arguments) {
print(Student.name);
}
/// 学生类
class Student {
/// 名字
static String name = "訾博";
}
Operationsergebnis
訾博
3. Statische Methode
statische
也可以修饰类的成员方法，称为statische Methode
Codebeispiel
void main(List<String> arguments) {
Student.printName("訾博");
}
/// 学生类
class Student {
/// 打印名字
static printName(String name) => print(name);
}
Operationsergebnis
訾博
4. Sichtbarkeit von Mitgliedern und Klassen
In Dart können Mitglieder und Klassen unterschiedliche Sichtbarkeit haben, die durch einige Zugriffsmodifikatoren gesteuert wird. Diese Modifikatoren bestimmen, wo im Code auf eine Klasse oder einen Member zugegriffen werden kann.
In Dart gibt es vier Sichtbarkeitsmodifikatoren:
-
public: Der standardmäßige Sichtbarkeitsmodifikator. Wenn keine Modifikatoren explizit angegeben werden, sind Klassen und Mitglieder standardmäßig öffentlich. Auf öffentliche Mitglieder kann von überall aus zugegriffen werden. -
private:_Bezeichner, die mit einem Unterstrich beginnen, gelten als privat. Auf private Mitglieder kann nur innerhalb derselben Bibliothek (Datei) zugegriffen werden, nicht von außerhalb der Bibliothek.class MyClass { String _privateField; void _privateMethod() { // 私有方法的实现 } } -
protected: In Dart gibt es kein direktes Schlüsselwortprotected, aber Mitglieder können durch Konvention simuliert werdenprotected. Bezeichner, die mit einem Unterstrich beginnen_, gelten innerhalb der Bibliothek als private Mitglieder, können aber von Unterklassen aufgerufen werden.class MyBaseClass { String _protectedField; void _protectedMethod() { // 受保护方法的实现 } } class MyDerivedClass extends MyBaseClass { void accessProtectedMember() { _protectedField = 'Value'; // 可以在子类中访问受保护字段 _protectedMethod(); // 可以在子类中调用受保护方法 } } -
package-private: In Dart gibt es kein direktes Schlüsselwort „package-private“, es kann jedoch durch Konvention emuliert werden. Wenn Sie eine Klasse oder ein Mitglied ohne Sichtbarkeitsmodifikatoren definieren, ist sie auf Paketebene privat. Auf private Mitglieder auf Paketebene kann nur innerhalb desselben Pakets zugegriffen werden.class _PackagePrivateClass { // 包级私有类 } void _packagePrivateFunction() { // 包级私有函数 }