面向对象的三大特征

面向对象的三大特征：封装 继承 多态、

一.封装

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

访问修饰符有：

1.public：公用 任何位置都可以访问

2.private:私有 ，只允许本类访问

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

1.如何使用封装

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

1.私有化属性并初始化

2.提供一个公用的方法来访问属性一般用get/set 或getter/setter来访问属性和设置或赋值

3.实例化并打印

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.提供一个公有的方法来访问属性 get/set || getter//setter
    public getetId():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.helth=99
p.setHelth(90) //调用函数修改属性的值
//必须使用get函数访问属性
console.log(`序号:${p.getetId()},昵称：${p.getName()}`);

二. 继承

1.继承

继承关键字:extends子类继承父类的属性和方法,通过export 导出,用improt导入。

//导包
import { Pet } from "../bb/extends";
//
//创建父类
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
    }
    //获取私有属性 返回a3的值
    public getA3():number{
        return this.a3
    }
    //设置获取的私有属性并赋值
    public setA3(a3:number){
        this.a3=a3
    }
    //设置 aa方法为私有属性
    private aa(){
        console.log('私有方法');
        
    }
    // 设置bb方法为公有方法
    public bb(){
        console.log('父类的公有方法');
        
    }
}
 
//创建子类B 继承了父类 A的属性和方法
 
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)
console.log(ba);
ba.bb()
 
 

2.继承的关键字：extends

1.继承的关键字 extends
 
//列子
 
class A{
    name:string
    constructor(name:string){
        this.name=name
    }
}
 
class B extends A{}

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

class R{
    public Name:string
    public Sex:string
    public chi(){
        console.log('平淡的一天');
        
    }
    constructor(Name:string,Sex:string){
        this.Name=Name
        this.Sex=Sex
    }
}
let h:R=new R('李四','男')
console.log(`姓名：${h.Name},性别：${h.Sex}`);
h.chi()
class H extends R{
    fs:string
    hs(){
        console.log(this.Name+':'+'做好事');
    }
    constructor(Name:string,Sex:string,fs:string){
        super(Name,Sex)
        this.fs=fs
    }
}
let h1:H=new H('张三','男','黄色')
console.log(`姓名：${h1.Name},性别：${h1.Sex},肤色：${h1.fs}`);
h1.hs()
 
class Huai extends R{
    dq:string
    hs(){
        console.log(this.Name+':'+'做坏事');
    }
    constructor(Name:string,Sex:string,dq:string){
        super(Name,Sex)
        this.dq=dq
    }
}
let h2:Huai=new Huai('王五','男','北京')
console.log(`姓名：${h2.Name},性别：${h2.Sex},地区：${h2.dq}`);
h2.hs()

1.object类时所有类的父类,没有显示的继承的类都默认继承object，继承了object中转换字符串的toString方法。

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

3.super：调用父类的构造函数方法。

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

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

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(){
        //调用父类的属性和方法需要使用this关键字
        console.log(this.sex+'好人都上天堂');
        
    }

6.子类属性和父类属性同名，默认使用子类的属性

//实例化对象
let hr:GoodPerson=new GoodPerson('张三','男','黄')
//调用hs方法
hr.hs()
//子类属性和父类属性同名，默认使用子类的属性
//

7.有种方法可以同名，默认调用子类方法，可以使用super调用父类方法

eat(){
        // 调用父类的方法需要使用super关键字
        super.eat()
        console.log('好人都上天堂');
        
    }
//使用super可以调用父类方法，但是只能写到构造函数里

三. 多态

多态有方法的重载，方法的重写等
1.方法的重载的概念

在同一个类中，方法名相同，返回值和参数不同，ts中无法使用，arkts中使用。

2.方法的重写

子类重写父类的方法，方法名相同，参数相同，返回值相同或者是其子类。

//创建一个父类 A
class A{
    a1():void{
        console.log('第一个'); 
    }
}
 
子类 B 继承 父类 A
class B extends A{
    a1(): void {
        console.log('子类的重写');
        
    }
}
 
let b:B=new B()
b.a1()