Javascript面向对象的语言特性

2017-06-28  本文已影响0人  fronter

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

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(-------------)
     }

}

多态:父类引用指向子类实例
上一篇下一篇

猜你喜欢

热点阅读