TypeScript Klassen

Klassen sind ein Kernkonzept der objektorientierten Programmierung (OOP). Sie sind Vorlagen oder Baupläne für die Erstellung von Objekten mit denselben Eigenschaften und Methoden. TypeScript unterstützt objektorientierte Programmierung vollständig und bietet Funktionen wie Klassen, Vererbung und Zugriffsmodifikatoren.

Klassen kapseln Daten (Attribute) und Verhalten (Methoden) und machen den Code modularer, wiederverwendbarer und wartbarer. Durch Klassen können wir mehrere Objekte mit derselben Struktur erstellen, und diese Objekte werden Instanzen der Klasse genannt.


Klassendefinition

TypeScript verwendetclassdas Schlüsselwort `class`, um eine Klasse zu definieren. Eine Klasse kann die folgenden Mitglieder enthalten:

  • Feld: Eine in der Klasse deklarierte Variable, die die Attribute des Objekts repräsentiert
  • Konstruktor: Eine spezielle Methode, die aufgerufen wird, wenn die Klasse instanziiert wird, und dazu dient, das Objekt zu initialisieren
  • Methode: Eine in der Klasse definierte Funktion, die das Verhalten des Objekts repräsentiert

Syntaxformat

class class_name {
    // 字段声明
    field1: type;
    field2: type;

    // 构造函数
    constructor(parameters) {
        // 初始化代码
    }

    // 方法
    methodName(): return_type {
        // 方法实现
    }
}

Beispiel: Erstellen einer einfachen Klasse

Beispiel

// Definiere eine leere Person-Klasse
class Person {
}

Kompiliertes JavaScript:

Beispiel

var Person = /** @class */ (function () {
    function Person() {
    }
    return Person;
}());

Klassenfelder und Konstruktoren

Klassenfelder sind der Ort, an dem Objektdaten gespeichert werden, und Konstruktoren werden automatisch aufgerufen, wenn ein Objekt erstellt wird, um die Felder zu initialisieren.

Beispiel

// Die Klasse Car definieren
class Car {
// Felder: Attribute, die das Auto beschreiben
    engine: string;

// Konstruktor: initialisiert engine beim Erstellen eines Objekts
    constructor(engine: string) {
        this.engine = engine;
    }

// Methode: Engine-Informationen anzeigen
    disp(): void {
console.log("Engine model: " + this.engine);
    }
}

// Eine Instanz der Klasse erstellen
var car = new Car("V8 engine");

// Zugriff auf ein Feld
console.log("Read engine: " + car.engine);

// Eine Methode aufrufen
car.disp();

Ausgabe:

读取发动机: V8 发动机
发动机型号: V8 发动机

Erklärung:

  • thisDas Schlüsselwort `this` verweist auf die aktuelle Instanz der Klasse.
  • Konstruktor-Parameternamen können mit Feldnamen identisch sein, wobeithis.field`this` verwendet wird, um sie zu unterscheiden.
  • Verwenden Sienewdas Schlüsselwort `new`, um eine Instanz der Klasse zu erstellen.

Hinweis:TypeScript-Klassen werden nach der Kompilierung in JavaScript-Konstruktor-/Prototyp-Muster konvertiert, und Schnittstellen erscheinen nicht in der kompilierten Ausgabe.


Zugriffssteuerungsmodifikatoren

TypeScript bietet drei Zugriffsmodifikatoren, um die Zugänglichkeit von Klassenmembern zu steuern:

Modifizierer Beschreibung
public Öffentliches Member, von überall zugänglich (Standard)
private Privates Element, nur innerhalb der Klasse zugänglich
protected Geschütztes Element, innerhalb der Klasse und ihrer Unterklassen zugänglich

public (Standard)

Beispiel

class Person {
public name: string; // Öffentliches Attribut
public age: number; // Öffentliches Attribut

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    public introduce(): void {
console.log("Ich bin " + this.name + ", " + this.age + " Jahre alt");
    }
}

var person = new Person("Alice", 25);
console.log("Name: " + person.name); // Zugriff möglich
person.introduce(); // Kann aufgerufen werden

private

Beispiel

class Person {
    public name: string;
private secret: string; // Privates Attribut, von außen nicht direkt zugänglich

    constructor(name: string, secret: string) {
        this.name = name;
        this.secret = secret;
    }

// Öffentliche Methoden können auf private Attribute zugreifen
    public revealSecret(): void {
console.log("Secret: " + this.secret);
    }
}

var person = new Person("Alice", "I like programming");

console.log("Name: " + person.name); // Zugriff möglich
// console.log(person.secret); // Fehler: 'secret' ist eine private Eigenschaft

