TypeScript学习7、类Class

TS类

class Point {
    public x: number
    public y: number
    constructor(x: number, y: number) {
        this.x = x
        this.y = y
    }
    public getPosition() {
        return `(${this.x}, ${this.y})`
    }
}
const point1 = new Point(1, 2)
console.log(point1.getPosition()) // (1, 2)

TS类 修饰符
public 公共修饰符，修饰 可以通过实例访问的属性和方法。

class Parent {
     public name: string
     constructor(name: string) {
         this.name = name
     }
 }
 class Child extends Parent {
     constructor(name: string) {
         super(name)
     }
 }
 const child = new Child('bob')
 console.log(child.name) // bob

private 私有修饰符，修饰 类的外部无法访问的属性和方法，只能在类的定义中使用。

class Parent {
    private age: number
    constructor(age: number) {
        this.age = age
    }
}

const p = new Parent(50)
console.log(p.age) // 报错：属性“age”为私有属性，只能在类“Parent”中访问
class Child extends Parent {
    constructor( age: number) {
        super(age)
        console.log(super.age) // 报错：通过 "super" 关键字只能访问基类的公共方法和受保护方法。
    }
}

protected 受保护修饰符, protected和private相似，但protected成员可以在派生类中访问（能被继承，但不能在实例中访问，另外若constructor是protected，则不能被实例化，只能被继承）。

class Parent {
    protected age: number
    constructor(age: number) {
        this.age = age
    }
    protected getAge() {
        return this.age
    }
}

const p = new Parent(5)
console.log(p.age) // 属性“age”受保护，只能在类“Parent”及其子类中访问。
class Child extends Parent {
    constructor( age: number) {
        super(age)
        console.log(super.age) // 报错：通过 "super" 关键字只能访问基类的公共方法和受保护方法。
        console.log(this.age) // 20
        console.log(this.getAge()) // 20
    }
}
const child = new Child(20)
console.log(child.age) // 报错： 属性“age”受保护，只能在类“Parent”及其子类中访问。
console.log(child.getAge())// 报错： 属性“getAge”受保护，只能在类“Parent”及其子类中访问。
// 在派生类通过super访问， 只能访问基类的公共方法和受保护方法。

readonly 修饰符， 设置为readonly属性， 实例只能读取，不能修改。

class UserInfo {
    public readonly name: string
    constructor(name: string) {
        this.name = name
    }
}
const u = new UserInfo('bob')
console.log(u.name) // bob
u.name = 'tina' // 报错：　无法分配给“name”，因为它是只读属性。

参数属性， 参数属性可以方便地让我们在一个地方定义并初始化一个成员。
在参数前面加上访问修饰符，既指定了属性的类型，又将属性放到实例上。

class A {
    constructor(public name: string) {

    }
}

const a = new A('toni')
console.log(a.name) // toni

static 静态属性，指定属性存在于类本身上面而不是类的实例上。

class Grid  {
    public static count: number = 20
    public static getGridCount() {
        return Grid.count
    }
    constructor() {}
}
console.log(Grid.getGridCount()) // 20

存取器 get set

class Info {
    public title: string
    public content?: string // ? 可选属性
    private _infoStr: string
    constructor(title: string,  public time?: string, content?: string) {
        this.title = title
        this.content = content
    }
    get infoStr() {
        return this._infoStr
    }
    set infoStr(val) {
        this._infoStr = val
    }
}
const i = new Info('标题', '2019-11-20', '正文')
i.infoStr = '12'
console.log(i.infoStr)// 12

abstract 抽象类，抽象类做为其它派生类的基类使用。不能直接实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 abstract关键字并且可以包含访问修饰符。

abstract class Animal {
    constructor(public foot: string) {

    }
    public abstract eat(): string
}

class Dog extends Animal {
    constructor(public foot: string) {
        super(foot)
        this.foot = foot
    }
    public eat() {
        return '狗吃屎'
    }
}

class Cat extends Animal {
    constructor(public foot: string) {
        super(foot)
        this.foot = foot
    }
    public eat() {
        return '猫吃鱼'
    }
}
const dog1 = new Dog('屎')
const cat1 = new Cat('鱼')
console.log(dog1.eat()) // 狗吃屎
console.log(cat1.eat()) // 猫吃鱼