面向对象(封装/继承/多态)

面向对象

封装

访问修饰符以及公/私有关键字如下:

export class Pet{
    // 访问修饰符   本类,本包,其他包,子类
    // public 共有的    任何位置都可以访问
    public id:number
    // default  默认
    name:string
    private sex:string
    b(){
        console.log('默认');
    }
    // 私有的   只允许本类访问
    private a(){
        console.log('私有');
    }
    constructor(id:number,name:string,sex:string){
        this.id=id
        this.name=name
        this.sex=sex
    }
}

封装: 隐藏对象的属性对外只提供可以访问属性的方法

通过private关键字来私有化属性

再提供一个共有的方法来访问属性,分别为 getter/setter,其中getter方法来返回它的值,而setter方法去设置或更新它的值.

调用时必须使用get函数访问属性

class Pets{
    constructor(id:number,name:string,sex:string,helth:number,love:number){
        this.id=id
        this.name=name
        this.sex=sex
        this.helth=helth
        this.love=love
    }
    // 1.私有化属性
    private id:number
    private name:string
    private sex:string
    private helth:number//健康值
    private love:number//亲密度
    // 2.提供一个共有的方法来访问属性  getter/setter
    public getId():number{
        return this.id
    }
    public getName():string{
        return this.name
    }
    public getSex():string{
        return this.sex
    }
    public getHelth():number{
        return this.helth
    }
    public getLove():number{
        return this.love
    }
    // set 设置/赋值
    public setId(id:number){
        this.id=id
    }
    public setName(name:string){
        this.name=name
    }
    public setSex(sex:string){
        this.sex=sex
    }
    public setHelth(helth:number){
        this.helth=helth
    }
    public setLove(love:number){
        this.love=love
    }
}
let p:Pets=new Pets(1,'大黑','公',100,100)
p.setHelth(90)//调用函数修改属性的值
// 必须使用get函数访问属性
console.log(`序号:${p.getId()},昵称:${p.getName()}`);

继承

继承是面向对象编程中的一种机制，它允许一个类（子类）从另一个已存在的类（父类）直接获得属性和方法。通过继承，子类不仅可以复用父类的定义，还可以在其基础上添加新的特性或覆盖、扩展父类的功能。这意味着子类可以被视为父类的特化版本。

在继承结构中，父类是超类，提供了一组通用的行为；子类则继承了这些行为，并可以根据需要添加或修改特定功能。这种方式提高了代码的模块性和复用性，使得设计更加层次分明。

在继承中,子类使用父类的属性时需要通过super关键字来调用,并且调用父类的构造函数,必须写在构造函数的第一行

// 继承     子类继承父类的属性和方法
class A{
    public a1:number
    a2:number
    private a3:number
    constructor(a1:number,a2:number,a3:number){
        this.a1=a1
        this.a2=a2
        this.a3=a3
    }
    public getA3():number{
        return this.a3
    }
    public setA3(a3:number){
        this.a3=a3
    }
    private aa(){
        console.log('私有方法');
    }
    public bb(){
        console.log('父类的共有方法');
    }
}
// 子类
class B extends A{
    // 子类可以有自己的属性和方法
    b1:number
    b2:number
    b3(){
        console.log('b的函数');
        console.log(this.a1);
        console.log(this.a2);
        // 子类无法继承父类的私有属性和方法
        // console.log(this.a3);
        // this.aa()
        this.bb()
    }
    // 派生类的构造函数必须包含 "super" 调用
    constructor(a1:number,a2:number,a3:number,b1:number,b2:number){
        // 调用父类的构造函数   必须写在构造函数的第一行
        super(a1,a2,a3)
        this.b1=b1
        this.b2=b2
    }
}
let ba:B=new B(1,2,3,4,5)
ba.bb()

同时调用父类的方法,需要使用super关键字

class Person{
    constructor(name:string,sex:string){
        this.name=name
        this.sex=sex
    }
    name:string
    sex:string
    eat(){
        console.log('人的吃喝');
    }
}
class GoodPerson extends Person{
    color:string
    sex: string
    constructor(name:string,sex:string,color:string){
        super(name,sex)
        this.color=color
        this.sex=sex
    }
    hs(){
        console.log(this.sex+'好人在做好事');
    }
    eat(){
        // 调用父类的方法,需要使用super关键字
        super.eat()
        console.log('人的吃喝');
    }
}
let hr:GoodPerson=new GoodPerson('张三','男','黄')
hr.hs()
hr.eat()

注意

在使用继承是需要注意以下几点:

1.继承的关键字 extends

2.子类继承父类 只能继承一个类(单继承)

3.一个父类 可以有多个子类

4.object 类是所有类的父类

5.子类必须调用父类的构造函数,构造函数必须在第一行

6.子类不能继承父类的私有属性和方法

7.想要在子类中调用父类的属性和方法需要使用this关键字

