类

calss A {
    
    
    name: string
    constructor(name:string) {
    
    this.name = name}
    greet() {
    
    return 'hello,' + this.name}
}
let people = new A('RenNing')

继承

子类是一个派生类，他派生自父类（基类），通过 extends关键字

派生类通常被称作子类，基类通常被称作超类。

派生类包含了一个构造函数，它必须调用 super()

公共、私有、受保护的修饰符

public

ts中成员默认为public

private

不能再声明他的类的外部访问

子类无法访问 private

class Animal {
    
    
    private name: string;
	constructor(thenname: string) {
    
    this.name = theName}
}
new Animal('cat').name //报错

protected

protected成员可以再派生类中访问

构造函数（constructor）被标记成 protected 后，不能实例化该类，当是能被继承

class A{
    
    
    protected constructor() {
    
    }
}
class B extends A {
    
    }
let a = new A() //错误-A的构造函数时被保护的
let b = new B() //ok

readonly修饰符

readonly关键字将属性设置为只读，只读属性必须再声明时构造函数里被初始化。

class A {
    
    
    readonly name: string;
	readonly age: number = 18
}
(new A()).name = 1 //报错

参数属性

参数属性可以方便地让我们在一个地方定义并初始化一个成员

改造上面的例子后

class A {
    
    
	constructor(readonly name: string, readonly age: number) {
    
    }
    say() {
    
    console.log(this.name,this.age)}
}
let a = new A('Ren', 18)
a.say() //Ren 18

我们把声明和赋值合并至一处

存取器

ts 指出通过getter/setters来截取对象成员访问。

let passcode = 'searet passcode'
class Employee {
    
    
    private _fullName: string;
	get fullName() :string {
    
    
        return this._fullName
    }
	set fullName(newValue: string) {
    
    
        if(passcode && passcode == 'secret passcode') {
    
    
            this._fullName = newValue
        }else {
    
    
            console.log('Error Unauthorized update of employee')
        }
    }
}
let employee = new Employee()

只带有 get不带有 set的存取器自动被推断为 readonly。

静态属性

使用 static定义

class A {
    
    
    static name: string = 'RenNing'
}
console.log(A.name)//RenNing

抽象类abstract

作为其他派生类的基类使用，不会被实例化，可定义抽象类、抽象方法

abstract class A {
    
    
    abstract makeSound(): void;
    move: void {
    
    console.log('roamin the earch...')}
}

抽象类中的抽象方法不包含具体实现，并且必须再派生类中事项，

与接口方法相似：只定义方法签名，但不包含方法体。abstract 可以包含访问修饰符

abstract class A {
    
    
    abstract say() :void//必须在派生类中实现
    sing(){
    
    console.log('sing-A')}
}
class B extends A {
    
    
    say():void{
    
    console.log('say-B')}
    song() :void {
    
    console.log('song-B')}
}
let point: A
point = new A()//错误：不能实例化抽象类
point = new B()
point.say()say-B
point.song()//错误：方法再声明抽象类中不存在

let point: B
point = new B()
point.say()//say-B
point.song()//song-B
point.sing()//sing-A

高级技巧

取类的类型 **typeof 类名，这个类型包含了类的所有静态成员和构造函数

class A {
	static name: string = "Ren"
	age: number = 18
}
let aMaker: type A = A
console.log(A.name)//Ren

let b: A = new A()
console.log(b.age)//18

console.log(typeof A)// function

把类当做接口使用

类定义会创建两个东西：类的实例类型和一个构造函数

class A {
    
    x: number;y:number}
interface Point3d extends Point {
    
    z: number}
let point3d: Point2d = {
    
    x: 1, y: 2, z: 3}

无法直接实例化

接口继承类

构造函数被 protected 修饰

抽象类

TS学习03-类

类

继承