Javascript面向对象的语言特性

因为原型存在，我们实现了对象的封装，但是这种封装也同样可能存在问题的。

1、 我们无法像使用构造函数的那样将属性传递用于设置值

2、 当属性中有引用类型， 可能存在变量值的重复

封装：

        //原型--封装
        function Person(){};
        Person.prototype = {
            constructor : Person,
            name : "小明",
            age : 8,
            likes : ["篮球","棒球"],
            say : function(){
                alert("我的名字是"+this.name+"，今年"+this.age+"岁了"+"身高
是"+this.height)
            }
        }
        var p1 = new Person();
        p1.likes.push("足球");
        alert(p1.likes);
        var p2 = new Person();
        alert(p2.likes);
//因为p1和p2对象指向了同一个原型链，
//无法像构造函数一样能够改变任意对象的属性，所以当p1的friends发生变化是p2也跟着变化

为了解决原型所带来的问题，需要通过组合构造函数和原型来实现对象的创建：
属性在构造函数中定义，方法在原型中定义。
这种有效集合了两者的优点，是目前最为常用的一种方式。

    //1.属性在构造函数中定义：
        function Person(name,age,likes){
            this.name = name;
            this.age = age;
            this.likes = likes;
        }
        //由于在创建构造函数过程中，计算机会开拓出内存，供给构造函数，
        //所以此时创建的属性都是保存在自己的内存中；
    //2.方法在原型中定义：   
    Person.prototype = {
        constructor : Person,
        say : function() {
            alert("My name is "+this.name+" , I'm "+this.age+"years old"+" , my favorite are "+this.likes)
        }
    };
    
    
    var p1 = new Person("X",8,["football","basketball"]);
    p1.likes.push("baseball");
    alert(p1.likes);
        
    var p2 = new Person("L",18,["movie","chess"]);
    alert(p2.likes);
    p2.say();

继承

在javascript中实现继承的方式有多种：
1.原型链实现继承；
2.基于伪装实现继承；
3.基于组合方式实现继承。

（1）原型链的继承

子类的原型指向父类的实例

        function Parent(){
            this.src1 = "parent";
        }
        Parent.prototype.showParent = function(){
            alert(this.src1);
        }
        function Son(){
            this.src2 = "Son";
        }
//      Parent.prototype.showSon = function(){
//          alert(this.src2);
//      }
        //利用原型链实现继承
        Son.prototype = new Parent();
        //将son的原型指向Parent的实例
        
        Son.prototype.showSon = function(){
            alert(this.src2);
        }
        
        var s1 = new Son();
        
        s1.showParent();
        
        s1.showSon();

先继承，再重写

方法的重写（覆盖）和方法的重载：
方法的重写或者覆盖，其实是在继承而言的，如果父类的方法不能满足子类的使用，子类通过写相同的名称的方法，来重写父类的方法。

function add（a）{
return a+10；
}
var sum = add（10，20）
js中没有重载，根据就近原则进行调用。
由于function内部的arguments，所以多加入的参数，保存在arguments数组中；

arguments.callee();//等价于add（）；递归
避免了不必要的错误

（2）基于伪造的方式实现继承

add.call（window）
add.apply（window）//表示将add方法绑定在window对象下面==window.add

（3）继承的终极方案：

基于组合的继承（原型链和伪装）

ES6实现封装和继承：
ES6之前不能定义 “类 ”；我们只能以构造函数的方式模拟类；
ES6中则可以定义类

class 类名{
constructor（）{
this.属性1 = 属性1；
this.属性2 = 属性2；
......
方法名称（参数列表）{
方法体
}
}
}
/************************************************/
定义一个类：
class Ball {
constructor（）{
this.size = size;
this.color = color;

    }
    say(msg){
      alert(-------------)
     }

}

多态：父类引用指向子类实例