面向对象的编程思想

面向对象编程思想:根据需求,分析对象,找到对象有什么特征和行为,通过代码的方式来实现需求,要想实现这个需求,就要创建对象,要想创建对象,就应该先有构造函数,然后通过构造函数来创建对象,通过对象调用属性和方法来实现相应的功能及需求,即可。

首先JS不是一门面向对象的语言,JS是一门基于对象的语言,那么为什么学习js还要学习面向对象,因为面向对象的思想适合于人的想法,编程起来会更加的方便,及后期的维护....

面向对象的编程语言中有类(class)的概念(也是一种特殊的数据类型),但是JS不是面向对象的语言,所以,JS中没有类(class),但是JS可以模拟面向对象的思想编程,JS中会通过构造函数来模拟类的概念(class)。

 

eg：小明,小红，小丽，小白，小花 都是人

      * 共同的特征和行为

      * 特征--->属性

      * 行为---方法

 

面向对象的特性:封装,继承,多态

 

封装

封装:就是包装

    * 一个值存储在一个变量中--封装

    * 一段重复代码放在一个函数中--封装

    * 一系列的属性放在一个对象中--封装

    * 一些功能类似的函数(方法)放在一个对象中--封装

    * 好多相类似的对象放在一个js文件中---封装

继承

首先继承是一种关系,类(class)与类之间的关系,JS中没有类,但是可以通过构造函数模拟类,然后通过原型来实现继承，继承也是为了数据共享,js中的继承也是为了实现数据共享。

原型作用之一:数据共享,节省内存空间。

原型作用之二:为了实现继承。

例子:

    ①* 小杨--->人, 姓名, 有钱, 帅, 有功夫--降龙十八掌

    * 小杨的儿子-->人,

    * 继承:

    * 姓氏----继承

    * 外表----继承

    * 财产----继承

    * 功夫---继承

    ②人:  姓名, 性别, 年龄 ,吃饭, 睡觉

    * 学生类别: 姓名, 性别, 年龄 ,吃饭, 睡觉 学习行为

    * 老师类别: 姓名, 性别, 年龄 ,吃饭, 睡觉 工资,教学行为

    * 程序员: 姓名, 性别, 年龄 ,吃饭, 睡觉 工资, 敲代码

    * 司机类别: 姓名, 性别, 年龄 ,吃饭, 睡觉 工资 开车

多态

一个对象有不同的行为,或者是同一个行为针对不同的对象,产生不同的结果,要想有多态,就要先有继承,js中可以模拟多态,但是不会去使用,也不会模拟。

继承的实现

       function Person(name,age,sex,weight) {
         this.name=name;
         this.age=age;
         this.sex=sex;
         this.weight=weight;
       }
       Person.prototype.sayHi=function () {
         console.log("您好");
       };
       function Student(score) {
         this.score=score;
       }
       //希望人的类别中的数据可以共享给学生---继承
       Student.prototype=new Person("小明",10,"男","50kg");
    
       var stu1=new Student("100");
       console.log(stu1.name,stu1.age,stu1.sex,stu1.weight,stu1.score);
       stu1.sayHi();
    
       var stu2=new Student("120");
       stu2.name="张三";
       stu2.age=20;
       stu2.sex="女";
       console.log(stu2.name,stu2.age,stu2.sex,stu2.weight,stu2.score);
       stu2.sayHi();
       var stu3=new Student("130");
       console.log(stu3.name,stu3.age,stu3.sex,stu3.weight,stu3.score);
       stu3.sayHi();

问题：

为了数据共享,改变原型指向,做到了继承---通过改变原型指向实现的继承。

缺陷:因为改变原型指向的同时实现继承,直接初始化了属性，继承过来的属性的值都是一样的了,所以,这就是问题。

只能重新调用对象的属性进行重新赋值。

 

解决方案：

借用构造函数:构造函数名字.call(当前对象,属性,属性,属性....);  ====》当前对象借用构造函数，并传递需要的实参。

