面向对象（一）

构造对象---混合法

1.面向对象的三个特点：
封装，继承，多态（抽象）

2.对象的组成：
属性---变量：状态，静态的

    var c = 12;//变量：是自由自在的；
    arr.c = 3;//而属性:是属于一个对象的。

方法---函数：过程，动态的：

    function show() {//函数，谁都不属于，自由自在
        console.log("函数");
    }

    arr.fn = function () {//方法：因为他属于一个对象
        console.log("方法");
    }    

3.this

this:是当前的方法属于谁，（全局函数是window的方法）

    function show() {
        console.log(this);
    }
    show();//window
    // show实际是window上的一个方法。全局的函数，本就是属于window的

 补充，window：全局函数是window的方法：上面的全局函数等价于：

    window.show = function () {
        console.log(this);
    }
    window.show();//window

4.了解工厂方式来构造对象：

工厂方式来构造对象：最简单，最原始。
缺点：1，没有new；2，每个对象都有一套自己的函数，浪费资源；

理解工厂函数：
1，原料；
2，加工；
3，出厂

    function creatPerson2(name,sex) {//构造函数：用来构造一个对象
        var obj = new Object();//第一步，创建空白对象（原料）
        obj.name = name;//第二部，加工
        obj.sex = sex;
        obj.showName = function () {
            console.log(this.name);
        }
        obj.showsex = function () {
            console.log(this.sex);
        }
        return obj;//返回（出厂）
    }
    var p1 = creatPerson2("22","33");//没有new的解决方案；
    var p2 = creatPerson2("55","44");//没有new的解决方案；
    p1.showName();
    p1.showsex();
    p2.showName();
    p2.showsex();
    console.log(p1.showName==p2.showName);//flase,每个对象都有一套自己的函数，浪费资源；
    console.log(p1.showsex==p2.showsex);//flase,每个对象都有一套自己的函数，浪费资源；

5，理解new

创建一个新的对象。

    //一，全局函数是window的一个方法
    function show() {
        console.log(this)
    }
    show()//window
    new show();//show，新创建的一个对象

通过var this=new Object();自动创建，来给函数添加new，解决工厂方式的第一个缺点：

    function creatPerson2(name,sex) {//构造函数：用来构造一个对象
        //假象的系统内部工作流程；
        // var this=new Object();自动创建；
        this.name = name;//第二部，加工
        this.sex = sex;
        this.showName = function () {
            console.log(this.name);
        }
        this.showsex = function () {
            console.log(this.sex);
        }
        //假象的系统内部工作流程；
        //return this;自动返回
    }
    var p1 = new creatPerson2("22","33");//有new了
    var p2 = new creatPerson2("55","44");//有new了
    p1.showName();
    p1.showsex();
    p2.showName();
    p2.showsex();
    console.log(p1.showName==p2.showName);//flase,每个对象都有一套自己的函数，浪费资源；
    console.log(p1.showsex==p2.showsex);//flase,每个对象都有一套自己的函数，浪费资源；

6. prototype(原型)：

原型的重要的功能（应用）：可以扩展系统对象，给一类元素添加方法和属性。ex：

    Array.prototype.sum= function () {
        var result = 0;
        var i = 0;
        for(i = 0;i<this.length;i++){
            result+=this[i];
        }
        return result;
    }

    var arr1 = new Array(1,2,3,4);
    var arr2 = new Array(1,1,1,1);
    console.log(arr1.sum());
    console.log(arr2.sum());
    console.log(arr1.sum == arr2.sum);//true;

理解类和对象：

    var arr = new Array(1,2,3,4);
    //Array ：类  ，不具备实际的功能，只能用来构造对象；
    //arr : 对象  ，真正有功能的，被类给构造出来的；
    Array.prototype.sum = function () {

    }

    //给string添加方法
    String.prototype.trim = function () {
        return this.replace(/^s+|s+$/g,'');//去除头尾的空格
    }
    var str = '  abc  fljf   djlfjdl ljjd  ';
    console.log('('+str.trim()+')');

最后，构造函数-混合法：

    function CreatPerson2(name,sex) {//构造函数：用来构造一个对象
        //假象的系统内部工作流程；
        // var this=new Object();自动创建；
        this.name = name;//第二部，加工
        this.sex = sex;
        //假象的系统内部工作流程；
        //return this;自动返回
    }
    CreatPerson2.prototype.showName = function () {
        console.log(this.name);
    }
    CreatPerson2.prototype.showsex = function () {
        console.log(this.sex);
    }
    var p1 = new CreatPerson2("22","33");//有new了
    var p2 = new CreatPerson2("55","44");//有new了
    p1.showName();
    p1.showsex();
    p2.showName();
    p2.showsex();
    console.log(p1.showName==p2.showName)//true共用函数
    console.log(p1.showsex==p2.showsex);//true,共用函数

总结：

普通函数调用的时候不需要new，而构造函数调用的时候需要用到new
ex ：var p1 = new CreatPerson2("22","33");

1，用混合法来创建对象
---所以，为了区别普通函数和构造函数，我们需要把构造函数的首字母大写；
系统也是这样，比如：new Array, new Date ,  new Function;

---在构造函数里面添加的是属性。在原型里添加方法。ex：

    function CreatPerson2(name,sex) {//构造函数：用来构造一个对象
        //属性
        this.name = name;
        this.sex = sex;
    }
    //方法
    CreatPerson2.prototype.showName = function () {
        console.log(this.name);
    }
    CreatPerson2.prototype.showsex = function () {
        console.log(this.sex);
    }

因为属性在每个对象各不相同，方法是所有对象都一样的。
简言，不同的东西加到构造函数里，相同的东西加到原型里。


原型的优先级

            css             js
class-----改变一类元素的样式---prototype

行间样式---改变一个元素的样式---给一个对象加方法，ex：

    Array.prototype.a = 12;
    var arr = [1,2,3];
    console.log(arr.a);//12，只有原型
    arr.a = 5;
    console.log(arr.a);//5，既有原型，又有行间样式
    //所以给对象本身加属性，优先级最高

    delete arr.a;
    console.log(arr.a)//12