Ts—面向对象

Ts—面向对象

三大特征

1.封装

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

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
    }
}

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或者get/set
    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
    }
}

2.继承

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
    }
}
// class C extends A{}
let ba:B=new B(1,2,3,4,5);
ba.bb()

注意

1.继承的关键字 extends

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

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

4.object 类是所有类的父类,没有显示继承的类都默认继承object

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

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

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

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

9.方法同名时:能不能同名?怎么调用?

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

3.多态

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

//宠物
class Pet{
    name:string
    sex:string
    health:number
    love:number
    constructor(name:string,sex:string,health:number,love:number){
        this.name=name
        this.sex=sex
        this.health=health
        this.love=love
    }
    eat(food:string){
        console.log('宠物在吃'+food+',健康值+1');
        this.health+=1;//健康值加1
    }
    show():string{
        return `昵称:${this.name},性别:${this.sex},健康值:${this.health},亲密度:${this.love}`
    }
}
//狗
class Dog extends Pet{
    type:string
    constructor(type:string,name:string,sex:string,health:number,love:number){
        super(name,sex,health,love)
        this.type=type
    }
    //重写
    eat(food: string): void {
        if(this.health<=97){
            this.health+=3
        }else{
            this.health=100
        }
        console.log(`狗在吃:${food},健康值+3,当前健康值:${this.health}`);
    }
    show():string{
        let str:string=super.show();
        return str+`,品种:${this.type}`
    }
    jfp(){
        console.log(`狗仔接飞盘,健康值-10,亲密度+5`)
        this.health-=10
        this.love+=5
    }
}
//🐧企鹅
class Pengun extends Pet{
    age:number
    constructor(age:number,name:string,sex:string,health:number,love:number){
        super(name,sex,health,love)
        this.age=age
    }
    eat(food: string): void {
        if(this.health<=95){
            this.health+=5
        }else{
            this.health=100
        }
        console.log(`企鹅在吃:${food},健康值+5,当前健康值:${this.health}`);
    }
    show():string{
        let str:string=super.show();
        return str+`,年龄:${this.age}`
    }
    yy(){
        console.log(`企鹅在游泳,健康值-8,亲密度+3`)
        this.health-=8
        this.love+=3
    }
}
//猫
class Cat extends Pet{
    type:string
    constructor(type:string,name:string,sex:string,health:number,love:number){
        super(name,sex,health,love)
        this.type=type
    }
    eat(food: string): void {
        if(this.health<=97){
            this.health+=3
        }else{
            this.health=100
        }
        console.log(`猫在吃:${food},健康值+3,当前健康值:${this.health}`);
    }
    show():string{
        let str:string=super.show();
        return str+`,品种:${this.type}`
    }
    mxq(){
        console.log(`猫在玩毛线球,健康值-10,亲密度+5`)
        this.health-=10
        this.love+=5
    }
}
//主人: 领养宠物 喂养宠物
class Master{
    // getDog():Dog{
    //     let dog:Dog=new Dog('柯基','小飞侠','公',90,80)
    //     // console.log(`恭喜你领养了一个宠物狗:${dog}`)
    //     return dog
    // }
    // getPengun():Pengun{
    //     let p:Pengun=new Pengun(3,'皇帝','公',80,90)
    //     // console.log(`恭喜你领养了一个宠物企鹅:${p}`)
    //     return p
    // }

    getPet(p:Pet){
        console.log(p.show())
    }
    //以父类作为形参实现多态
    //喂宠物
    feedPet(p:Pet){
        //判断p是不是狗  instanceof 判断一个对象是不是某个类型
        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.mxq()
        }
    }
}
let m:Master=new Master();
let dd:Dog=new Dog('柯基','小飞侠','公',90,80)
let str=m.getPet(dd)
m.feedPet(dd)
let pg:Pengun=new Pengun(3,'皇帝','公',80,90)
m.feedPet(pg)
m.play(pg)
let mm:Cat=new Cat('缅因','飞侠','公',90,80)
m.feedPet(mm)
m.play(mm)

//1.加一个宠物猫
//2.领养猫,喂猫,陪猫玩耍
//3.找图片  宠物(猫,狗,企鹅)    吃(狗吃骨头的动图...)   玩(动图)

//
// let ms:Master=new Master()
// let dog:Dog=ms.getDog()
// console.log(`恭喜你领养了一个宠物狗:${dog.name}`)
// let pg:Pengun=ms.getPengun()
// console.log(`恭喜你领养了一个宠物企鹅:${pg.name}`)