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 Background Title Scope of Access Modifiers public Inside class ✓ Subclass ✓ External ✓ protected Inside class ✓ Subclass ✓ External ✗ private Inside class ✓ Subclass ✗ External ✗ Example area Use cases public scenario public Public methods/properties E.g., user name, login method protected scenario protected Methods visible to subclasses E.g., calculation formulas, template methods private scenario private Internal implementation details E.g., database connection, internal calculations

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

// Definiere eine Tierklasse
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

// Eine Bankkonto-Klasse definieren
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

// Basisklasse Person definieren
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

// Definiere eine User-Klasse
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

// Eine Point-Klasse definieren
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

Empfehlungen:Entwickle die Gewohnheit, Zugriffsmodifizierer zu verwenden; dies ist die Grundlage für das Schreiben von hochwertigem TypeScript-Code.

Weitere Erweiterungen