js面向对象的三大特性

一.什么是面向对象

面向对象是一种编程思想 js本身就是基于面向对象构建出来的，而js内有很多内置对象类，比如Promise就是es6
新增的内置类 js中的面型对象，和其他编程语言还是略有不同的 js中的类和实例是基于原型和原型链机制来处理的

二.面向对象的三大特征分别为：封装，继承和多态

1. 封装：低耦合高内聚

我们平时所用的方法和类都是一种封装，当我们在项目开发中，遇到一段功能的代码在好多地方重复使用的时候，我们可以 把他单独封装成一个功能的方法，这样在我们需要使用的地方直接调用就可以了。

优点：封装的优势在于定义只可以在类内部进行对属性的操作，外部无法对这些属性指手画脚，要想修改，也只能通过你定义的封装方法；

2.多态：重载和重写

优点：多态实现了方法的个性化，不同的子类根据具体状况可以实现不同的方法，光有父类定义的方法不够灵活，遇见特殊状况就捉襟见肘了

重载：方法名相同，形参个数或类型不一样(js中不存在真正意义上的重载，js中的重载指的是同一个方法，
根据传参不同，实现出不同的效果)

 eg：
    function sum(x,y,z){
        // arguments
        if(typeof z === "undefined"){
            return;  
        }
    }
    sum(1,2);
    sum(1,2,3)

重写：在类的继承中，子类可以重写父类的中的方法

 eg：
    function sum(a,b){
		return a+b
	}
	console.log(sum)	
	console.log(sum(1,2)) 
	function sum(a,b,c){
		a+b+c
	}
	console.log(sum)
	console.log(sum(1,2,3))

3. 继承 :

子类继承父类中的方法(目的是让子类的实例调取父类中的属性和方法)

优点：继承减少了代码的冗余，省略了很多重复代码，开发者可以从父类底层定义所有子类必须有的属性和方法，以达到耦合的目的；

继承的几种方式：

①原型链继承

父类的实例作为子类的原型

    特点：
		1.非常纯粹的继承关系，实例是子类的实例，也是父类的实例
		2.父类新增原型方法/原型属性，子类都能访问到
		3.简单，易于实现

	缺点：
		1.实例并不是父类的实例，只是子类的实例
		2.只能继承父类的实例属性和方法，不能继承原型属性/方法
		3.无法实现函数复用，每个子类都有父类实例函数的副本，影响性能

function Cat(){ 
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

//　Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.eat('fish'));
console.log(cat.sleep());
console.log(cat instanceof Animal); //true 
console.log(cat instanceof Cat); //true

②构造继承

使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）

特点：
	1.解决了1中，子类实例共享父类引用属性的问题
	2.创建子类实例时，可以向父类传递参数
	3.可以实现多继承（call多个父类对象）

缺点：
	1.实例并不是父类的实例，只是子类的实例
	2.只能继承父类的实例属性和方法，不能继承原型属性/方法
	3.无法实现函数复用，每个子类都有父类实例函数的副本，影响性能

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

③实例继承

为父类实例添加新特性，作为子类实例返回

特点：
	1.不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
缺点：
	1.实例是父类的实例，不是子类的实例
	2.不支持多继承

	function Cat(name){
	  var instance = new Animal();
	  instance.name = name || 'Tom';
	  return instance;
	}

	// Test Code
	var cat = new Cat();
	console.log(cat.name);
	console.log(cat.sleep());
	console.log(cat instanceof Animal); // true
	console.log(cat instanceof Cat); // false

④拷贝继承

	特点：
		1.支持多继承
	缺点：
		1.效率较低，内存占用高（因为要拷贝父类的属性）
		2.无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）

	function Cat(name){
	  var animal = new Animal();
	  for(var p in animal){
	    Cat.prototype[p] = animal[p];
	  }
	  Cat.prototype.name = name || 'Tom';
	}
	// Test Code
	var cat = new Cat();
	console.log(cat.name);
	console.log(cat.sleep());
	console.log(cat instanceof Animal); // false
	console.log(cat instanceof Cat); // true

⑤组合继承

通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用

特点：
	1.弥补了方式2的缺陷，可以继承实例属性/方法，也可以继承原型属性/方法
	2.既是子类的实例，也是父类的实例
	3.不存在引用属性共享问题
	4.可传参
	5.函数可复用
缺点：
	1.调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）

	function Cat(name){
	  Animal.call(this);
	  this.name = name || 'Tom';
	}
	Cat.prototype = new Animal();
	Cat.prototype.constructor = Cat;
	// Test Code
	var cat = new Cat();
	console.log(cat.name);
	console.log(cat.sleep());
	console.log(cat instanceof Animal); // true
	console.log(cat instanceof Cat); // true

⑥寄生组合继承

通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点

特点：
	1.堪称完美
缺点：
	1.实现较为复杂

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
(function(){
  // 创建一个没有实例方法的类
  var Super = function(){};
  Super.prototype = Animal.prototype;
  //将实例作为子类的原型
  Cat.prototype = new Super();
})();
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true