继承、原型

<script type="text/javascript">
    //判断某个对象是不是某个构造函数的实例 方法：xxx instanseof 构造函数
    function Preson(){};
    var a = new Preson();
    console.log(a instanceof Preson);
    console.log(a)/*Preson {}
                        __proto__:Object  该对象中一般都有一个constructor属性
                            constructor:Preson()
                            __proto__:bject
                            */
    //typeof运算符，只能判断：数字、字符串、布尔值、undefiend、function(){}
    //typeof null === "object"
    //
    //
    //继承
    //概念：通过【某种方式】让一个对象可以访问到另一个对象中的属性和方法，
    //我们把这种方式称之为继承
    //
    //为什么有继承
    function Person(name,age){
        this.name = name,
        this.age = age,
        this.say = function(){}
    }
    var p1 = new Person();
    var p2 = new Person();
    //p1和p2的say方法不是同一个方法
    console.log(p1.say === p2.say);//false
    //由于say方法功能相似，但是不是同一个方法(没有指向同一块内存，会造成内存的浪费)
    //解决方法：把say方法卸载他们共同的（父对象）中
    //其实他们的共同的父对象，就可以通过：Person.prototype来获取
    //只要把say方法写在Person.prototype中，那么say方法就是同一个方法
    //
//**继承的第一种方式：
    Person.prototype.run=function(){//所有的Person的实例都能访问到run方法
        console.log("时速");
    }
    //此时p1、p2都能访问到run方法
    p1.run();//打印出时速
    p2.run();//打印出时速
    //验证p1.run和p2.run是不是同一个方法
    console.log(p1.run === p2.run);//true 指向同一个方法，这种方法避免了内存的浪费
    //结论：只要往某个构造函数的prototype对象中添加某个属性、方法，那么这样的属性、方法
    //都可以被所有的构造函数的实例所共享。
    //==>这里的【构造函数的prototype对象】称之为原型对象
    //Person.prototype 是 p1 p2 的原型对象
    //Person.prototype是Person构造实例的【实例】的原型对象
    //
    //
    //Person的原型对象是谁？
    //-->首先要知道Person的构造函数是：Function
    //-->所以Person的原型对象是：Function.prototype
    //
    //
    //p1的原型对象是谁？
    //-->首先要知道p1的构造函数是：Person   (先找构造函数)
    //-->所以p1的原型对象是：Person.prototype (再找构造函数上的prototype)
    //
    //
    //##所有的对象都继承自object,，但并不是直接创建
//***object创建了一个，这一个有创建出了其他的，或者更多，这种关系称之为--原型链
//**继承的第一种方式 --> 原型链继承
    function Dog(){}
    var d1 = new Dog();
    Dog.prototype.jiao = function(){
        console.log("汪汪汪")
    }
    d1.jiao();//汪汪汪
    Dog.prototype.s1 = function(){};
    Dog.prototype.s2 = function(){};
    Dog.prototype.s3 = function(){};
    //问题：如果有很多种方法，使用原型链继承会产生不少的重复代码
    //为了减少这种重复，改良版：
    Dog.prototype = {
        a1:function(){},
        a2:function(){},
        a3:function(){}
    }
    console.log(d1.s1);//function(){}  可以访问
    console.log(d1.a1);//undefined  访问不到  原因是：d1对象在创建的时候
    //已经有了一个确定的原型对象，就是旧的Dog.prototype，由于Dog.prototype
    //后面被重新赋值，但是d1对象的原型对象却没有改变，所以d1对象并不能访问到
    //新原型对象中的a1-a3方法。
    //
    //如何解决这个问题
//**原型链继承2
//--->注意：先改变原型，在创建对象
//          一般情况下，对于新原型，会添加一个constructor属性，从而不破坏原有的原型对象的结构
    function Tiger(){};
    Tiger.prototype = {
        // constructor:Tiger,      添加constructor属性
        a:function(){console.log("a")},
        b:function(){console.log("b")}
    };
    //创建tiger实例，此时的tiger实例的原型对象是新原型，
    //所以tiger可以访问到新原型中的属性和方法
    var tiger = new Tiger();
    console.log(tiger.a);//function(){console.log("a")}
    console.log(tiger.b);//function(){console.log("b")}


</script>