04 ts面向对象, 类, 对象类型补充

是云呀！

已于 2022-10-26 17:40:48 修改

阅读量316

点赞数

分类专栏： ts 文章标签： 1024程序员节 typescript

于 2022-10-24 18:22:07 首次发布

本文链接：https://blog.csdn.net/yunbabac/article/details/127495136

版权

ts 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

类的基本使用

class Person {
  // 在ts中,如果成员有属性,需要在class中声明
  name: string = ''
  age: number = 0

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}

const person1 = new Person('zhao', 18)
console.log(person1.name);
console.log(person1.age);



export {}

类的继承

类的继承与js差别不大

class Person {
    // 在ts中,如果成员有属性,需要在class中声明
    name: string = ''
    age: number = 0

    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
    eating() {
        console.log('person eating');
    }
}
class Son extends Person {
    height: number = 0
    constructor(name: string,age: number ,height: number) {
        super(name, age)
        this.height = height
    }
    eating() {
        super.eating()           
        console.log('son eating'); 
    }
}
const son = new Son('zhao', 18, 1.88)
son.eating() // person eating,son eating
  
export {}

类的成员修饰符

在ts中,类的属性与方法支持三种修饰符

public: 修饰的是在任何地方可见,共有的属性或方法,不写默认就是public

private: 修饰的是在类本身中可见(实例对象不可访问),私有的属性或方法

protected: 修饰的是仅在类本身级子类中可见,受保护的属性或方法

class Person {
    public name: string = ''
    private age: number = 0
    protected height: number = 0

    constructor(name: string, age: number, height: number) {
        this.name = name
        this.age = age
        this.height = height
    }
    eating() {
        console.log('person eating');
        console.log(this.age, this.height);
    }
}
class Son extends Person {
    constructor(name: string,age: number ,height: number) {
        super(name, age, height)
    }
    run() {
        // console.log(this.age); // 私有,子不能访问
        console.log(this.height); // 保护,子可以访问
    }
}
const person = new Person('qun', 44, 1.77)
console.log(person.name);
// console.log(person.age); // 私有,不能访问
// console.log(person.protected); // 受保护,不能访问


const son = new Son('zhao', 18, 1.88)
// console.log(son.height); // 保护,子类实例对象不能访问

  
export {}

类的readonly修饰符

class Person {
    readonly name: string = ''
    age: number = 0
    height: number = 0

    constructor(name: string, age: number, height: number) {
        this.name = name
        this.age = age
        this.height = height
    }

}

const person = new Person('qun', 44, 1.77)
console.log(person.name);
// person.name = 'cheng' // 只读,不能修改

  
export {}

类的get与set访问器

class Person {
    // 约定俗成,对于私有属性前加_
    private _name: string = ''
    constructor(name: string) {
        this.name = name
    }
    // set/get 对外开发,主要是可以做一些拦截操作
    set name(newValue) {
        this._name = newValue
    }
    get name() {
        return this._name
    }

}

const person = new Person('qun')
person.name = 'cheng'
console.log(person.name); //cheng

  
export {}

ts中类的参数属性

可以看做是一种语法糖写法

在构造函数参数前添加一个可见性修饰符 public private protected readonly 来创建参数属性,最后这些类属性字段也会得到这些修饰符

class Person {
    // name: string = ''
    // age: number = 0
    // height: number = 0

    // constructor(name: string, age: number, height: number) {
    //     this.name = name
    //     this.age = age
    //     this.height = height
    // }
    // 以下为语法糖
    constructor( public name: string, public age: number, public height: number) {
    }
}

const person = new Person('qun', 44, 1.77)

export {}

抽象类与方法abstract

抽象类不能被实例化

抽象方法存在于抽象类中

抽象类中可以有普通方法(有实现体)

子类必须实现抽象类

// 学过Java的应该对抽象类较为了解,把具体事物的共同特性抽象出来(个人理解)
// 抽象类不能实例化
abstract class Aimal { // 抽象类,所有动物都会吃
    abstract eating() // 抽象方法只能出现在抽象类中,不需要有实现体
}

class Cat extends Aimal {
    // 子类必须实现抽象类的抽象方法
    eating() {
        console.log("猫吃鱼");
    }
}

class Dog extends Aimal {
    eating() {
        console.log("狗吃屎");
    }
}

// 通用方法,这里参数类型是Aimal
function getAimalEat(aimal: Aimal) {
    aimal.eating()
}
// 这里也是多态的体现,继承是多态实现前提,龙生九子各有不同
getAimalEat(new Cat())
getAimalEat(new Dog())