【TypeScript】类

类

类：可以理解为模板，通过模板可以实例化对象
面向对象的编程思想

    // ts中类的定义及使用
    class Person {
        // 定义属性
        name: string
        age: number
        gender: string
        // 构造函数
        constructor(name: string, age: number, gender: string) {
            this.name = name
            this.age = age
            this.gender = gender
        }

        sayHi() {
            console.log(`大家好，我是${this.name}，今年已经${this.age}岁了，是个${this.gender}孩子`)
        }
    }

    // ts中实用类，实例化对象，可以直接进行初始化操作
    const person = new Person('kudo', 18, '男')
    person.sayHi()

继承

A类继承了B这个类，那么此时A类叫子类，B类叫基类
子类—>派生类
基类—>超类(父类)

    // 定义一个类
    class Person {
        // 定义属性
        name: string
        age: number
        gender: string

        // 定义构造函数
        constructor(name: string, age: number, gender: string) {
            // 更新属性数据
            this.name = name
            this.age = age
            this.gender = gender
        }

        // 定义实例方法
        sayHi(str: string) {
            console.log(`我是：${this.name}, ${str}`)
        }
    }

    // 定义一个学生类
    class Student extends Person {
        constructor(name: string, age: number, gender: string) {
            // 调用父类的构造函数
            super(name, age, gender)
        }
    }

    // 实例化Person
    const person = new Person('kudo', 18, '男')
    person.sayHi('哈哈')

    // 实例化Student
    const student = new Student('kudo', 17, '男')
    student.sayHi('hhhh')

多态

多态：父类型的引用指向子类型的对象，不同类型的对象针对相同的方法，产生了不同的行为

    // 定义一个父类
    class Animal {
        name: string

        constructor(name: string) {
            this.name = name
        }

        run(distance: number = 0) {
            console.log(`跑了${distance}米这么远的距离`)
        }
    }

    // 定义一个子类
    class Dog extends Animal {
        // 构造函数
        constructor(name: string) {
            // 调用父类的构造函数，实现子类中属性的初始化操作
            super(name)
        }

        run(distance: number = 5) {
            console.log(`跑了${distance}米这么远的距离`, this.name)
        }
    }

    // 定义一个子类
    class Pig extends Animal {
        // 构造函数
        constructor(name: string) {
            // 调用父类的构造函数，实现子类中属性的初始化操作
            super(name)
        }

        run(distance: number = 10) {
            console.log(`跑了${distance}米这么远的距离`, this.name)
        }
    }

    // 实例化父类对象
    const ani: Animal = new Animal('动物')
    ani.run(1)

    // 实例化子类对象
    const dog: Dog = new Dog('大黄')
    dog.run()
    const pig: Pig = new Pig('大猪')
    pig.run()

    // 父类类型创建子类对象
    const dog1: Animal = new Dog('小黄')
    dog1.run()
    const pig1: Animal = new Pig('小猪')
    pig1.run()

    function showRun(animal: Animal) {
        animal.run()
    }

    showRun(new Dog('小狗狗'))
    showRun(new Pig('小猪猪'))

修饰符

public 公共的 默认
private 私有的 子类也无法访问该属性，外部也不能访问s
protected 受保护的 子类可以访问，外部不能访问

readonly

readonly修饰符：只读
构造函数中，可以对只读的属性成员的数据进行修改

    class Person {
        readonly name: string
        constructor(name: string) {
            this.name = name
        }
    }

存取器

存取器：让我们可以有效的控制对 对象中的成员进行访问，getters和setters

    class Person {
        firstName: string
        lastName: string

        constructor(firstName: string, lastName: string) {
            this.firstName = firstName
            this.lastName = lastName
        }

        // 读取器
        get fullName() {
            return this.firstName + '_' + this.lastName
        }

        // 设置器
        set fullName(val) {
            let names = val.split('_')
            this.firstName = names[0]
            this.lastName = names[1]
        }
    }

    // 实例化对象
    const person: Person = new Person('kudo', 'sama')
    console.log(person.fullName)
    person.fullName = '诸葛_孔明'
    console.log(person.fullName)

静态成员

    // 定义一个类
    class Person {
        static name1: string = 'kudo'

        static sayHi() {
            console.log('你好呀')
        }
    }

    console.log(Person.name1)
    Person.name1 = '张三'
    console.log(Person.name1)
    Person.sayHi()

抽象类

抽象类：包含抽象方法，抽象类不能被实例化
抽象类的目的是为了子类服务的

    // 定义一个抽象类
    abstract class Animal {
        // 抽象方法
        abstract eat()

        sayHi() {
            console.log('你好呀')
        }
    }

    // 定义一个子类
    class Dog extends Animal {
        // 实现父类中的抽象方法
        eat() {
            console.log('我是干饭狗')
        }
    }

    // 实例对象
    const dog: Dog = new Dog()
    dog.eat()
    dog.sayHi()