一、构造函数

  定义:类实例是由一个特殊的类方法构造的,这个方法名通常和类名相同,被称为构造函数。这个方法的任务就是初始化实例需要的所有信息(注:需要用 new 来调用,这样语言引擎才知道你想要构造一个新的类实例)

与其他高级语言中类的概念不同的是:

  (1)其他语言中,构造函数是属于类的,但在javascript中,类是属于构造函数的。类似于Foo.prototype .

class Brid{
            constructor(name,color){
                this.name = name;
                this.color = color;
            }

            show(){
                console.log(`这是一只${this.color}的${this.name}`);
            }
        }
        
        const brid = new Brid("麻雀","白色");
        brid.show();        //这是一只白色的麻雀
        console.log(Brid.prototype);        //{constructor: ƒ, show: ƒ}
        //结论:对于真正的类来说,构造函数是属于类的。然而,在JavaScript中恰好相反——实际上“类”是属于构造函数的

 二、实例化

  把类的行为复制到实例中。

三、继承

  类的继承其实就是复制,子类得到的只是父类的一个副本。因此,子类“重写”方法并不会影响到父类。(javascript本身并不存在“类”,只有对象,所以不会自动执行复制行为)类被继承时,将父类行为也会被复制到子类中,但在javascript中不会自动执行复制行为,开发者 混入 来实现复制。下面是对混入的详细介绍:

  混入:

    分为:显式混入和隐式混入。

     (1)显式混入:

//混入来实现继承
        //显式混入
        function mixin(sourceObj,targetObj){
            for(var key in sourceObj){
                if(!(key in targetObj)){
                    targetObj[key] = sourceObj[key];
                }
            }
            return targetObj;
        }
        const parent = {
            name: 'parent',
            obj: {
                name: "5346"
            },
            show: function(){
                console.log("my name is "+this.name);
            }
        };
        const son = mixin(parent,{
            name: 'son',
            say: function(){
                console.log("hello!!!");
            }
        });
        console.log(son);       //{name: "son", say: ƒ, arr: Array(4), show: ƒ}
        son.show();     //my name is son

        son.obj.name = 'zxn'
//混入实际上不能完全模拟面向类的语言的复制,复制到只是函数对象的引用。一旦操作,子类和父类都会发生改变。
        console.log(son.obj);        //{name: 'zxn'}
        console.log(parent.obj);       //{name: 'zxn'}

    (2)隐式混入:

//隐式混入
        const parent = {
            cool: function(){
                this.name = "parent";
                this.say = function(){
                    console.log("My name is "+ this.name);
                }
            }
        };
        const son = {
            cool: function(){
                parent.cool.call(this);
                this.name = "son";
            }
        };
        son.cool();
        son.say();      //My name is son

四、总结:

  类是一种设计模式。类意味着复制。传统的类被实例化时,它的行为会被复制到实例中。类被继承时,行为也会被复制到子类中。多态(在继承链的不同层次名称相同但是功能不同的函数)看起来似乎是从子类引用父类,但是本质上引用的其实是复制的结果。