面向对象笔记

         //    oop模式的面向对象
         //    抽象：事物要分文别类，不能在数组对象下用的方法拿到日期对象下用
         //    封装：只能通过对象来访问方法
         //    继承：子级不影响到父级,可以有交复用代码
         //    多态：他也是复用代码,他是定义接口
         //    对象的组成：
         //    方法（行为、操作）---函数：过程、动态的
         //    属性---变量：状态、静态的
         //    普通工厂构造函数
        function CreatePerson(name) {
                this.name = name;
                this.showName = function() {
                    alert(this.name);
                }
        }

        //这里如果不加new他是一个构造函数，只有对象才能调用方法，所以前面要加上new
        var p1 = new CreatePerson("小明");
        p1.showName();
        var p2 = new CreatePerson("小强");
        p2.showName();


         //对象引用
        var a = [1, 2, 3];
        b = a; //这里工把地址引用给了b，他们现在共用一个地址
        b.push(4); //所以这里改变b，a也会发生改成 a=1,2,3,4
        b = [1, 2, 3, 4]; //只要在程序中进行赋值的话他都会在内存里重开一个地址所以上面的a还是1,2,3
         //js是基于prototype的程序， 去改写对象下面共用的方法或属性,让他们在内存中只存在一份，好处是提高性能
         //像上面new了两上对象出来，同时调了两次不用地址的方法，这个对性能有很大影响
        var arr = [1, 2, 3];
        var arr2 = [1, 2, 3, 4];
        Array.prototype.sort = function() {
            ....
        }
        arr.sort();
        arr2.sort();
        //普通方法或属性的优先级要高于原型的方法或属性优先级
        arr.numb = 10;
        Array.prototype.numb = 20;
        alert(arr.numb); //弹出的是10;


        //包装对象：基本类型都是有自己的对应的包装对象(String,Number,Boolean),除了null和undefined
        //原型链：实例对象与原型之间的连接
        //a1要找到属性或方法是通过_proto_去找到他对应的原型Aaa.prototype对象如果没找到他
        //还会继续往外找Object.prototype，这就是原型链之间的关系
        function Aaa() {
            this.num = 10; //他的优先级最高
        }
        Aaa.prototype.num = 20; //优先级第二
        Object.prorotype.num = 30; //优先级最后
        var a1 = new Aaa(); //这是实例对象
        alert(a1.num);


        //constructor:查看对象的构造函数
        function Aaa() {
            .....
        }
        Aaa.prototype.constructor = Aaa; //他是函数创建后自动生成这样一个东西
        //下面这个是在原形对象上添加属于和方法 
        Aaa.prototype.name = "hello";
        Aaa.prototype.age = 30;
        Aaa.prototype.init = function() {}
        //这个是上面的简写,但这样写有区别，这个是个json{}里的是东西等于自己把这个Aaa.prototype给覆盖了
        //等于是Aaa.prototype=Object.prototype
        //上面的 Aaa.prototype.constructor=Aaa;指向会发生变化constructor会指看Object
        Aaa.prototype = {
            constructor: Aaa, //上面的解决方案是这里可以写这个指向到Aaa
            name: 'hello', //这样写是原型下的属性
            age: 30,
            init: function() { //这样写是原型下的方法
            }
        }
        var a1 = new Aaa();
        alert(a1.constructor); //对象所对应的构造函数