person.revealSecret(); // Zugriff auf private Eigenschaft über öffentliche Methode

protected

Beispiel

class Person {
protected name: string; // Geschütztes Attribut

    constructor(name: string) {
        this.name = name;
    }

    protected sayHello(): void {
console.log("Hallo, ich bin " + this.name);
    }
}

class Student extends Person {
    private grade: string;

    constructor(name: string, grade: string) {
        super(name);
        this.grade = grade;
    }

    public introduce(): void {
// Unterklassen können auf geschützte Attribute und Methoden zugreifen
console.log("Ich bin " + this.name + ", Klasse: " + this.grade);
        this.sayHello();
    }
}

var student = new Student("Bob", "Klasse 12");
student.introduce(); // Darauf kann zugegriffen werden

// console.log(student.name); // Fehler: 'name' ist eine geschützte Eigenschaft

Ausgabe:

我是 Bob,年级: 高三
你好,我是 Bob

Klassenvererbung

Vererbung ermöglicht es einer Klasse (Unterklasse), Eigenschaften und Methoden von einer anderen Klasse (Elternklasse) zu übernehmen. Eine Unterklasse kann den Code der Elternklasse wiederverwenden und auch das Verhalten der Elternklasse erweitern oder überschreiben.

Grundlegende Syntax

class child_class extends parent_class {
    // 子类新增的属性和方法
}

Einfachvererbung

Beispiel

// Elternklasse: Shape
class Shape {
    area: number;

    constructor(a: number) {
        this.area = a;
    }
}

// Unterklasse: Circle, erbt von Shape
class Circle extends Shape {
    disp(): void {
console.log("Kreisfläche: " + this.area);
    }
}

var circle = new Circle(223);
circle.disp();

Ausgabe:

圆的面积: 223

Mehrfachvererbung

TypeScript unterstützt keine Mehrfachvererbung (eine Klasse, die von mehreren Klassen erbt), aber es unterstützt mehrstufige Vererbung (A erbt von B, B erbt von C):

Beispiel

// Wurzelklasse
class Root {
    str: string;
}

// Unterklasse: erbt von Root
class Child extends Root {
}

// Blattklasse: erbt von Child (mehrstufige Vererbung)
class Leaf extends Child {
}

var leaf = new Leaf();
leaf.str = "hello";
console.log("str value: " + leaf.str);

Ausgabe:

str 值: hello

Methodenüberschreibung

Eine Unterklasse kann eine Methode der Elternklasse überschreiben, das heißt, in der Unterklasse eine Methode mit demselben Namen wie die Methode der Elternklasse definieren, um ihr eigenes Verhalten zu implementieren.

Verwenden Siesuperdas Schlüsselwort `super`, um die Methode der Elternklasse aufzurufen.

Beispiel

// Elternklasse
class PrinterClass {
    doPrint(): void {
console.log("Parent class's doPrint() method");
    }
}

// Unterklasse: Methode der Elternklasse überschreiben
class StringPrinter extends PrinterClass {
    doPrint(): void {
// Methode der Elternklasse aufrufen
        super.doPrint();

// Eigene Logik der Unterklasse
console.log("Methode doPrint() der Unterklasse");
    }
}

var obj = new StringPrinter();
obj.doPrint();

Ausgabe:

父类的 doPrint() 方法
子类的 doPrint() 方法

Statische Member

Verwenden Siestaticdas Schlüsselwort `static`, um Member zu definieren, die zur Klasse selbst gehören, nicht zu Instanzen der Klasse. Auf sie kann direkt über den Klassennamen zugegriffen werden, ohne eine Instanz zu erstellen.

Beispiel

class StaticMem {
// Statisches Attribut
    static num: number;

// Statische Methode
    static disp(): void {
console.log("Der Wert von num ist " + StaticMem.num);
    }
}

// Zugriff auf statische Mitglieder direkt über den Klassennamen
StaticMem.num = 12;
StaticMem.disp();

Ausführungsergebnis:

num 值为 12

Anwendungsszenario:Statische Mitglieder werden häufig verwendet, um Klassenkonstanten, Hilfsmethoden oder Singleton-Muster zu definieren.


instanceof-Operator

instanceofWird verwendet, um festzustellen, ob ein Objekt eine Instanz einer Klasse ist.

Beispiel

class Person {
}

var obj = new Person();
var isPerson = obj instanceof Person;

console.log("Ist obj eine Instanz von Person? " + isPerson);

Ausführungsergebnis:

obj 是 Person 类的实例吗? true

Klassen, die Schnittstellen implementieren