function Person(name, age, sex, weight) {
      this.name = name;
      this.age = age;
      this.sex = sex;
      this.weight = weight;
    }
    Person.prototype.sayHi = function () {
      console.log("您好");
    };
    function Student(name, age, sex, weight, score) {
      //借用构造函数
      Person.call(this, name, age, sex, weight);
      this.score = score;
    }
    var stu1 = new Student("小明", 10, "男", "10kg", "100");
    console.log(stu1.name, stu1.age, stu1.sex, stu1.weight, stu1.score);

    var stu2 = new Student("小红", 20, "女", "20kg", "120");
    console.log(stu2.name, stu2.age, stu2.sex, stu2.weight, stu2.score);

    var stu3 = new Student("小丽", 30, "妖", "30kg", "130");
    console.log(stu3.name, stu3.age, stu3.sex, stu3.weight, stu3.score);
　　 stu3.sayHi();

解决了属性继承,并且值不重复的问题，缺陷:父级类别中的方法不能继承。

解决方案：

组合继承：原型继承（继承方法）+借用构造函数继承（解决重复值）

function Person(name,age,sex) {
      this.name=name;
      this.age=age;
      this.sex=sex;
    }
    Person.prototype.sayHi=function () {
      console.log("阿涅哈斯诶呦");
    };
    function Student(name,age,sex,score) {
      //借用构造函数:属性值重复的问题
      Person.call(this,name,age,sex);
      this.score=score;
    }
    //改变原型指向----继承
    Student.prototype=new Person();//不传值
    Student.prototype.eat=function () {
      console.log("吃东西");
    };
    var stu=new Student("小黑",20,"男","100分");
    console.log(stu.name,stu.age,stu.sex,stu.score);
    stu.sayHi();
    stu.eat();
    var stu2=new Student("小黑黑",200,"男人","1010分");
    console.log(stu2.name,stu2.age,stu2.sex,stu2.score);
    stu2.sayHi();
    stu2.eat();

    //属性和方法都被继承了

 

拷贝继承

   var obj1={
     name:"小糊涂",
     age:20,
     sleep:function () {
      console.log("睡觉了");
     }
   };

   //改变了地址的指向
   var obj2=obj1;
   console.log(obj2.name,obj2.age);
   obj2.sleep();

以上代码obj1和obj2指向堆中同一块内存。

   var obj1={
     name:"小糊涂",
     age:20,
     sleep:function () {
       console.log("睡觉了");
     }
   };


   var obj2={};
   for(var key in obj1){
     obj2[key]=obj1[key];
   }
   console.log(obj2.name);

以上代码obj1和obj2指向堆中各自的内存。

function Person() {}
    Person.prototype.age=10;
    Person.prototype.sex="男";
    Person.prototype.height=100;
    Person.prototype.play=function () {
      console.log("玩的好开心");
    };
    var obj2={};
    //Person的构造中有原型prototype,prototype就是一个对象,那么里面age,sex,height,play都是该对象中的属性或者方法
    for(var key in Person.prototype){
      obj2[key]=Person.prototype[key];
    }
    console.dir(obj2);
    obj2.play();

 继承总结

面向对象特性:封装,继承,多态

继承：类与类之间的关系,面向对象的语言的继承是为了多态服务的,

　　   js不是面向对象的语言,但是可以模拟面向对象，模拟继承，目的是为了节省内存空间

 

原型作用一: 数据共享     目的是:为了节省内存空间

原型作用二: 继承            目的是:为了节省内存空间

继承实现的方式：

    * 原型继承:改变原型的指向

    * 借用构造函数继承:主要解决属性的问题

    * 组合继承:原型继承+借用构造函数继承=======》既能解决属性问题,又能解决方法问题

    * 拷贝继承:就是把对象中需要共享的属性或者方法,通过直接遍历的方式复制到另一个对象中