1. 面向对象Object-Oriented(O O) ——

在编程里面所谓面向是指以什么什么为主的，而不是字面意思，那么面向对象就是以对象为主要应用体的意思。

所谓面向对象它不是一个概念，全世界有多少个程序员，就可以给出多少个概念，面向对象其实是一个经验总结的编程模式。

1. JavaScript面向对象编程术语：

(1) 命名空间Namespace： JS 中命名空间只是另一个包含方法，属性，对象的对象.

     1.  全局命名空间： 一个全局对象被创建，所有的变量，方法和功能成为该对象的属性。使用命名空间也最大程度地减少应用程序的名称冲突的可能性。
     
         var MYAPP = MTAPP || {} //如果全局对象MTYAPP是真值，则返回这个值，否则新建一个空对象，这是兜底写法
     
     2.  子命名空间：MYAPP.event = {}

(2) 类Class: 定义对象的特征。它是对象的属性和方法的模板.

(3) 对象Object: 类的一个实例.

(4) 属性Property: 对象的特征，比如颜色.

(5) 方法Method: 对象的能力，比如行走.

(6) 构造函数Constructor: 对象初始化的瞬间, 被调用的方法. 通常它的名字与包含它的类一致.

(7) 继承 Inheritance: 一个类可以继承另一个类的特征

(7) 封装Encapsulation: 一种把数据和相关的方法绑定在一起使用的方法.

(8) 抽象Abstract: 结合复杂的继承，方法，属性的对象能够模拟现实的模型.

(9) 多态Polymorphism: 多意为‘许多’，态意为‘形态’。不同类可以定义相同的方法或属性.

2. JavaScript面向对象实例：这是站在跨文件的角度总结的代码优化方式

   ! function () {

        var view = View('section.message') 

        var model = Model({
            resourceName: 'leaveMessage'
        })

        var controller = Controller({
            init: function (view, controller) {
                this.messageList = view.querySelector('#messageList')
                this.form = view.querySelector('form')
                this.loadmessages()
            },
            loadmessages: function () {
                this.model.fetch()
                    .then((messages) => {
                        let array = messages.map((item) => item.attributes)
                        array.forEach((item) => {
                            let li = document.createElement('li')
                            li.innerText = `${item.name} : ${item.content}`
                            this.messageList.appendChild(li)
                        })
                    })
            },
            bindEvents: function () {
                //把留言功能存到leanCloud数据库

                this.form.addEventListener('submit', (e) => { //监听form表单的submit事件
                    e.preventDefault() //防止form表单自动刷新页面
                    this.saveMessage()
                })
            },
            saveMessage: function () {
                let myForm = this.form
                let content = myForm.querySelector('input[name=content]').value //拿到用户输入的内容
                let name = myForm.querySelector('input[name=name]').value //拿到用户的名字
                this.model.save({
                        'name': name,
                        'content': content
                    })
                    .then(function (object) {
                        let li = document.createElement('li')
                        li.innerText = `${object.attributes.name} : ${object.attributes.content}`
                        let messageList = document.querySelector('#messageList')
                        messageList.appendChild(li)
                        myForm.querySelector('input[name=content]').value = ''
                        myForm.querySelector('input[name=name]').value = ''
                        console.log(object)
                    })
            }
        })
        controller.init(view, model)
    }.call()

—————————————————————————————————————————————————————————

2. new的语法：

1. 面向对象里面new关键字有两个作用：

在函数里面创建私有属性
在函数外面创建原型（prototype共有属性），并在函数里面指向这个原型(this. __ proto__ = 函数.prototype)。

2. 面向对象举例：

（1）、不用new关键字

一个js文件里写一下代码：

    //游戏里面创建100个常规士兵
    //每一个士兵私有属性：id不同、生命值不同
    //每一个士兵共有属性：都会行走、奔跑、死亡、攻击、防御、攻击力一样、都是美国步兵
    
    function create士兵(id){
        var temp = {}
        temp.__proto__ = 士兵原型
        this. __proto__ = create士兵.rototype
        this.ID = id,
        this.生命值 = 42
        return temp
    }
     
    create士兵.原型 = {
    
         constructor:士兵
        
        行走：function(){/*走两步的代码*/}，
        奔跑：function(){/*狂奔的代码*/}，
        死亡：function(){/*GO DIE*/}，
        防御：function(){/*护脸*/},
        攻击：function(){/*attack*/}
        国家：function(){/*美国*/}
    }

在另一个文件里写调用上面代码的函数：

var 士兵们 = []
for(i=0;i<100;i++){
    士兵们.push(create士兵们(i))
}

（2）、使用new关键字

一个js文件里写一下代码：

    //游戏里面创建100个常规士兵
    //每一个士兵私有属性：id不同、生命值不同
    //每一个士兵共有属性：都会行走、奔跑、死亡、攻击、防御、攻击力一样、都是美国步兵
    
    function create士兵(id){
        （ create士兵.prototye = {constructor:士兵}  //不能这样写，会被下面的prototype覆盖掉）
        this.ID = id,
        this.生命值 = 42
    }
     
    create士兵.prototye = {
    
        //避免引用的prototype覆盖默认prototype里的constructor属性的第一种方法：
        constructor:士兵
        //避免引用的prototype覆盖默认prototype里的constructor属性的第二种方法：
       create士兵.prototype.国家 = '美国'
       create士兵.prototype.攻击 = '打他'
    
         constructor:士兵
        行走：function(){/*走两步的代码*/}，
        奔跑：function(){/*狂奔的代码*/}，
        死亡：function(){/*GO DIE*/}，
        防御：function(){/*护脸*/},
        攻击：function(){/*attack*/}
        国家：function(){/*美国*/}
    }

在另一个文件里写调用上面代码的函数：

var 士兵们 = []
for(i=0;i<100;i++){
    士兵们.push(new create士兵(i))
}

（3）new关键字总结

1.new 的作用

使用了new关键字之后代码中简化了以下（使用new关键字之后会自动省略以下内容）

 （1）、var temp = {}
    
 （2）、temp.__proto__ = 士兵原型

 （3）、this. __proto__ = create士兵.rototype

 （4）、return temp
 
 （5）、 不用写原型（函数名），因为new会默认声明函数名叫prototype

2.new 的约定：

由于new关键字后面的函数是用来创建对象的，所以不必要写士兵前面的create，，只要使用了new，就可以把士兵前面的全部create给去掉

一个js文件里写一下代码：

    //游戏里面创建100个常规士兵
    //每一个士兵私有属性：id不同、生命值不同
    //每一个士兵共有属性：都会行走、奔跑、死亡、攻击、防御、攻击力一样、都是美国步兵
    
    function 士兵(id){
        this.ID = id,
        this.生命值 = 42
    }
     
    士兵.prototye = {
        constructor:士兵
        行走：function(){/*走两步的代码*/}，
        奔跑：function(){/*狂奔的代码*/}，
        死亡：function(){/*GO DIE*/}，
        防御：function(){/*护脸*/},
        攻击：function(){/*attack*/}
        国家：function(){/*美国*/}
    }

在另一个文件里写调用上面代码的函数：

    var 士兵们 = []
    for(i=0;i<100;i++){
        士兵们.push(new 士兵(i))
    }

3. new 的常见用法解释：

    var object = new Object()

在这里new起了两个作用：

（1）、 new会给object添加自有属性（这里添加了空对象）

（2）、 object. __ proto__ === Object.prototype

JavaScript 【面向对象编程】