Eine Klasse kann dasimplementsSchlüsselwort verwenden, um eine Schnittstelle zu implementieren, wodurch sichergestellt wird, dass die Klasse den durch die Schnittstelle definierten Vertrag erfüllt.

Beispiel

// Schnittstelle definieren
interface ILoan {
interest: number; // Zinssatz
}

// Klasse implementiert Schnittstelle
class AgriLoan implements ILoan {
    interest: number;
rebate: number; // Rabatt

    constructor(interest: number, rebate: number) {
        this.interest = interest;
        this.rebate = rebate;
    }
}

var loan = new AgriLoan(10, 1);
console.log("Zinssatz: " + loan.interest + "%, Rabatt: " + loan.rebate);

Ausführungsergebnis:

利率: 10%,回扣: 1

Abstrakte Klassen

Abstrakte Klassen können nicht instanziiert werden, sie können nur als Basisklassen für Unterklassen dienen, die von ihnen erben. Abstrakte Klassen können abstrakte Methoden enthalten (Platzhaltermethoden ohne Implementierung), die Unterklassen implementieren müssen.

Beispiel

// Abstrakte Klasse
abstract class Animal {
abstract makeSound(): void; // Abstrakte Methode, muss von Unterklassen implementiert werden

    move(): void {
console.log("Das Tier bewegt sich");
    }
}

// Konkrete Klasse: erbt von der abstrakten Klasse
class Dog extends Animal {
    makeSound(): void {
console.log("Wuff wuff!");
    }
}

var dog = new Dog();
dog.move();
dog.makeSound();

Ausführungsergebnis:

The animal is moving
Woof woof woof!

Umfassendes Beispiel

Umfassende Anwendung verschiedener Features von Klassen:

Beispiel

// Schnittstellendefinition
interface I Printable {
    print(): void;
}

// Abstrakte Klasse
abstract class Item {
    protected name: string;
    protected price: number;

    constructor(name: string, price: number) {
        this.name = name;
        this.price = price;
    }

    abstract getDetails(): string;
}

// Konkrete Klasse
class Product extends Item implements I Printable {
    private category: string;

    constructor(name: string, price: number, category: string) {
        super(name, price);
        this.category = category;
    }

// Abstrakte Methode implementieren
    getDetails(): string {
return `Produkt: ${this.name}, Preis: ¥${this.price}, Kategorie: ${this.category}`;
    }

// Interface-Methode implementieren
    print(): void {
        console.log(this.getDetails());
    }

// Statische Methode
    static create(name: string, price: number): Product {
return new Product(name, price, "Standardkategorie");
    }
}

// Verwendung
var product = Product.create("Laptop", 5999);
product.print();

// Rabattmethode
class DiscountedProduct extends Product {
    private discount: number;

    constructor(name: string, price: number, category: string, discount: number) {
        super(name, price, category);
        this.discount = discount;
    }

    getDetails(): string {
        var discountedPrice = this.price * (1 - this.discount / 100);
return `Produkt: ${this.name}, Originalpreis: ¥${this.price}, Rabatt: ${this.discount}%, Aktueller Preis: ¥${discountedPrice.toFixed(2)}`;
    }
}

var discountedProduct = new DiscountedProduct("Telefon", 2999, "Elektronische Produkte", 20);
discountedProduct.print();

Ausführungsergebnis:

产品: 笔记本电脑, 价格: ¥5999, 类别: 默认类别
产品: 手机, 原价: ¥2999, 折扣: 20%, 现价: ¥2399.20

Zusammenfassung

TypeScript-Klassen bieten vollständige Unterstützung für objektorientierte Programmierung:

  • Klassendefinition: Verwendet das Schlüsselwort class, enthält Felder, Konstruktoren und Methoden
  • Zugriffsmodifikatoren: public, private, protected steuern den Zugriff auf Member
  • Vererbung: Verwendet extends zur Implementierung der Klassenvererbung, unterstützt mehrstufige Vererbung
  • Methodenüberschreibung: Unterklassen können Methoden der Elternklasse überschreiben und mit super die Elternklasse aufrufen
  • Statische Member: Verwenden das Schlüsselwort static, gehören zur Klasse selbst und nicht zu Instanzen
  • Schnittstellenimplementierung: Verwenden das Schlüsselwort implements zur Implementierung von Schnittstellen
  • Abstrakte Klassen: Verwenden das Schlüsselwort abstract, können nicht instanziiert werden, dienen als Basisklassen

Klassen sind die Grundlage der objektorientierten Programmierung in TypeScript. Die richtige Verwendung von Klassen kann den Code strukturierter und wartbarer machen.

Weitere Erweiterungen