Klassen in TypeScript

;(Funktion () {
  // Klasse definieren class Person {
    // Öffentliche Attribute, können standardmäßig weggelassen werden öffentlicher Name: Zeichenfolge
    // Konstruktor Konstruktor(Name: Zeichenfolge) {
      // Initialisiere die Namenseigenschaft this.name = name
    }
  }
  //Klasse instanziieren const person = new Person('Yiwan Zhou')
  Konsole.log(Person.Name) // Yiwan Zhou})()

;(Funktion () {
  Klasse Person {
    Konstruktor (öffentlicher Name: Zeichenfolge) {}
  }
  //Klasse instanziieren const person = new Person('Yiwan Zhou')
  Konsole.log(Person.Name) // Yiwan Zhou})()

;(Funktion () {
  // Definieren Sie eine Basisklasse, auch Superklasse genannt class Person {
    // Definieren Sie eine Namenseigenschaft im Konstruktor der Basisklasse (öffentlicher Name: Zeichenfolge) {}
  }
  // Definieren Sie eine abgeleitete Klasse, auch Unterklasse genannt, die von der Basisklasse erbt class Programmer extends Person {
    Konstruktor(Name: Zeichenfolge, öffentliches Hobby: Zeichenfolge) {
      // Rufen Sie den Basisklassenkonstruktor super(name) über super auf
    }
  }
  // Unterklasse instanziieren const programmer = new Programmer('Programmierer', 'coding')
  console.log(programmer.name, programmer.hobby) // Eine Schüssel wöchentliches Coding
})()

//Definiere eine Personenklasse class Person {
    Konstruktor (öffentlicher Name: Zeichenfolge) {}
    //Definiere eine Methode sayMy() {
        console.log(`Mein Name: ${this.name}`)
    }
}
// Definieren Sie eine Erwachsenenklasse, die von der Personenklasse erbt class Adult extends Person {
    Konstruktor(öffentliches Alter: Zahl) {
        super('die andere Seite ist wohlhabend')
    } // Überschreibe die Methode der übergeordneten Klasse sayMy() {
        console.log(`Mein Name: ${this.name} Alter: ${this.age}`)
    }
}
// Definieren Sie eine Programmierer-Klasse, die von der Erwachsenen-Klasse erbt class Programmer extends Adult {
    Konstruktor(öffentliches Hobby: Zeichenfolge) {
        super(18)
    } // Überschreibe die Methode der übergeordneten Klasse sayMy() {
        konsole.log(
            `Mein Name: ${this.name} Alter: ${this.age} Hobby: ${this.hobby}`
        )
    }
}
// Klasseninstanzierung const programmer = new Programmer('coding')
programmer.sayMy() // Mein Name: Bi'an Fanhua Alter: 18 Hobbys: Programmieren

// Definieren Sie eine Personenklasse, die öffentliche, private und geschützte Mitglieder enthält.
Klasse Person {
  öffentlicher Name: Zeichenfolge
  // Es besteht allgemein Einigkeit darüber, dass private Mitglieder mit _ private _age: number beginnen.
  geschütztes Hobby: Schnur
  // Initialisierungskonstruktor der Eigenschaft (Name: Zeichenfolge, Alter: Zahl, Hobby: Zeichenfolge) {
    dieser.name = Name
    this._age = Alter
    dieses.hobby = hobby
  }
  sagMein() {
    console.log(dieser.Name, dieses._Alter, dieses.Hobby)
  }
}

// Instanziieren Sie die Klasse „Person“ const person = new Person('Person', 18, 'coding')

console.log(person.name) // Zurück zur Klasse//Der Zugriff auf private Member außerhalb der Klasse löst eine Ausnahme aus// console.log(person._age) // Fehler melden//Der Zugriff auf geschützte Member außerhalb der Klasse löst eine Ausnahme aus// console.log(person.hobby) // Fehler melden//Auf private und geschützte Member kann innerhalb der Klasse zugegriffen werden person.sayMy() // Zurück zur Klasse18 Codierung

// Definiere eine Klasse die von der Klasse Person erbt class Programmer extends Person {
  Konstruktor(Name: Zeichenfolge, Alter: Zahl, Hobby: Zeichenfolge) {
    super(Name, Alter, Hobby)
  }
  sagMein() {
    console.log(this.name) // Fehlerbericht// Auf private Member der Elternklasse kann in der Unterklasse nicht zugegriffen werden // console.log(this._age) // Fehlerbericht// Auf geschützte Member kann in der Unterklasse zugegriffen werden console.log(this.hobby) // coding
  }
}

