面向对象编程特点、js实现面向对象(封装、继承、多态)、重载（不属于面向对象）

[TieMuZhen]

一、面向过程和面向对象的区别

（1）面向过程：面向过程编程就是分析出解决问题的步骤，然后把这些步骤一步一步的实现，使用的时候一个一个的依次调用就可以了。
（2）面向对象：面向对象编程就是把问题分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

二、面向过程和面向对象的优缺点

• 面向过程语言

优点： 性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点： 没有面向对象易维护、易复用、易扩展

• 面向对象语言：

优点： 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点： 性能比面向过程低

三、例子

网上有一个典型的例子：把大象放入冰箱里面。

C++是这么做的：涉及到两个对象：冰箱和大象。三个动作：打开冰箱，放置大象，关闭冰箱。

首先定义一个冰箱类，他有打开的方法，放置的方法，关闭的方法。然后再定义一个大象类。接下来构建冰箱和大象的对象，然后冰箱对象调用打开门的方法，冰箱对象再调用放置大象对象的方法，最后冰箱对象关门。

伪代码如下

// 大象类
class Elephant  {} 

//冰箱类有三个方法
class Fridge{ 
    open()；
    lay()；
    close()；
}

function main(){
    Elephant   elephant;//构建一个大象对象
    Fridge  fridge;//构造一个冰箱对象
    fridge.open();
    fridge.lay(elephant);
    fridge.close();
}

而当C是这么做的：首先打开冰箱门，然后把大象放入进去，最后关闭冰箱门。

function main(){
    open()；
    lay(elephant)；
    close()；
}

四、js实现面向对象(封装、继承、多态)、重载（不属于面向对象）

1、封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。

ES6之前 没有类的概念，封装定义类相当于定义函数，写法如下：

function Person (name,age,sex){
    this.name = name;
    this.age = age;
    this.sex = sex;
}
Pserson.prototype = {
    constructor:Person,
    sayHello:function(){
        console.log('hello');
    }
}

ES6中引入 class（类）这个概念，写法如下：

//定义类
class Person{
  // 类的静态方法,相当于Person.test = function(){console.log("类的静态方法");}
  static test() {
    console.log("类的静态方法");
  }
  //constructor构造函数
  constructor(name,age){
    console.log("调用构造函数");
    this.name = name;
    this.age = age;
  }
  //类的一般方法,定义在实例对象的原型对象上,相当于Person.prototype.show = function(){console.log("this.name,this.age");}
  show(){
    console.log(this.name,this.age);
  }
}

2、继承

提高代码复用性；继承是多态的前提。

详情请看实现继承的七种方式

3、多态

多态首先是建立在继承的基础上的，先有继承才能有多态。
多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。

JS中ES6之前多态用法如下：

var makeSound = function(animal) {
    animal.sound();
}

var Duck = function(){}
Duck.prototype.sound = function() {
    console.log('duck')
}

var Chicken = function() {};
Chicken.prototype.sound = function() {
    console.log('chicken')
}
makeSound(new Chicken());
makeSound(new Duck());

ES6中多态写法如下：

class Animal{
    eat(){
        throw '"' + this.constructor.name + "'类没有eat()方法";
    }
}

class Snake extends Animal{}

class Dog extends Animal{
    eat(){
        console.log("dog eat");
    }
}

class Cat extends Animal{
    eat(){
        console.log("cat eat");
    }
}
var makeEat=function(animal){
    animal.eat();
}

makeEat(new Snake());
makeEat(new Dog());
makeEat(new Cat());

4、重载（不属于面向对象）

重载是函数名相同，函数的参数列表不同(包括参数个数和参数类型)，根据参数的不同去执行不同的操作。

js通过arguments 对象来实现重载

function overload () {
  if (arguments.length === 1) {
    console.log('一个参数')
  }
  if (arguments.length === 2) {
    console.log('两个参数')
  }
}

overload(1);      //一个参数
overload(1, 2);  //两个参数