面向对象

一，什么是面向对象？

凡是定义问题，一句话就可以解决，但是要深刻理解其内涵，确实不是一句话就能解决的，在说面向对象之前先说一下对象。 

1.什么是对象？

万物皆对象，这确实是简单明了的解释，但是当面试官问我们什么是对象时，千万不能脱口而出：万物皆对象！

具有特定属性和方法的物质叫做对象。

2.什么是面向对象？

面向对象是一种编程思想。

3.面向对象和面向过程的区别：

面向对象体现的是一种生活逻辑；

面向过程体现的是一种数学逻辑。

二、面向对象的创建方式：

1.字面量的创建方式：

<script>
    //字面量创建方式：
    var obj = {};
    var obj = new Object();
</script>

<script>
    //创建一个对象：
    var person = {
        name:"lily",
        age:18,
        sex:'gril'
    }
    var person1 = {
        name:"tom",
        age:12,
        sex:'boy'
    }
    var person2 = {
        name:"rose",
        age:11,
        sex:'gril'
    }
    console.log(person.name,person1.name,person2.name);
</script>

缺点：代码重复书写，代码冗杂；

解决方法：工厂模式创建对象。

2.工厂模式创建对象：

工厂模式就是批量生产

<script>
   //工厂模式：
   //创建一个工厂：
   function personinfo(name,age,sex){
       //备料：创建一个对象：
       var obj = new Object();
       //加工：为对象添加方法和属性；
       //添加属性：
        obj.name = name,
        obj.age = age,
        obj.sex = sex  
        //添加方法:
        obj.running = function(){
            return name + "eating";
        } 
        //出厂：返回对象；
        return obj;
   }
  var person1 =  personinfo('lily',19,'gril');
  var person2 =  personinfo('tom',19,'boy');
  console.log(person1.name,person2.name,person1.running());
</script>

优点：解决代码冗杂问题。

<script>
   //工厂模式：
   //创建一个工厂：
   function personinfo(name,age,sex){
       //备料：创建一个对象：
       var obj = new Object();
       //加工：为对象添加方法和属性；
       //添加属性：
        obj.name = name,
        obj.age = age,
        obj.sex = sex  
        //添加方法:
        obj.running = function(){
            return name + "eating";
        } 
        //出厂：返回对象；
        return obj;
   }
  var person1 =  personinfo('lily',19,'gril');
  var person2 =  personinfo('tom',19,'boy');
  console.log(person1.name,person2.name,person1.running());
    //创建一个工厂：
    function animalinfo(name,color){
       //备料：创建一个对象：
       var obj = new Object();
       //加工：为对象添加方法和属性；
       //添加属性：
        obj.name = name,
        obj.color = color
        //添加方法:
        obj.running = function(){
            return name + "eating";
        } 
        //出厂：返回对象；
        return obj;
   }
  var a1 = animalinfo('xiaobai','white');
  var a2 = animalinfo('xiaohei','black');
  console.log(a1.name,a2.name,a1.running());
  //判断对象是否属于某一类：（不能明确判断）
  console.log(person1 instanceof Object);//true
  console.log(a1 instanceof Object); //true
</script>

缺点：不能确定某个对象属于哪个类；

          对象是通过函数调用的方式创建的，创建方式不规范。

3.构造函数：

注：大驼峰命名法；

       是new出来的对象；

       this指向是new出来的对象。

<script>
   //创建构造函数：
   function Person(name,age){
       //实例属性：
       this.name = name,
       this.age = age
       //实例方法：
       this.running = function(){
           return "sleep";
       }
   }
   var person1 = new Person('lily',19);
   var person2 = new Person('tom',20);
   console.log(person1.name,person2.age,person1.running());
</script>

优点：解决工厂模式创建方式不规范问题以及不能明确判断某一对象属于哪一类的问题。

<script>
   //创建构造函数：
   function Person(name,age){
       //实例属性：
       this.name = name,
       this.age = age
       //实例方法：
       this.running = function(){
           return "sleep";
       }
   }
   var person1 = new Person('lily',19);
   var person2 = new Person('tom',20);
   console.log(person1.name,person2.age,person1.running());
   console.log(person1.running,person2.running);
   //输出结果：
    //    ƒ (){
    //            return "sleep";
    //        } ƒ (){
    //            return "sleep";
    //        }
    console.log(person1.running==person2.running);//false  可见空间不共用
      //创建构造函数：
      function Animal(name,age){
       //实例属性：
       this.name = name,
       this.age = age
       //实例方法：
       this.running = function(){
           return "eat";
       }
   }
   var a1 = new Animal('xioabai',2);
   var a2 = new Animal('xiaohei',3);
   console.log(a1.name,a2.age,a1.running());
//判断对象是否属于某一类：(可以明确判断)
console.log(person1 instanceof Person);//true
console.log(a1 instanceof Person); //false
</script>

从以上代码中可以看出，构造函数也有缺点：

多个同类对象的方法会被重复创建，空间不共享。

4.构造函数（使用原型属性和方法）：

<script>
    //创建一个构造函数：
    function Animal(){

    }
    //原型属性：
    Animal.prototype.name = "lily";
    Animal.prototype.age = 2;
    //原型方法：
    Animal.prototype.running = function(){
            return "watch television";
        }

    var a1 = new Animal();
    var a2 = new Animal();
    console.log(a1.name,a2.age,a2.running());
    console.log(a1.running,a2.running);
    // ƒ (){
    //     return "watch television";
    //     } ƒ (){
    //         return "watch television";
    //     }
    console.log(a1.running==a2.running);//true（空间共享） 
</script>

从代码中可以看出：使用原型属性和方法可以解决空间不共享的问题，但同时产生了原型属性是固定不变的缺点。

5.混合模式：

 构造函数（实例属性+原型方法）

<script>
    function Animal(name,color){
        //实例属性：
        this.name = name,
        this.color = color
    }
    //原型方法：
    Animal.prototype.running = function(){
        return 'eat'
    }
    var a1 = new Animal('niuniu','white');
    var a2= new Animal('maomao','black');
    console.log(a1.name,a1.running(),a2.color);
</script>