TS复习-----TS中的类

目录

概述

类的定义

类的继承

类的静态方法和属性

类里面的修饰符

抽象类

 多态

getters与setters

readonly修饰符

---

概述

• 类(Class)：定义了一切事物的抽象特点
• 对象(Object)：类的实例
• 面向对象(OOP)三大特性：封装继承多态

类的定义

// 定义类
class Person {
    // 公共属性，默认可以不写
    public name: string
    // 构造函数
    constructor(name: string) {
        // 初始化name属性
        this.name = name
    }
}
// 实例化类
const person = new Person('zs')
console.log(person.name) // zs

类的继承

在面向对象的编程语言中，有一个重要得特征就是继承。继承就是基于某个类来扩展现有的类。

例如，爸爸在北京有一个四合院，儿子可以继承爸爸的四合院，而且还可以自己去买一栋别墅；最终儿子的房产拥有北京的四合院和一栋别墅。

TypeScript中类的继承需要通过extends来配合super来实现。子类若要继承父类的属性和方法需要执行一次super()，它代表实例化父类的构造函数，super() 只能用在子类的构造函数之中，用在其他地方就会报错。

// 定义一个基类，又称超类
class Father {
    // 在基类中定义一个name属性
    public name: string
    constructor(name: string) {
        this.name = name
    }
}
// 定义一个派生类，又称子类，继承于基类 
class Son extends Father {
    constructor(name: string, public age: number) {
        // 通过 super 调用基类的构造函数
        super(name)
    }
    getInfo(): void {
        console.log(this.name); //ZS
        console.log(this.age); //18
    }

}
const a = new Son('ZS', 18)
a.getInfo()

类的静态方法和属性

静态属性和静态方法属于类自身，而不属于实例，访问的时候要用类名访问，而不能用实例对象访问。在 TS中定义静态成员与ES6中一样，都是使用static关键字来说明。

class Hero {
    static count = 0
    constructor(public name: string) {
        // 每创建一个属性 count ++
        ++Hero.count
    }
}
const hero1 = new Hero('孙悟空')
console.log(Hero.count) // 1
const hero2 = new Hero('哪吒')
console.log(Hero.count) // 2
// console.log(hero1.count);不能访问静态成员count

类里面的修饰符

TypeScript定义属性的时候给我们提供了三种修饰符：

• public：公有属性，在当前类里面、 子类 、类外面都可以访问。属性如果不加修饰符默认就public。
• protected：保护类型，在当前类里面、子类里面可以访问 ，在类外部没法访问。
• private：私有属性，在当前类里面可以访问，子类、类外部都没法访问。

class Person {
    public name: string
    // 约定 私有成员一般采用 _ 开头
    private _age: number
    protected hobby: string
    // 属性初始化
    constructor(name: string, age: number, hobby: string) {
        this.name = name
        this._age = age
        this.hobby = hobby
    }
    sayMy() {
        console.log(this.name, this._age, this.hobby)
    }
}

// 实例化 Person 类
const person = new Person('zs', 18, 'coding')
console.log(person.name) // zs
// console.log(person._age) // 报错 类外访问私有成员 抛出异常
//  console.log(person.hobby) // 报错  类外访问保护成员 抛出异常
person.sayMy() // zs 18 coding,private 成员和 protected 成员可以在类内访问

// 定义一个类继承与 Person 类
class Programmer extends Person {
    constructor(name: string, age: number, hobby: string) {
        super(name, age, hobby)
    }
    sayMy() {
        console.log(this.name) // zs
        // console.log(this._age) // 报错 在子类不可以访问父类的私有成员
        // console.log(this.hobby) // coding 在子类不可以访问父类的私有成员
    }
}

// 实例化 Programmer 类
const programmer = new Programmer('zs', 18, 'coding')
programmer.sayMy()

抽象类

概念

• 想要理解什么是抽象类，就需要先理解什么是抽象，所谓的抽象就是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征 。例如苹果、香蕉、生梨、葡萄、桃子等，它们共同的特性就是水果。得出水果概念的过程，就是一个抽象的过程。
• 抽象类就是将众多类中具有共同部分的功能抽离出来，单独创建一个类作为其他派生类的基类使用。他们不允许被实例化，定义抽象类使用abstract关键字。
• 抽象方法就是只有方法的定义，没有方法体，方法体需要在子类中进行实现。

// 通过 abstract 关键字 定义一个抽象类，该类不必进行初始化，仅作为基类使用
abstract class Department {
    // 初始化name成员，参数属性
    constructor(public name: string) { }

    printName(): void {
        console.log('部门名称: ' + this.name)
    }
    // 抽象方法必须包含 abstract 关键字
    abstract printMeeting(): void // 必须在派生类中实现
}

class AccountingDepartment extends Department {
    constructor() {
        super('会计部') // 在派生类的构造函数中必须调用super()
    }

    printMeeting(): void {
        console.log('会计部是负责管钱的部门')
    }
}

// const department = new Department() // 抛出异常：不能创建一个抽象类的实例
// 实例化抽象子类
const department = new AccountingDepartment()
// 调用抽象类中的方法
department.printName() // 部门名称: 会计部
// 调用在派生类实现的抽象方法
department.printMeeting() // 会计部是负责管钱的部门

 多态

多态属于继承，是继承的一种延续，在父类内部有一个公用方法，但是不知道具体做什么，由多个子类继承同一个方法，实现不同效果，这个公用方法也叫方法的重写

class Animall {
    name: string;
    constructor(name: string) {
        this.name = name
    }
    eat(): void {
        console.log('我们都可以吃');
    }
}

class Dog extends Animall {
    constructor(name: string) {
        super(name)
    }
    eat(): void {
        console.log(`${this.name}吃骨头`)
    }
}

class Cat extends Animall {
    constructor(name: string) {
        super(name)
    }
    eat(): void {
        console.log(`${this.name}吃老鼠`)
    }
}

let dog = new Dog('小黄')
dog.eat()

getters与setters

类中的私有成员和保护成员我们并不是真的不能读写，在TS中提供了getters与setters帮助我们有效的控制对对象成员的访问。

// 定义一个 Person 类
class Person {
    // 约定 私有成员一般采用 _ 开头
    private _name: string
    // 属性初始化
    constructor(name: string) {
        this._name = name
    }
    // 获取 私有的 _name 属性值
    get getName(): string {
        return this._name
    }
    // 设置 私有的 _name 属性值
    set setName(name: string) {
        this._name = name
    }
}
// 实例化类
const person = new Person('zs')
console.log(person.getName) // zs 通过 getName 的方式获取
person.setName = 'ls'//通过 setName 的方式设置 _name 的值
console.log(person.getName) // // 重新获取 ls

readonly修饰符

我们可以通过 readonly修饰符将一个属性设置为只读的。只读属性必须在声明时或者在构造函数中进行初始化。

// 定义一个类，且具有一个只读属性
class Person {
    // readonly name: string
    // 等同于
    // public readonly name: string
    // constructor(name: string) {
    //     this.name = name
    // }
    // 或者
    constructor(public readonly name: string) { }
}
// 实例化
const person = new Person('zs')
console.log(person.name) // zs
// 修改name的值
// person.name = 'ls' // 错误! name 是只读的.