面向对象编程

什么是对象

1、万物皆对象。
2、对象是单个事物的抽象
3、对象相当于一个容器，封装了属性（property）和方法（method）

• 属性：对象的状态
• 方法：对象的行为

什么是面向对象？

面向对象编程，简称OOP，是一种编程开发思想。
可以将真实世界各种复杂的关系，抽象为一个个对象，然后由对象之间的分工与合作对真实世界的模拟。

面向对象与面向过程对比

• 面向过程就是亲力亲为，事无巨细，面面俱到，步步紧跟，有条不紊；
• 面向对象就是找一个对象，指挥得到结果；
• 面向对象是将执行者转换为指挥者；
• 面向对象不是面向过程的替代，而是面向过程的封装。

可以通 过以下例子来区分面向过程和面向对象：

// 面向过程
    // 定义学生对象
    var stu1 = {name:"占山",score:95};
    var stu2 = {name:"里斯",score:85};
    // 封装一个打印学生姓名和成绩的函数
    function printscore(student){
      console.log("姓名是：" + student.name + "成绩：" + student.score);
    }
    // 调用函数并打印数据
    printscore(stu1);
    printscore(stu2);
// 面向对象
    // 抽象所有的数据行为生成模板
    function studentScroe(name,score){
      //实例成员，创建时，直接添加给函数内部的this
      this.name = name;
      this.score = score;
      this.printScore = function(){
        console.log("姓名是：" + this.name + "成绩是：" + this.score);
      }
    }
    // 根据模板创建具体实例对象（Instance）
    var stu1 = new studentScroe("占山",52);
    var stu2 = new studentScroe("里斯",89);
    // 调用实例对象自己的方法
    stu1.printScore();
    stu2.printScore();

面向对象的特性

• 封装性
• 继承性

• 【多态性】抽象

  面向对象的设计思想

• 抽象出Class（构造函数）

• 根据Class（构造函数）创建Instance（实例）

• 指挥Instance得出结果

  创建对象的几种方式

• new Object() 构造函数

• 对象字面量
• 工厂函数
• 自定义构造函数

不太清楚的可以参考下面的链接复习一下：
Iknnm：Js对象

构造函数和实例对象的关系

构造函数会根据具体的事物抽象出来的抽象模板
实例对象是根据抽象的构造函数模板得到具体实例对象

静态成员和实例成员

我们在使用构造函数方法创建对象时，可以给构造函数和创建的实例对象添加属性和方法，而这些属性和方法都叫做成员。
实例成员：在构造函数内部添加给this的成员，属于实例对象成员，在创建实例对象后必须由对象调用。
静态成员：添加给构造函数自身的成员，只能使用构造函数进行调用，不能使用生成的实例对象调用。

function Person(name,age){
  // 实例成员，通过将来生成的实例对象进行调用的成员
  // 创建时，是直接添加给函数内部的this
  this.name = name;
  this.age = age;
  this.sayName = function(){
    console.log(this.name);
  }
}
// 静态成员--直接给构造函数添加的成员
Person.version = "1.0";
//生成对象实例
var p1 = new Person("Bob",23);
var p2 = new Person("Mike",19);
// 调用实例成员
console.log(p1.name);
// 调用静态成员，只能通过构造函数进行调用
console.log(Person.version);

构造函数存在问题的解决方法

1、在构造函数中，直接定义函数，内存浪费的问题

// 自定义构造函数
        function Person(name,age){
            this.name = name;
            this.age = age;
            // 每个对象的sayName方法是一一样的
            this.sayName = function(){
                console.log(this.name);
            }
        }
        // 生成对象实例
        var p1 = new Person("张三",23);
        var p2 = new Person("里斯",18);
        // 判断各自的方法是否是同一个函数
        console.log(p1.sayName == p2.sayName); //false

处理方法一：可以将自定义构造函数内部的sayName方法单独放到一个函数里。

// 解决方法一：提取公共函数
        function sayName(){
                console.log(this.name);
        }
         // 自定义构造函数
         function Person(name,age){
            this.name = name;
            this.age = age;
            // 每个对象的sayName方法是一一样的
            this.sayName = sayName;
        }
        // 生成对象实例
        var p1 = new Person("张三",23);
        var p2 = new Person("里斯",18);
        // 判断各自的方法是否是同一个函数
        console.log(p1.sayName == p2.sayName); //true

处理方法二：如果存在多个函数，可能会导致命名重复，就可以将函数放到一个对象中

// 解决方法二：如果存在多个函数，可能会导致命名重复，就可以将函数放到一个对象中
        var fun = {
            sayName : function(){
                console.log(this.name);
            },
            sayAge : function(){
                console.log(this.age);
            }
        }
         // 自定义构造函数
         function Person(name,age){
            this.name = name;
            this.age = age;
            // 每个对象的sayName方法是一一样的
            this.sayName = fun.sayName;
            this.sayName = fun.sayAge;
        }
        // 生成对象实例
        var p1 = new Person("张三",23);
        var p2 = new Person("里斯",18);
        // 判断各自的方法是否是同一个函数
        console.log(p1.sayName == p2.sayName); //true
        console.log(p1.sayAge == p2.sayAge); //true

处理方法三、使用原型对象创建sayAge

// 自定义构造函数
        function Person(name,age){
            this.name = name;
            this.age= age;
            // 使用原型对象创建sayAge
            // Person.prototype 得到的就是一个原型对象
            Person.prototype.sayAge = function(){
                console.log(this.name);
            }
        }
        //定义实例对象
        var p1 = new Person("张三",26);
        var p2 = new Person("张三",26);
        // 打印
        p1.sayAge();//张三
        console.log(p1.sayAge == p2.sayAge);//true

总结：

面向对象编程具有灵活性、代码可复用性、高度模块化等特点，容易维护维护和开发。适合于多人合作的大型软件项目。