8.子类属性和父类属性同名,默认使用子类的属性

9.方法可以同名,默认调用子类方法,可以使用super调用父类方法

多态

多态的概念：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

方法的重载:

// 方法的重载
// 在同一个类中,方法同名,返回值和参数不同
class A{
    a1():void{
        console.log('第一个');
    }
    // a1(num:string){
    //     return ''
    // }
}
// 方法的重写:子类重写父类的方法,方法名相同
// 参数相同,返回值相同或者是其子类
class B extends A{
    a1(): void {
        console.log('子类的重写');
    }
}
let b:B=new B()
b.a1()

练习

以下是对多态的练习扩展

// 宠物
class Pet{
    name:string
    sex:string
    hea:number
    love:number
    constructor(name:string,sex:string,hea:number,love:number){
        this.name=name
        this.sex=sex
        this.hea=hea
        this.love=love
    }
    eat(food:string){
        console.log('宠物再吃'+food,'健康值加1');
        this.hea+=1;//健康值加1
    }
    show():string{
        return `昵称:${this.name},性别:${this.sex},健康值:${this.hea},亲密度:${this.love}`
    }
}
// 狗
class Dog extends Pet{
    type:string
    constructor(type:string,name:string,sex:string,hea:number,love:number){
        super(name,sex,hea,love)
        this.type=type
    }
    // 重写
    eat(food: string): void {
        if(this.hea<=97){
            this.hea+=3
        }else{
            this.hea=100
        }
        console.log(`狗在吃:${food},健康值加3,当前健康值:${this.hea}`);
    }
    show(): string {
        let str:string=super.show();
        return str+`,品种:${this.type}`
    }
    jfp(){
        console.log(`狗在接飞盘,健康值-10,亲密度+5`);
        this.hea-=10
        this.love+=5
    }
}
// 企鹅
class Pengun extends Pet{
    age:number
    constructor(name:string,sex:string,age:number,hea:number,love:number){
        super(name,sex,hea,love)
        this.age=age
    }
    eat(food: string): void {
        if(this.hea<=95){
            this.hea+=5
        }else{
            this.hea=100
        }
        console.log(`企鹅在吃:${food},健康值加5,当前健康值:${this.hea}`);
    }
    show(): string {
        let str:string=super.show();
        return str+`,年龄:${this.age}`
    }
    yy(){
        console.log(`企鹅在游泳,健康值-8,亲密度+3`);
        this.hea-=8
        this.love+=3
    }
}
class Cat extends Pet{
    color:string
    constructor(name:string,sex:string,color:string,hea:number,love:number){
        super(name,sex,hea,love)
        this.color=color
    }
    eat(food: string): void {
        if(this.hea<=95){
            this.hea+=5
        }else{
            this.hea=100
        }
        console.log(`猫在吃:${food},健康值加5,当前健康值:${this.hea}`);
    }
    show(): string {
        let str:string=super.show()
        return str+=`,毛色:${this.color}`
    }
    wmx(){
        console.log(`猫在玩毛线,健康值-5,亲密度加5`);
        if(this.hea>=8&&this.love<=95){
            this.hea-=5
            this.love+=5
        }
        console.log(`当前健康值:${this.hea},当前亲密度:${this.love}`);
    }
}
// 主人:    领养宠物   喂宠物
class Master{
    // getDog():Dog{
    //     let dog:Dog=new Dog('泰迪','奥龙队','公',90,80)
    //     return dog
    // }
    // getPengun():Pengun{
    //     let p:Pengun=new Pengun('瑶瑶','公',3,90,80)
    //     return p
    // }
    getPet(p:Pet){
        console.log(p.show());
    }
    // 以父类作为形参实现多态
    // 喂宠物
    feedPet(p:Pet){
        // 判断p是不是狗   判断一个对象是不是某个类型
        if(p instanceof Dog){
            p.eat('骨头')
        }else if(p instanceof Pengun){
            p.eat('鱼')
        }else if(p instanceof Cat){
            p.eat('猫粮')
        }
    }
    // 玩游戏
    play(p:Pet){
        // as断言
        // let pg:Pengun=p as Pengun;
        // pg.yy()
        if(p instanceof Dog){
            // 前边已经做了类型判断,所以系统会自动把对象转换为对应的类型
            p.jfp()
        }else if(p instanceof Pengun){
            p.yy()
        }else if(p instanceof Cat){
            p.wmx()
        }
    }
}
let m:Master=new Master();
let dd:Dog=new Dog('泰迪','龙队','母',80,70)
let str=m.getPet(dd)
// m.feedPet(dd)
let pg:Pengun=new Pengun('泰迪','龙队',3,80,70)
m.feedPet(pg)
m.play(pg)
let cc:Cat=new Cat('阿狸','母','狸花',70,70)
let str1=m.getPet(cc)
m.feedPet(cc)
m.play(cc)