Die Klassen in ts ähneln den Klassen in js, abgesehen von einigen Typprüfungen und Funktionserweiterungen.
Grundlegende Verwendung
Wir verwenden classSchlüsselwörter, um eine Klasse zu deklarieren und einige Instanzeigenschaften und -methoden zu deklarieren.
class Dog {
//定义几个实例属性
name: string = '小狗'
age: number = 5
//定义一个实例方法，该方法会绑定在类的原型对象上
sayHi() {
console.log('Hi')
}
}
let dog = new Dog() //Dog: {"name": "小狗","age": 5}
dog.sayHi() //hi
Eigenschaftswerte manuell festlegen
Im obigen Code sind unsere Instanzattribute fest codiert und nicht sehr praktisch. Wir versuchen, constructormanuelle Zuweisungsvorgänge durchzuführen.
class Dog {
name: string
age: number
constructor(name: string, age: number) {
this.age = age
this.name = name
}
sayHi() {
console.log('Hi')
}
}
let dog = new Dog('富贵', 5)
console.log(dog) //Dog: {"name": "小狗","age": 5}
dog.sayHi() //hi
Statische Eigenschaften festlegen
Wir können auch einige statische Eigenschaften und Methoden für die Klasse festlegen. Diese Eigenschaftsmethoden müssen nicht über Instanzen übergeben werden, sondern können direkt über die Klasse verwendet werden.
class Dog {
static gender: string = '雌'
static getGender() {
console.log('我的性别是' + Dog.gender)
}
}
console.log(Dog.gender) // '雌'
Dog.getGender() // '我的性别是雌'
erben
Wenn es um Klassen geht, müssen wir über Vererbung sprechen. Durch Vererbung können wir häufig einige öffentliche Methoden oder Eigenschaften abstrahieren und kapseln und so die Wiederverwendung von Code reduzieren.
class Animal {
type: string
gender: boolean
constructor(type: string, gender: boolean) {
this.type = type
this.gender = gender
}
}
class Dog extends Animal {
age: number
constructor(gender: boolean, age: number) {
super('dog', gender)
this.age = age
}
}
let dog: Dog = new Dog(true, 5)
console.log(dog)
// {
// "type": "dog",
// "gender": true,
// "age": 5
// }
Während des Vererbungsprozesses überschreiben wir möglicherweise einige Eigenschaften oder Methoden.
class Animal {
type: string
gender: boolean
constructor(type: string, gender: boolean) {
this.type = type
this.gender = gender
}
sayHi() {
console.log('动物再叫')
}
}
class Dog extends Animal {
age: number
constructor(gender: boolean, age: number) {
super('dog', gender)
this.age = age
}
sayHi() {
console.log('小狗在叫')
}
}
let dog: Dog = new Dog(true, 5)
dog.sayHi() //小狗在叫
Modifikator
public (Standardmodifikator)
Wenn wir eine Klasse normal definieren, sind die darin enthaltenen Eigenschaften und Methoden standardmäßig öffentlich. Das heißt, die standardmäßig definierten Methoden und Eigenschaften sind öffentlich und können innerhalb und außerhalb der Klasse verwendet werden.
class Dog {
name: string = '小狗'
age: number = 5
sayHi() {
console.log(this.name'说Hi') //直接在类的内部使用name属性
}
}
let dog = new Dog() //Dog: {"name": "小狗","age": 5}
dog.name // 直接在类的外部使用name属性
privat (Private)
Wenn ein Mitglied als privat markiert ist, kann außerhalb der Klasse, in der es deklariert ist, nicht darauf zugegriffen werden.
class Dog {
private name: string = '小狗'
sayHi() {
console.log(this.name + '说Hi') //直接在类的内部使用name属性
}
}
let dog = new Dog() //Dog: {"name": "小狗","age": 5}
dog.sayHi() // 小狗说Hi
dog.name // Property 'name' is private and only accessible within class 'Dog'.
Selbst auf geerbte Klassen kann nicht zugegriffen werden.
class Animal {
private type: string
gender: boolean
constructor(type: string, gender: boolean) {
this.type = type
this.gender = gender
}
}
class Dog extends Animal {
age: number
constructor(gender: boolean, age: number) {
super('dog', gender)
this.age = age
console.log(this.type) //Property 'type' is private and only accessible within class 'Animal'.
}
}
protected (class private)
protected ähnelt privateihr, aber auf die von ihr definierten Eigenschaften und Methoden kann in der geerbten Klasse zugegriffen werden.
class Animal {
protected type: string
gender: boolean
constructor(type: string, gender: boolean) {
this.type = type
this.gender = gender
}
}
class Dog extends Animal {
age: number
constructor(gender: boolean, age: number) {
super('dog', gender)
this.age = age
console.log(this.type) //dog
}
}
readonly (Schreibgeschützt)
Eine schreibgeschützte Implementierung muss im Klassenattribut definiert oder constructordarin zugewiesen werden.
Parametereigenschaften
Wir haben festgestellt, dass wir in der obigen Klasse jedes Mal, wenn wir constructoreine Eigenschaft im Konstruktor deklarieren, zuerst den Typ außerhalb deklarieren und dann die formalen Parameter im Konstruktor deklarieren müssen, bevor wir die Zuweisungsoperation intern ausführen können, aber wir können sie vollständig verwenden Schritt zur Typdeklaration des Parameterattributdeklarationstyps.
class Animal {
constructor(protected type: string, public gender: boolean) {
this.type = type
this.gender = gender
}
}
Indem wir Modifikatoren direkt im Konstruktor verwenden, lassen wir den Schritt der Typdeklaration weg und führen Zuweisungsoperationen direkt im Konstruktor durch.
get/Set (Accessor)
class Person {
constructor(public name: string, public age: number) {
this.name = name
this.age = age
}
}
let user: Person = new Person('fufu', 20)
user.age = 1000
Im obigen Code haben wir eine Personenklasse definiert. In dieser Klasse gibt es ein Altersattribut. Nachdem wir die Instanz generiert haben, können wir das Alter nach Belieben ändern oder es sogar auf 10.000 ändern. Dies ist offensichtlich unvernünftig. Wir können get/set verwenden, um auf Eigenschaften zuzugreifen und diese festzulegen.
class Person {
constructor(public name: string, private _age: number) {
this.name = name
this._age = _age
}
get getAge() {
return this._age
}
set setAge(num: number) {
if (num > 120) {
console.log('数字太大啦！')
}
}
}
let user: Person = new Person('fufu', 20)
user.setAge = 130 //数字太大啦！
console.log(user.getAge) // 20
abstrakte Klasse
Oft möchten wir nicht, dass alle Klassen zum Erstellen von Instanzen verwendet werden. Wenn wir beispielsweise eine Tierklasse haben, möchten wir nur, dass sie von anderen Klassen geerbt wird, und wir möchten nicht, dass jemand sie direkt zum Erstellen verwendet Instanzen. In diesem Fall müssen wir Abstraktion verwenden. Art.
abstract class Animal {
constructor(public breed: string) {
this.breed = breed
}
}
class Dog extends Animal {
constructor() {
super('dog')
}
}
let animal: Animal = new Animal('dog') //Cannot create an instance of an abstract class.
let dog: Dog = new Dog()
console.log(dog.type) // 'dog'
Abstrakte Methoden können auch in abstrakten Klassen definiert werden. Abstrakte Methoden enthalten keine konkreten Implementierungen und müssen in abgeleiteten Klassen implementiert werden. Die Syntax abstrakter Methoden ähnelt der von Schnittstellenmethoden. Beide definieren Methodensignaturen, enthalten jedoch keine Methodenkörper.
abstract class Animal {
constructor(protected breed: string) {
this.breed = breed
}
abstract sayHi(): void
}
class Dog extends Animal {
constructor() {
super('dog')
}
sayHi() {
console.log(this.breed + '在叫！')
}
}
let dog: Dog = new Dog()
dog.sayHi() // dog在叫！
Beachten Sie, dass wir beim Definieren einer Eigenschaft einen Anfangswert oder einen Wert im Konstruktor zuweisen müssen. Sie können ! oder ? verwenden, um zu bestätigen oder anzuzeigen, dass es optional ist.
class Dog {
name?: string
age!: number
}