JS面向对象总结

function Dog(name,size){
    this.name = name || '二哈'
    this.size = size || '中等'
}

Dog.prototype.bark = function(){
    console.log(`${this.name}在叫！`)
}

let shinubi = new Dog('shinubi','小')
let peiqi = new Dog('peiqi','肥')
shinubi.bark()
console.log(shinubi.constructor==Dog)//true
peiqi.bark()
console.log(peiqi.bark === shinubi.bark)//true

console.log(peiqi.__proto__ === Dog.prototype)//true
console.log(Dog.prototype.isPrototypeOf(peiqi))//true
console.log(peiqi.hasOwnProperty("bark"));
console.log("bark" in peiqi);

for (const key in peiqi) {
    console.log(key);
}//name size bark

function Animal(){
    this.species = 'animal'
}
Animal.prototype.showId = '动物'
/**
 * 在构造函数中使用call或者apply的方式继承
 */
function Dog(name,size){
    Animal.apply(this)
    this.name = name || '二哈'
    this.size = size || '中等'
}

let peiqi = new Dog('peiqi','肥')

console.log(peiqi.species);


/**
 * 将子类的原型指向父类的实例
 * 注意此种继承要多一步修正子类的原型上的 constructor
 */
function Pig(name,size){
    this.name = name || '悟能'
    this.size = size || '大'
}

Pig.prototype = new Animal()
Pig.prototype.constructor = Pig

let fatherPeiqi = new Pig('八戒','huge')

console.log(fatherPeiqi.species);

function Monkey(name,size){
    this.name = name || "悟空"
    this.size = size || '可小可大'
}
//此种方式直接让子类的原型指向父类的原型实现继承，缺点是变动子类的原型相当于变动父类的原型
Monkey.prototype = Animal.prototype

Monkey.prototype.constructor = Monkey

dasheng = new Monkey('大圣','大')
console.log(dasheng.showId);
console.log(Animal.prototype.constructor);//Mokey

/**
 * 利用中间空白类来实现干净的继承并且不会占用创建实例的内存
 * 综合了实例继承法的干净，和直接原型继承不耗费内存
 */

function midClass (){}

midClass.prototype = Animal.prototype

function People(name,size){
    this.name = name || '唐僧'
    this.size = size || '中等'
}

People.prototype = new midClass()
People.prototype.constructor = People

let tangseng = new People('玄奘','还好')

console.log(tangseng.showId);

/**
 * 拷贝继承
 */

function copyExtend(Child,Parent){
    for (const key in Parent.prototype) {
        if (Parent.prototype.hasOwnProperty(key)) {
            Child.prototype[key] = Parent.prototype[key]           
        }
    }
}

function Cat(){}

copyExtend(Cat,Animal)

let tom = new Cat()
console.log(tom.showId);//动物

function Animal(){
    this.species = 'animal'
    this.important = 'brain'
}
Animal.prototype.run = function(){
    console.log('跑');
}

function People(sex){
    this.important = 'people-brain'
    this.sex = sex || 'YAO'
}
People.prototype.eat = function(){
    console.log('吃饭');
}

function Man(name,age,sex){
    Animal.call(this)
    People.call(this,sex)
    this.name = name || 'ray'
    this.age = age || 18
}

for (const key in Animal.prototype) {
    if (Animal.prototype.hasOwnProperty(key)) {
        Man.prototype[key] = Animal.prototype[key]     
    }
}
for (const key in People.prototype) {
    if (People.prototype.hasOwnProperty(key)) {
        Man.prototype[key] = People.prototype[key]     
    }
}

let ray = new Man('ray',25,'man')

ray.run()
ray.eat()
console.log(ray.important);
console.log(ray.sex);
console.log(ray.species);

class Animal{
    constructor(){
        this.species = 'animal'
    }
    run(){
        console.log('跑！');
    }
}

class People extends Animal{
    constructor(name,sex){
        super()//必须在子类的构造函数中调用super()
        this.name = name || 'ray'
        this.sex = sex || 'man'    
    }
    eat(){
        console.log(`${this.name}正在吃饭`)
    }
}

let ray = new People()

console.log(ray.species)// animal
console.log(ray.sex)// man
ray.run()// 跑！
ray.eat()// ray正在吃饭

function People(name,age){
    if (new.target !== undefined) {
        console.log(new.target)
        this.name = name || 'ray'
        this.age = age || 18
    } else {
        throw new Error('必须用new来生成实例')
    }
}

let ray = new People('ray',22)

console.log(ray.name);//ray

People('ray',18)// Error

class People{
    constructor(name2,age){
        this.name2 = name2 || 'ray'
        this.age = age || 18
    }
    static run(){
        console.log(`${this.name2}在跑！`);
    }
    run(){
        console.log(`${this.name2}在跑！`);
    }
}
People.name2="人"
People.run()//人在跑！

let ray = new People('ray',25)

ray.run()//ray在跑!

class Man extends People{
    constructor(){
        super()
    }
    static run(){
        super.run()
        console.log(`更是${this.sex}人在跑`);
    }
}
Man.sex = "男"

Man.run()
// 人在跑！
// 更是男人在跑

class Animal{
    constructor(){
        if (new.target === Animal) {
            throw new Error('该类不能被实例化！')
        }else{
            this.species = 'animal'
        }
    }
}

class Wolf extends Animal{
    constructor(kind){
        super()
        this.kind = kind || '狼'
    }
    bark(){
        console.log(`${this.kind}在叫！`);
    }
}
let wolf = new Wolf()

console.log(wolf.species);//animal
wolf.bark()//狼再叫

let king = new Animal()//Error