TypeScript Zugriffsmodifikatoren
Zugriffsmodifikatoren sind eine der Kernfunktionen der objektorientierten Programmierung in TypeScript.
Sie werden verwendet, um die Sichtbarkeit von Klassenmitgliedern (Eigenschaften, Methoden, Konstruktoren) zu steuern.
Durch Zugriffsmodifikatoren kann Kapselung erreicht werden, wodurch die internen Implementierungsdetails einer Klasse geschützt werden.
SVG-Diagramm: Gültigkeitsbereich von Zugriffsmodifikatoren
Warum brauchen wir Zugriffsmodifikatoren?
Kapselung ist eines der drei Prinzipien der objektorientierten Programmierung.
Kapselung bedeutet, Daten und die Methoden, die auf den Daten operieren, zu verbergen und nur die notwendigen Schnittstellen nach außen freizugeben.
Zugriffsmodifikatoren sind das Mittel zur Erreichung der Kapselung; sie steuern den Sichtbarkeitsbereich von Klassenmitgliedern.
Konzepterklärung:Zugriffsmodifikatoren bestimmen, wo auf Klassenmitglieder zugegriffen werden kann. TypeScript bietet drei Zugriffsmodifikatoren: public, protected und private.
public-Modifikator
public ist der Standard-Zugriffsmodifikator, das heißt, auf Mitglieder kann überall zugegriffen werden.
Ob innerhalb der Klasse, in einer Unterklasse oder außerhalb der Klasse, auf public-Mitglieder kann zugegriffen werden.
Beispiel
class Animal {
// Verwende public, um die name-Eigenschaft zu ändern (kann weggelassen werden, standardmäßig public)
public name: string;
// Konstruktor
public constructor(name: string) {
this.name = name;
}
// Öffentliche speak-Methode
public speak(): void {
console.log(this.name + " makes a sound");
}
}
// Eine Instanz erstellen
var animal = new Animal("Animal");
// Zugriff auf öffentliche Eigenschaft außerhalb der Klasse
console.log(animal.name);
// Öffentliche Methode außerhalb der Klasse aufrufen
animal.speak();
Ausgabe:
animal Animals make sounds.
Erklärung:Wenn Sie keinen Zugriffsmodifizierer schreiben, verwendet TypeScript standardmäßig public. Daher kann public weggelassen werden, aber für die Klarheit des Codes wird empfohlen, es explizit zu deklarieren.
private-Modifizierer
private kennzeichnet private Member, auf die nur innerhalb der Klasse zugegriffen werden kann, in der sie definiert sind.
Weder Unterklassen noch der Bereich außerhalb der Klasse können auf private Member zugreifen.
Dies wird häufig verwendet, um die internen Implementierungsdetails einer Klasse zu verbergen und Daten vor versehentlicher Änderung zu schützen.
Beispiel
class BankAccount {
// Verwenden Sie private, um den Kontostand zu ändern, auf den nur innerhalb der Klasse zugegriffen werden kann
private balance: number;
// Konstruktor
constructor(initialBalance: number) {
this.balance = initialBalance;
}
// Einzahlungsmethode
public deposit(amount: number): void {
if (amount > 0) {
this.balance += amount; // Auf private Eigenschaften kann innerhalb der Klasse zugegriffen werden
console.log("Einzahlung erfolgreich, aktueller Kontostand: " + this.balance);
}
}
// Kontostand abrufen
public getBalance(): number {
return this.balance; // Auf private Eigenschaften kann innerhalb der Klasse zugegriffen werden
}
}
// Eine Kontoinstanz erstellen
var account = new BankAccount(1000);
// Einzahlen
account.deposit(500);
// Kontostand über eine öffentliche Methode abrufen
console.log("Kontostand: " + account.getBalance());
// Fehler: Auf private Eigenschaften kann von außerhalb der Klasse nicht direkt zugegriffen werden
// console.log(account.balance); // Kompilierungsfehler!
Ausgabe:
存款成功,当前余额: 1500 余额: 1500
Empfohlene Vorgehensweise:Den internen Zustand einer Klasse privat zu setzen und kontrollierten Zugriff über öffentliche Methoden bereitzustellen, ist der Standardweg zur Umsetzung von Kapselung.
protected-Modifizierer
protected kennzeichnet protected-Mitglieder, auf die innerhalb der Klasse und in Unterklassen zugegriffen werden kann.
Von außerhalb der Klasse kann nicht direkt auf protected-Mitglieder zugegriffen werden.
Dies ist sehr nützlich, wenn Unterklassen bestimmte Funktionalität von der Elternklasse erben sollen, während Implementierungsdetails verborgen bleiben.
Beispiel
class Person {
// protected verwenden, um name zu modifizieren, in Unterklassen zugänglich
protected name: string;
constructor(name: string) {
this.name = name;
}
}
// Employee-Klasse definieren, die von Person erbt
class Employee extends Person {
// Department ist private
private department: string;
constructor(name: string, department: string) {
super(name); // Konstruktor der Elternklasse aufrufen
this.department = department;
}
// Methode zur Selbstvorstellung
public introduce(): string {
// Unterklassen können auf das protected-Mitglied name zugreifen
return "I am " + this.name + ", at " + this.department + " working";
}
}
// Eine Employee-Instanz erstellen
var emp = new Employee("Alice", "Technology Department");
console.log(emp.introduce());
// Fehler: protected-Mitglieder sind außerhalb der Klasse nicht zugänglich
// console.log(emp.name); // Kompilierungsfehler!
Ausgabe:
我是 Alice,在 技术部 工作
Anwendungsfälle:protected wird oft verwendet, um Eigenschaften zu definieren, die Unterklassen benötigen, aber nicht nach außen offengelegt werden sollen.
readonly-Modifizierer
readonly wird verwendet, um Eigenschaften schreibgeschützt zu machen.
Sie können nur bei der Deklaration oder im Konstruktor zugewiesen werden und danach nicht mehr geändert werden.
Dies ist sehr nützlich, wenn Konstanten oder Bezeichner definiert werden.
Beispiel
class User {
// Mit readonly modifizierte Eigenschaften können nur während der Initialisierung zugewiesen werden
// Benutzer-ID
readonly id: number;
// Benutzername
readonly name: string;
constructor(id: number, name: string) {
this.id = id;
this.name = name;
}
}
// Eine User-Instanz erstellen
var user = new User(1, "Alice");
console.log("User: " + user.id + ", " + user.name);
// Fehler: readonly-Eigenschaften können nicht geändert werden
// user.id = 2; // Kompilierungsfehler!
// user.name = "Bob"; // Kompilierungsfehler!
Ausgabe:
User: 1, Alice
Hinweis:readonly und private stehen nicht im Konflikt. Du kannst readonly und private zusammen verwenden; die Eigenschaft kann weder geändert werden noch kann von außen auf sie zugegriffen werden.
Parametereigenschaften
TypeScript bietet eine Kurzschreibweise für Parametereigenschaften.
Zugriffsmodifikatoren können direkt bei Konstruktorparametern verwendet werden, um Eigenschaften automatisch zu erstellen und zu initialisieren.
Beispiel
class Point {
// Modifikatoren direkt bei Konstruktorparametern verwenden
// Entspricht dem gleichzeitigen Deklarieren von Eigenschaften und Zuweisen von Werten
constructor(
// public-Modifikator: erstellt öffentliche Eigenschaft x
public x: number,
// public-Modifizierer: erstellt öffentliche Eigenschaft y
public y: number,
// private-Modifizierer: erstellt private Eigenschaft z
private z: number
) {
// Der Konstruktorrumpf kann leer sein; Eigenschaften werden automatisch erstellt
}
// Berechne die Summe der drei Dimensionen
public sum(): number {
// Auf alle Eigenschaften kann innerhalb der Klasse zugegriffen werden
return this.x + this.y + this.z;
}
}
// Erstelle eine Point-Instanz
var point = new Point(1, 2, 3);
// Auf öffentliche Eigenschaften kann von außen zugegriffen werden
console.log("x: " + point.x);
console.log("y: " + point.y);
// Die Methode aufrufen
console.log("Sum: " + point.sum());
// Fehler: Auf private Eigenschaften kann nicht von außen zugegriffen werden
// console.log(point.z); // Kompilierungsfehler!
Ausgabe:
x: 1 y: 2 总和: 6
Vereinfachter Code:Parametereigenschaften können Klassendefinitionen erheblich vereinfachen und wiederholten Deklarations- und Zuweisungscode vermeiden.
Vergleich der Zugriffsmodifikatoren
Nachfolgend finden Sie einen Vergleich des Geltungsbereichs der drei Zugriffsmodifikatoren.
| Modifizierer | Innerhalb der Klasse | Unterklasse | Außerhalb der Klasse (Instanz) |
|---|---|---|---|
| public | ✓ Zugänglich | ✓ Zugänglich | ✓ Zugänglich |
| protected | ✓ Zugänglich | ✓ Zugänglich | ✗ Nicht zugänglich |
| private | ✓ Zugänglich | ✗ Nicht zugänglich | ✗ Nicht zugänglich |
Auswahlhinweise:Standardmäßig private verwenden. protected verwenden, wenn Zugriff durch Unterklassen erforderlich ist. public verwenden, wenn vollständiger öffentlicher Zugriff erforderlich ist.
Hinweise
- Standardmodifizierer:Wenn kein Modifizierer geschrieben wird, ist er standardmäßig public
- Konstruktor:Konstruktoren können ebenfalls Zugriffsmodifizierer verwenden, um die Instanziierungsberechtigungen zu steuern
- readonly-Kombination:readonly kann mit public, protected und private kombiniert werden
- Auswirkung auf die Kompilierung:Zugriffsmodifizierer werden nur zur Kompilierungszeit geprüft und haben zur Laufzeit keine Auswirkung
Best Practices:Verwende nach Möglichkeit den restriktivsten Zugriffsmodifizierer. Gib nur notwendige öffentliche Schnittstellen frei und mache interne Implementierungen private oder protected.
Zusammenfassung
Zugriffsmodifizierer sind das zentrale Werkzeug von TypeScript zur Umsetzung der Kapselung.
- public:Öffentlicher Zugriff, der Standardwert
- private:Privat, nur innerhalb der Klasse sichtbar
- protected:Geschützt, sichtbar innerhalb der Klasse und Unterklassen
- readonly:Schreibgeschützt, kann nach der Initialisierung nicht geändert werden
- Parametereigenschaften:Syntax zur Vereinfachung von Eigenschaftsdeklarationen
Weitere ErweiterungenEmpfehlungen:Entwickle die Gewohnheit, Zugriffsmodifizierer zu verwenden; dies ist die Grundlage für das Schreiben von hochwertigem TypeScript-Code.