面向对象三大特性：

• 封装
• 继承
• 多态

1.什么是封装：

顾名思义，封:封闭，装：装起来，将具体的实现细节装到一个容器中，并封闭起来，防止容器外部直接访问容器内部的实现细节，仅公开暴露指定的访问路径；生活中的例子：到饭馆吃饭，你只需要跟服务员讲你要吃什么饭菜，服务员就会跟后台厨房的厨师说明一下，等待一段时间后，饭菜就被服务员直接递送到你面前，作为客户的你是不知道也无需知道饭菜的具体做法，后台厨房的厨师及做饭菜的过程就是被封装的细节，而服务员则是公开暴露的访问路径，你只能通过服务员点餐然后获得饭菜，而不能直接去到后台厨房要求厨师如何做饭菜。

让我会心一笑，封装的场景一定会在你脑海里飘过一种熟悉感，js里的闭包就是封装的一种。

2.继承

最适合用的就是 寄生组合继承
何为组合？ 其实就是 构造函数 + 原型继承
先说原型继承吧！ 其实很简单就是:

function animal(size){
    this.size = size;
}

function cat (){
 ...
}
var aniIns = new animal('5米')
cat.prototype = aniIns;
catPiPi = new cat()
catPiPi.size // '5米'   

很简单的继承方式， size继承于父。 但是问题是 你创建的所有的猫的size的值都会一样。为了改变这个问题引入构造函数模式。

function animal(size){
    this.size = size;
}

function cat (size){
  animal.call(this,arguments)
}
var aniIns = new animal('3米')
cat.prototype = aniIns;
catPiPi = new cat('1米');
catYaoRan = new cat('1.5米');
catPiPi.size // '1米' 
catYaoRan.size // '1.5米'

这就是组合方式了，然而其缺点十分明显。 两只猫都有自己的size 同时原型链上也有一个size 就是说多了。我们不想要那个size 但是我们想要animal的原型 那么在组合的基础上 使用寄生模式。

function animal(size){
    this.size = size;
}

function constructorPro(){
    var func = new Function();
    func.prototype = animal.prototype
    return func
}

function cat (size){
  animal.call(this,arguments)
}
var aniIns = new animal('3米')
cat.prototype = constructorPro();
catPiPi = new cat('1米');
catYaoRan = new cat('1.5米');
catPiPi.size // '1米' 
catYaoRan.size // '1.5米'

且原型链上没有cat了。为了让他的constructor正常 还要做一件事 就是 constructor赋值下:

function animal(size){
    this.size = size;
}

function constructorPro(){
    var func = new Function();
    func.prototype = animal.prototype
    func.prototype.constructor = animal  // 这里做了改变，相比较与上面那个。
    return func
}

function cat (size){
  animal.call(this,arguments)
}
var aniIns = new animal('3米')
cat.prototype = constructorPro();
catPiPi = new cat('1米');
catYaoRan = new cat('1.5米');
catPiPi.size // '1米' 
catYaoRan.size // '1.5米'

3.多态：

多态其实是指在 编译的过程中无法确定变量的类型或执行函数最终结果，只有在运行的时候才能确定。（土话 下面给出好点的描述）(方法和变量都有多态)

所谓多态就是指程序中定义的引用变量所指向的具体类型或通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
在java中，最常用的多态是通过，继承、构造、向上转型来实现的。还是拿猫的例子来说吧。

public class animal{
    private float size;
    public void animal(Float size) {
        size = size;
    }
    public void jiao (String type){
        system.out.println(type);
    }
}

public class cat extends animal{
    public void cat(String size){
        size = size;
    }
    public void jiao(){
        system.out.println('喵喵喵')
    }
     public void jiao(String  prefix, String sufix ){
        system.out.println(prefix + '喵喵喵' + sufix)
    }
}

Java多态的分类
1、编译时多态，即方法的重载 （ 多个名字想同的函数 参数不同，） ，从JVM的角度来讲，这是一种静态分派（static dispatch）
2、运行时多态，即方法的重写 ( 运行时父类继承的方法或变量会被重新，每个对象状态都不一样，从字面意思来看也是一种多态。 ) ，从JVM的角度来讲，这是一种动态分派（dynamic dispatch）。

其实在js中多态更加简单：

function animal(size,jiaosheng){
    this.size = size;
    this.jiaosheng = jiaosheng
    this.jiao = function(){
      console.log(this.jiaosheng)
    }
}

function cat (size,jiaosheng){
  animal.call(this,arguments)
}
var aniIns = new animal('3米','lallal')
cat.prototype = aniIns;
catPiPi = new cat('1米','喵喵喵');
catYaoRan = new cat('1.5米'，'喵呜喵呜');
catPiPi.jiao() // '喵喵喵' 
catYaoRan.jiao() // '喵呜喵呜'