Typescript学习5 ( class类 | 抽象类 )

目录

一、ts中如何定义类

ES6提供了更接近传统语言的写法,引入了Class这个概念作为对象的模板,可以看作是一个语法糖

二、类的修饰符

1.public：可以让你定义的变量内部访问,也可以外部访问,如果不写默认就是public

2.private: 代表定义的变量私有的只能在内部访问,不能在外部访问

3.protected :代表定义的变量私有的只能在内部和继承的子类中访问,不能在外部访问

三、static静态属性和静态方法

1.static静态属性

2.static静态方法

四、interface定义类

ts 中interface 定义类使用关键字 implements,后面跟interface的名字多个用逗号隔开,继承还是用extends

五、抽象类(基类)

抽象类无法实例化，抽象方法只能出现在抽象类中

---

一、ts中如何定义类

ES6提供了更接近传统语言的写法,引入了Class这个概念作为对象的模板,可以看作是一个语法糖

class Person{
    name: string //ts中constructor中不许直接定义变量，要在constructor上方先进行声明
    age:number = 0 //取默认值或赋值,如果构造函数里已赋值，则不用
    constructor(name:string,age:number) {
        this.name=name
        this.age=age
    }
    run() {
    }
}

二、类的修饰符

1.public：可以让你定义的变量内部访问,也可以外部访问,如果不写默认就是public

class Person {
    public name: string
    private age: number
    protected some: any
    constructor(name: string, age: number, some: any) {
        this.name = name
        this.age = age
        this.some = some
    }
    run() {
    }
}
let person = new Person('小胖', 18, 3)
console.log(person.name); //结果为小胖

2.private: 代表定义的变量私有的只能在内部访问,不能在外部访问

3.protected :代表定义的变量私有的只能在内部和继承的子类中访问,不能在外部访问

class Man extends Person{
    constructor() {
        super('小王', 22, 1)
        console.log(this.some); //protected属性只能在内部及子类中使用
    }
    create() {
        console.log(this.some); //protected属性只能在内部及子类中使用
    }
}
let person = new Person('小胖', 18, 3)
let man = new Man
console.log(man.age); //报错，外部不能访问priviate属性

三、static静态属性和静态方法

1.static静态属性

static 定义的属性,不可以通过this 去访问,只能通过类名去调用

class Person {
    public name: string
    private age: number
    protected some: any
    static sex: string = '男' 
    constructor(name: string, age: number, some: any) {
        this.name = name
        this.age = age
        this.some = some
        this.sex //报错
    }
    run() {
    }
}
console.log(Person.sex) //结果为 男

2.static静态方法

static 静态函数,同样也是不能通过this 去调用,也是通过类名去调用

如果两个函数都是static 静态的是可以通过this互相调用

class Person {
    public name: string
    private age: number
    protected some: any
    static sex: string = '男'
    constructor(name: string, age: number, some: any) {
        this.name = name
        this.age = age
        this.some = some
    }
    static run() {
        console.log('123456'); 
    }
    static read() {
        return this.run() //通过this来调用静态方法run()
    }
}
Person.read() //结果为123456

四、interface定义类

ts 中interface 定义类使用关键字 implements,后面跟interface的名字多个用逗号隔开,继承还是用extends

interface PersonClass {
    get(type: boolean): boolean
}
interface PersonClass2 {
    set(): void,
    asd: string
}
class A {
    name: string
    constructor() {
        this.name = "123"
    }
}
class Person extends A implements PersonClass, PersonClass2 {
    asd: string
    constructor() {
        super()
        this.asd = '123'
    }
    get(type: boolean) {
        return type
    }
    set() {
    }
}
let person = new Person()
console.log(person.asd, person.get(true)) //结果为 123，true

五、抽象类(基类)

抽象类无法实例化，抽象方法只能出现在抽象类中

abstract class Person {
    name: string
    constructor(name: string) {
        this.name = name
    }
    getName(): string {
        return this.name
    }
    abstract change(name:string):void //抽象方法只能出现在抽象类中
}
let person = new Person() //报错，抽象类无法创建实例

通过派生类去继承基类，且定义的抽象方法必须在派生类实现

class Student extends Person {
    constructor() {
        super('')
    }
    change(name: string) {
​
    }
    setName(name: string) {
        this.name = name
    }
}
let student = new Student()
student.setName('小胖')
console.log(student.getName());