面向对象（Object Oriented Programming）

js之面向对象的程序设计

认识面向过程（POP）

面向过程就是分析出解决问题需要的步骤，用步骤来实现，举个栗子：把大象放进冰箱需要三步。就是我们已经分析好了步骤，按照步骤来解决问题。

面向对象（Object Oriented Programming）

面向对象就是把事物分解成为对象，然后由对象之间进行合作和分工。找出对象写出对象的功能。
举个栗子：①对象：大象；功能：进去
②对象：冰箱；功能：打开关闭；
即oop是以对象功能的划分来解决问题的。

特点

• 封装性
• 继承性
• 多态性
• 容易维护，复用，扩展，性能比面向过程低

思维特点

• 抽取对象共用的属性和行为来封装成一个类（模板）；（手机）
• 对类进行实例化，获取类的对象；（华为）

对象

在js中，对象是一组无序的相关属性的方法和集合，所有的事物都是对象，例如字符串，数值，数组，函数等等；

• 属性：对象的特征
• 方法：对象的行为

class

类抽象了对象的公共部分，它泛指某一大类，对象特指某一个，通过类实例化一个具体的对象

①面向对象的思维特点

• 抽取对象共用的属性和行为组织封装成一个类（模板）；
• 对象进行实例化，获取类的对象

class Star{
  constructor(uname){
       this.uname=uname;
       this.age=age;
       }
 }

var xnn=new.Star('小楠楠',18);
console.log(xnn.uame);

当我用new创建了这个实例之后，自动调用了constructor，函数就会执行，’小楠楠‘就会传递给uname，再传递给this.name就是说创建的这个实例已经具有uname的属性了。

注意点

• 关于class，习惯性定义首字母大写；
• 类中有constructor函数，可以接受传递过来的参数，同时返回实例对象；它也会返回。
• constructor函数只要new生成实例的时候就会自动调用这个函数
• new不能省略，生成实例；
• 注意语法，类后面加{}，实例后面加（），构造函数不需要加function

②在类中添加方法

class Star{
  constructor(uname){
       this.uname=uname;
       this.age=age;
       }
       sing（song）{
           console.log（“我唱歌”）；
           console.log(this.uname+song);
 }

var xnn=new.Star('小楠楠',18);
console.log(xnn.uame);
xnn.sing('我和我的祖国’)；

注意

• ①类中所有的函数都不需要写function；
• ②多个函数之间不需要加逗号分隔；
• ③方法也可以传递参数；

③类的继承

①父慈子孝继承财产

class Father{
     constructor(){
     }
     money(){
     soncle.log(100);
     }
}
class Son extends Father{
}
var son=new Son();
son.money();//100

用extends就可以教程父类的属性和方法

②父慈子孝教你做加法

class Father{
    constructor(x,y){
         this.x=x;
         this.y=y;
     }
     sum(){
           console.log(this.x+this.y);
           }
     }
class Son extends Father{
      constructor(x,y){
          super(x,y);//这里调用了父类中的构造函数
          }
}
var son=new Son(1,2);
son.sum();

先new实例化了，把（1，2）传递给子类中的constructor，接着再执行了super，super把（1，2）传给父类中的constructor，而父类中的方法就可以使用这两个数据了。
关键字super可以调用父类中的constructor
除了调用构造函数，也可以调用普通函数

③我永远是你爸爸，带孝子也要自省

class Father{
    say(){
         return'我是你爸爸‘；
         }
     }
 class Son extends Father{
     say（）{
           console.log（’我是儿子‘）；
           }
      }
var son =new Son();
son.say();//我是儿子

注意：

• 继承中，如果实例化子类输出一个方法，先看子类有没有这个方法，如果有就执行子类的，简称“就近原则”
• 继承中，如果子类里面没有，就去查找父亲有没有这个方法，如果有，再执行父亲的。
• 继承中的属性方法查找原则：就近。

super也可调用父类普通函数

class Son extends Father{
     say（）{
           console.log（’不可能‘+super.say()）；
           }
      }
var son=new Son();
son.say();//不可能我是你爸爸（这里就是调用了父类的普通函数）

④带孝子可以创新，但应该先继承

要永远把父亲放在第一位

class Father{
     constructor(x,y){
         this.x=x;
         this.y=y;
     }
     sum(){
           console.log(this.x+this.y);
           }
     }
//子类继承父亲的加法同时扩展减法
class Son extends Father{
      constructor(x,y);
      //**利用super调用父类的构造函数，但super必须在this之前调用**
      super(x,y)；
      this.x=x;
      this.y=y;
   }
   subtract(){
       console.log（this.x-this.y);
       }
    }
    var son=new Son(5,3);
    son.subtract();
    son.sum();

使用类注意事项

class Star{
    this.uname=uname;
    this.age=age；
    this.sing();//这里的this不能省略
    }
    sing(){
        console.log(this.uname);//这里的this不能省略
        }
    }
    var xnn=new Star('小楠楠’）；

``

注意事项

• ①莫得变量提升，所以必须先定义类，才能通过类实例化对象
• ②类里面的共有的属性和方法****一定要加this使用

##关于this里面的指向

  class Star{
     constructor(uname,age){//constructor里面的this指向的是创建实例的对象
      this.uname=uname;
      this.age=age；
      this.sing();
      }
      sing(){
          console.log(this.uname);
          }
      dance(){
          console.log(this);
          }
             
      }
      var xnn=new Star('小楠楠’）；
      xnn.dance();//这里是xnn调用了函数，this就是指向xnn
      

还有一种方法，先定义一个全局变量，在constructor里面把this保存在这个全局变量里面，这样在任何一个地方都可以使用全局变量