什么是多态？

什么是多态？

        同一个函数再不同情况下表现出的不同的状态。

        只要从父对象中继承来的东西（方法和属性）不好用，就可以自己在对象内部定义一个同
        名的成员，覆盖父对象中的成员  此过程称为 重写（override）

        多态包括重载（overload）和重写（override）

function Student(sname,sage){
    this.sname = sname;
    this.sage = sage;
}
var LiLei = new Student("Li Lei",11)
console.log( LiLei.toString() )    //"[object Object]"


function arr(){
    xxxxxxx
}
var arr = [1,2,3,4,5]
console.log( arr.toString() )// "1，2，3，4"


function Date(){
    xxxxxxx
}
var now = new Date()
console.log( now.toString() ) //Mon Mar 16 2024 14:15:33 GMT+0800


var ZhangSan ={
    sname:"Zhang San",
    sage : 20
}
console.log( ZhangSan.toString() )   //"[object Object]"

如何自己定义？

//在原型对象上定义属于自己的方法 并优先使用
Student.proto.toString= function(){
    return `{sanme:"${this.sname}" , sage:"${this.sage}"}`
}
 console.log( LiLei.toString() )   //{sanme:"Li Lei" , sage:"19"}


var ZhangSan ={
    sname:"Zhang San",
    sage : 20
    toString:function(){  //自定义某方法
        return `{sanme:"${this.sname}" , sage:"${this.sage}"}`
    }
}
 console.log( ZhangSan.toString() )   //{sanme:"Zhang San" , sage:"20"}

 自定义继承

        如果一个对象的整个父对象都不好用，就可以更换这个子对象的父对象   

       方法一： 对象._ _ proto _ _ = 新父对象 （有兼容性问题）           

function Student(sname,sage){
    this.sname = sname;
    this.sage = sage
}

var LiLei = new Student("Li Lei",19)
var ZhangSan = new Student("Zhang San",20)
console.log(LiLei ,ZhangSan)


var father={
    money:100000000,
    car:"BMA"
}
//修改父对象
ZhangSan.__proto__=father
console.log(LiLei ,ZhangSan)  // 输出结果如下图所示 只给ZhangSan的原型对象上添加了属性

     

        方法二：Object.setPrototypeOf (子对象，新的父对象)   

        设置子对象的原型为新的父对象

function Student(sname,sage){
    this.sname = sname;
    this.sage = sage
}

var LiLei = new Student("Li Lei",19)
var ZhangSan = new Student("Zhang San",20)
console.log(LiLei ,ZhangSan)

var father={
    money:100000000,
    car:"BMA"
}
//修改父对象
Object.setPrototypeOf(ZhangSan,father)
console.log(LiLei ,ZhangSan)

同时更换多个子对象的共同的父对象 （其实就是修改构造函数）

其实就是修改构造函数的prototype属性指向新的对象
        构造函数.prototype = 新原型对象

一定要找准时机，在创建第一个子对象之前就要更换！

var father={
    money:100000000,
    car:"BMA"
}

function Student(sname,sage){
    this.sname = sname;
    this.sage = sage
}
//修改Student构造函数的原型对象 为father
Student.prototype=father

var LiLei = new Student("Li Lei",19)
var ZhangSan = new Student("Zhang San",20)
console.log(LiLei ,ZhangSan)
console.log(LiLei.money,ZhangSan.money)  // 100000000  100000000  
                                         //因为是修改了原型对象所以他们两个共同修改了该属性
console.log(LiLei.car,ZhangSan.car)      // "BMA" "BMA"