面向对象基础（1）

什么是面向对象？

首先面向对象三大特性：抽象、封装、继承、（oop）

　　抽象 ：抽--把主要的特征、跟问题相关的特征抽出来。

　　封装：看不到里面的东西，用好表面的功能就行了。

　　继承：从父类上继承出一些方法和属性，子类，又有一些自己的特性（最大限度重用已有的代码）

        　　   继承有多重继承和多态继承。

对象的组成：

1. 方法：和函数类似，函数是自由的，但方法具有归属的对象，这两者都是过程量，是动态的；
2. 属性：和变量类似，变量是自由的，但属性具有归属的对象，这两者都是状态量，是静态的

this: 当前的方法属于谁就指向谁；

var arr=[1,2,3];
        arr.a=12;
        arr.show=function(){
            alert(this.a);
        }
        arr.show();

//结果：12

new：通过new+构造函数来构造对象，

　　    加上new 系统会偷偷做两件事：1.创建一个空白对象。2.返回出这个对象

　　    可以理解为“new”会先通过系统在函数内部创建var this=new Object()这个对象，然后在最后的时候又自动返回return this这个对象。

第一个面向对象的程序：

var obj=new Object(); //创建

obj.name="wy"; //属性
obj.qq="749996714";

obj.objName=function(){ //方法
alert("我的名字是" + this.name);    
}

obj.objQQ=function(){
alert("我的qq是" + this.qq);
}
obj.objName(); //调用
obj.objQQ();

构造函数：能构造一个对象的函数，功能与普通函数一样；

工厂方式：创建空白对象，加工对象，返回对象；缺点：创建时没有’new’，函数重复导致资源浪费；

function createPerson(name,qq){   //构造函数  --里面的功能是构造一个对象出来
            
            //原料
            var obj=new Object();  
            
            //加工
            obj.name=name;  
            obj.qq=qq;
            
            obj.objName=function(){  
                alert("我的名字是" + this.name);                
            }
            
            obj.objQQ=function(){
                alert("我的qq是" + this.qq);
            }
            
            //出厂
            return obj; 
        }
        
            var obj=createPerson("wy","749996714"); //调用
            
            obj.objName(); //调用
            obj.objQQ();
            
            var obj2=createPerson("hk","12345678") //调用
            
            obj2.objName(); //调用
            obj2.objQQ();

原型(prototype)：可以理解为css中的class， 能够同时给多个对象加方法；

        var arr=new Array(1,2,3);  
        var arr2=new Array(1,2,3);
        Array.prototype.sum=function(){   //相当于class
        //arr.sum=function(){              //相当于行间样式
            var result=0;
            for(var i=0;i<this.length;i++)
            {
                result+=this[i];
            }
            return result
        }
        
        alert(arr.sum());
        alert(arr2.sum());

类和对象：前者不具备实际功能，而后者具有，它们之间的关系就相当于模子和产品的关系；为了同时给多个对象加方法，那么就需要在类上面加原型，既可以给系统对象加也可以在创建的对象加；

对象命名规范：为了和系统对象保持一致，自己构造出来的对象命名时最好也保持首字母大写；

 

解决工厂方式缺点：

function CreatePerson(name,qq){   //构造函数 
            this.name=name;  //不一样的 放在构造函数里
            this.qq=qq;                            
        }
        
        CreatePerson.prototype.objName=function(){ //一样的放在原型里
                alert("我的名字是" + this.name);                
            }
        CreatePerson.prototype.objQQ=function(){   //原型
            alert("我的qq是" + this.qq);
        }
                    
        var obj=new CreatePerson("wy","749996714"); 
        var obj2=new CreatePerson("hk","12345678") 
            
            obj.objName();
            obj2.objName();  

 json 方式的面向对象：整个程序只有一个，写起来比较简单，不适合多个对象

var json={
            a:1,
            b:2,
            c:function()
　　　　　　　{
                alert("c")
            }
            
        }
        //alert(json.a);
        json.c();

 总结：用构造函数加属性，用原型加方法。(区别于工厂方式，这种方式叫做混合的构造函数/原型方式，简称混合方式构造对象；)