// Instanziieren Sie die Klasse „Programmer“ const programmer = new Programmer('Programmierer', 18, 'coding')
programmierer.sayMy()

// Stellen Sie sicher, dass kein Konflikt mit Mitgliedern in anderem Code auftritt. Export {}

//Definiere eine Personenklasse class Person {
  // Es wird vereinbart, dass private Mitglieder normalerweise mit _ private _name: string beginnen
  // Initialisierungskonstruktor der Eigenschaft (Name: Zeichenfolge) {
    dieser._name = Name
  }
  // Den privaten Wert des Attributs _name abrufen get getName(): string {
    gib dies zurück._name
  }
  // Setze den privaten _name-Eigenschaftswert set setName(name: string) {
    dieser._name = Name
  }
}
// Instanziieren Sie die Klasse const person = new Person('eine Schüssel Haferbrei')
// Mit getName abrufen console.log(person.getName) // Eine Schüssel Haferbrei // Den Wert von _name mit setName festlegen person.setName = 'Eine Schüssel Haferbrei'
// Console.log(person.getName) erneut abrufen // Yiwan Zhou

// Definieren Sie eine Klasse mit einem schreibgeschützten Attribut class Person {
  // schreibgeschützter Name: Zeichenfolge
  // entspricht // öffentlichem schreibgeschütztem Namen: Zeichenfolge
  // Konstruktor(Name: Zeichenfolge) {
  // dieser.name = Name
  // }
  // oder Konstruktor (öffentlicher schreibgeschützter Name: Zeichenfolge) {}
}
// Instanziierung const person = new Person('Person')
console.log(person.name) // person.name// Wert von „name“ ändern// person.name = „person.name“ // Fehler! „name“ ist schreibgeschützt.

Klasse Held {
  // Zähler statisch count = 0
  Konstruktor (öffentlicher Name: Zeichenfolge) {
    // Jedes Mal eine Eigenschaftsanzahl erstellen ++
    ++Heldenzahl
  }
}
// Instanziieren Sie eine Heldenklasse const hero1 = new Hero('Sun Wukong')
konsole.log(Hero.count) // 1
const hero2 = neuer Held('Nezha')
Konsole.log(Hero.count) // 2

// Verwenden Sie das Schlüsselwort abstract, um eine abstrakte Klasse zu definieren, die nicht initialisiert werden muss und nur als Basisklasse verwendet wird. abstract class Department {
  // Initialisieren Sie das Namenselement, Parameterattributkonstruktor (öffentlicher Name: Zeichenfolge) {}

  Druckname(): void {
    console.log('Abteilungsname: ' + dieser.name)
  }
  // Abstrakte Methoden müssen das Schlüsselwort abstract enthalten abstract printMeeting(): void // Muss in abgeleiteten Klassen implementiert werden}

Klasse AccountingDepartment erweitert Department {
  Konstruktor() {
    super('Buchhaltungsabteilung') // Sie müssen super() im Konstruktor einer abgeleiteten Klasse aufrufen
  }

  druckeMeeting(): void {
    console.log('Die Buchhaltungsabteilung ist für die Verwaltung des Geldes verantwortlich.')
  }
}

// const department = new Department() // Löst eine Exception aus: Es kann keine Instanz einer abstrakten Klasse erstellt werden // Instanziiere abstrakte Unterklasse const department = new AccountingDepartment()
// Rufen Sie die Methode in der abstrakten Klasse department.printName() auf. // Name der Abteilung: Buchhaltungsabteilung. // Rufen Sie die abstrakte Methode auf, die in der abgeleiteten Klasse department.printMeeting() implementiert ist. // Die Buchhaltungsabteilung ist die Abteilung, die für die Verwaltung des Geldes zuständig ist.

//Definiere eine Klasse class Point {
    x: Zahl
    y: Zahl
}
// Definieren Sie eine Schnittstellenvererbung und eine Klassenschnittstelle Point3d extends Point {
    z: Zahl
}

lass point3d: Point3d = { x: 1, y: 2, z: 3 }

// definiere Schnittstelle Eat {
  essen(Nahrung: Zeichenfolge): void
}
Schnittstelle Ausführen {
  Lauf(Entfernung: Zahl): void
}

// Klasse definieren um Schnittstellenklasse zu implementieren Person implements Eat, Run {
  essen(Nahrung: Zeichenfolge): void {
    console.log(Essen)
  }
  lauf(Entfernung: Zahl) {
    console.log(Entfernung)
  }
}
exportieren {}