金沙棋牌官方平台

当前位置:金沙棋牌 > 金沙棋牌官方平台 > js模拟类继承小例子,js面向对象基础

js模拟类继承小例子,js面向对象基础

来源:http://www.logblo.com 作者:金沙棋牌 时间:2019-11-08 00:57

JavaScript实现类的private、protected、public、static以及继承

2015/08/24 · JavaScript · class, private, protected, 继承

原文出处: Yorhom’s Game Box   

图片 1图片 2代码

p1.hello();
p2.hello();

继承父类,并调用父类的方法:

基础知识

 尽管很简单,私有方法却是非常重要的,它可以在保持你的代码免于冲突同时允许对你的用户可见和可用的施以更强大的控制。接下来,我们来研究特权方法。它是你的对象中可以使用的私有方法和共有方法的联合。

function Parent(name)
{
this.aa = 123;
this.getName = function() {return name;}; //使用闭包模拟私有成员
this.setName = function(value){name=value;};
}
Parent.prototype.print = function(){alert("print!");};
Parent.prototype.hello = function()
{
alert(this.getName() + "Parent")
};

flower2.prototype=new flower();
/*重置原型后,修改原型的constructor属性*/
flower2.prototype.constructor=flower2
或每次构造实例时都重写constructor属性
function flower2(){
this.constructor=arguments.callee;
}
flower2.prototype=new flower();

JavaScript中的类

JavaScript实际上是一种弱类型语言,与C++和Java等语言不同。因此,在JavaScript中,没有强调类(class)这一概念,但实际运用中,类还是很重要的,比如写一款游戏,如果我们不停地调用函数来完成创建角色,移动角色的话,那会是什么样的呢?可能会出现非常多的重复代码,因此我们需要一个类来统一这些代码。所谓的类,就是把程序中的代码分类,比如说游戏中的关于角色的代码算作一类,游戏背景算作一类,游戏特效又是一类。这样一来,我们对类进行操作,就不会使代码显得很凌乱,冗杂。虽然Js是弱类型语言,但是也提供了类这一概率。
定义Js中的类,实际上用的是function,总所周知,这个语法其实是用来定义函数的。不用于定义函数的是,我们可以在function中通过this.xxx的方式来定义属性和方法。比如说:

JavaScript

function People () { this.name = "Yorhom"; this.getName = function () { return this.name }; }

1
2
3
4
5
6
7
function People () {
    this.name = "Yorhom";
 
    this.getName = function () {
        return this.name
    };
}

使用的时候使用new

JavaScript

var yorhom = new People(); // "Yorhom" alert(yorhom.getName());

1
2
3
var yorhom = new People();
// "Yorhom"
alert(yorhom.getName());

可以看到,这样就可以使用到我们定义的类和类中的方法了。
也许你会问this.xxx只能定义公有属性和方法,那私有属性和方法怎么办呢?这个可以用到js闭包的知识来解决:

JavaScript

function People () { this.name = "Yorhom"; var age = 16; this.getName = function () { return this.name }; this.getAge = function () { return age; }; } var yorhom = new People(); // undefined alert(yorhom.age); // 16 alert(yorhom.getAge());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function People () {
    this.name = "Yorhom";
 
    var age = 16;
 
    this.getName = function () {
        return this.name
    };
 
    this.getAge = function () {
        return age;
    };
}
 
var yorhom = new People();
// undefined
alert(yorhom.age);
// 16
alert(yorhom.getAge());

 

可以看到,这里的age就是一个私有属性了。

静态方法

var p2 = new Child("xxx",33);

function flower(){}
function flower2(){}
flower2.prototype=new flower();
var obj1=new flower();
var obj2=new flower2();
/*问题出现了,2个实例的constructor属性都指向flower*/
alert(obj1.constructor==obj2.constructor);
/*obj1和obj2是不同的构造器产生的实例,缺指向相同的构造器,显然出了问题*/

JavaScript中的prototype

上面的代码美中不足的地方就是,如果一个类有很多方法,同时用到这个类的地方又有很多(也就是new出来的对象有很多),那么用上面的代码就会出现内存占用过剩的问题。问题的根本原因在于,每次实例化一个对象,这个类就会执行构造器里的代码(以People类为例就是function People () {…}执行的代码),因此每当这个类被实例化的时候,这些方法和属性就会被拷贝到实例化出来的对象中。这样一来,就会造成“吃”内存的现象。
于是js中的prototype就诞生了。prototype的作用通常是给一个类添加一系列常量或者方法。 每当一个类被实例化之后,实例化出来的对象会自动获取类的prototype中定义的方法和属性。只不过这里的获取类似于C++里面的引用,不会在内存里对这些方法和属性进行复制,而是指向这些方法和属性。示例:

JavaScript

function People () { this.name = "Yorhom"; } People.prototype.getName = function () { return this.name; }; var yorhom = new People(); // "Yorhom" alert(yorhom.getName());

1
2
3
4
5
6
7
8
9
10
11
function People () {
    this.name = "Yorhom";
}
 
People.prototype.getName = function () {
    return this.name;
};
 
var yorhom = new People();
// "Yorhom"
alert(yorhom.getName());

 

这种方法虽然可以节约内存,但是,美中不足的是,无法定义私有属性。

 

Child.prototype.hello = function() //重写父类hello方法
{
alert(this.getName() + "Child");

javascript中,对象没有原型,而构造器有原型
原型的含义:如果构造器有一个原型对象 A,则由该构造器创建的实例都必然复制自A

JavaScript Set/Get访问器

什么是set/get访问器呢?如果你熟悉python,那么你可以理解为@property@xxx.setter,但是简陋的js里也有?当然有,只不过是ES5的标准,可以采用这种写法:

JavaScript

Object.defineProperty(this, "name", { get : funtion () { return name; }, set : function (v) { name = v; } });

1
2
3
4
5
6
7
8
9
Object.defineProperty(this, "name", {
    get : funtion () {
        return name;
    },
 
    set : function (v) {
        name = v;
    }
});

 

具体有什么用呢?大致就是this.name属性在被获取的时候调用get访问器,在被更改值的时候调用set
你可以从上面的代码了解大致的写法,不过如果你想深究,可以参考这篇文章:

注意以上的这种用法会有兼容性问题,浏览器支持情况如下:

PC端

Firefox Google Chrome Internet Explorer Opera Safari
4.0 5 9 11.6 5.1

移动端

Firefox Mobile Android IE Mobile Opera Mobile Safari Mobile
4.0 Yes 9 11.5 Yes

来自: https://developer.mozilla.org/…/defineProperty#Browser_compatibility

 

var p1 = new Child("xhan",22);

您可能感兴趣的文章:

  • js对象继承之原型链继承实例
  • js对象的复制继承实例
  • javascript 面向对象封装与继承
  • JavaScript中创建对象和继承示例解读
  • 使用apply方法实现javascript中的对象继承
  • javascript的函数、创建对象、封装、属性和方法、继承
  • js对象的构造和继承实现代码
  • JavaScript中的对象继承关系

实现一个功能丰富的类

我们在上文中提到了,节省内存和定义私有属性两者无法兼得,是啊,和“鱼和熊掌不可兼得”是一个道理,在通常的使用过程中,我们需要对这两项进行取舍。但是现在这个年代,哪有不可兼得的呢?鱼和熊掌不能同时吃?当然不行……因为吃熊掌是违法的(有待考证)?不过至少鸡和鱼是可以同时吃的吧。
由于js没有实现私有属性的定义,所以这其实是一个没有头绪的工作,因为在标准的做法中,我们除了闭包可以阻止外部访问,没有别的办法了。所以这里我们要用点歪门邪道的方法了。

静态方法背后的前提其实跟其它任何方法是一样的。然而,最主要的不同在于,这些方法作为对象的静态属性而存在。作为属性,它们在该对象的实例上下文中不可访问;它们只有在与主对象本身相同的上下文是可用的。这些与传统的类继承的相似点,使得他们有点像是静态的类方法。

您可能感兴趣的文章:

  • javascript asp教程第三课 new String() 构造器
  • JavaScript中使用构造器创建对象无需new的情况说明
  • 详解JavaScript中的构造器Constructor模式
  • JavaScript设计模式之工厂模式和构造器模式
  • javascript设计模式Constructor(构造器)模式
  • JavaScript 高级篇之闭包、模拟类,继承(五)
  • JavaScript 模拟类机制及私有变量的方法及思路
  • 在JavaScript中模拟类(class)及类的继承关系
  • JavaScript中利用构造器函数模拟类的方法

/*申明2个构造器*/
var flower=function(){
this.name="nokia";
}
var flower2=function(){
this.age=22;
}
/*原型链*/
flower2.prototype=new flower();
/*根据刚才原型的定义,实例obj必然复制自new flower();*/
obj=new flowe2();
/*从父类继承的属性*/
alert(obj.name); //==>"nokia"
alert(obj.age); //==>22

类的继承

Javascript没有提供继承的函数,所以只有自己写了。这里借用lufylegend.js中的继承方法向大家展示如何实现继承:

JavaScript

function base (d, b, a) { var p = null, o = d.constructor.prototype, h = {}; for (p in o) { h[p] = 1; } for (p in b.prototype) { if (!h[p]) { o[p] = b.prototype[p]; } } b.apply(d, a); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function base (d, b, a) {
    var p = null, o = d.constructor.prototype, h = {};
 
    for (p in o) {
        h[p] = 1;
    }
    for (p in b.prototype) {
        if (!h[p]) {
            o[p] = b.prototype[p];
        }
    }
 
    b.apply(d, a);
}

这里的base就是继承函数了。继承函数的原理莫过于复制类的方法和属性。因此,只要做到这点,就可以实现类的继承了。可以在上面的代码中看见,我们通过遍历prototype来获取原型链中定义的方法和属性。通过apply调用父类的构造器进行构造器中属性和方法的复制。使用示例:

JavaScript

function People () { this.name = "Yorhom"; } People.prototype.getName = function () { return this.name; }; function Student () { base(this, People, []); } var yorhom = new Student(); // "Yorhom" alert(yorhom.getName());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function People () {
    this.name = "Yorhom";
}
 
People.prototype.getName = function () {
    return this.name;
};
 
function Student () {
    base(this, People, []);
}
 
var yorhom = new Student();
// "Yorhom"
alert(yorhom.getName());

 

公有方法可以完全地被对象的上下文中的最终使用者访问。为了实现这些对于特定对象的所有实例都可用的公共方法,你需要学习一个名为"prototype"的属性。prototype 简单地包含一个对象,为一个父对象的所有新副本充当对基类的引用。本质上,prototype 的任何属性对该对象的所每一个实例都是可用的。创建/引用的过程给了我们一个廉价版的继承 

alert(p1 instanceof Child); //true
alert(p1 instanceof Parent);//true

var Class={
create:function()
{
var _class=function()
{
this.init.apply(this,arguments);
}
_class.prototype.init=Function.prototype.init;
try{
return _class;
}finally{
_class=null;
}
}
};
//默认构造函数
Function.prototype.init=function(){}
//方法扩展
Function.prototype.extend=function(list)
{
for(var i in list)this.prototype[i]=list[i];
return this;
}
//多级继承
Function.prototype.inherits=function(parent)
{
//继承的深度级别
var _depth=0;
//方法属性移植
this.extend(new parent());
//初始化构造函数 类的继承通常不继承构造函数
this.prototype.init=Function.prototype.init;
//类的静态父类
this.parent=parent;
//执行父类函数
this.prototype.parent=function(name)
{
//若没有参数则执行构造函数
if(!name)name='init';
//即将执行的父类
var _parent=parent;
//若当前已经在父类中执行则继续向上寻找超类
if(_depth)
{
for(var i=0;i<_depth;i++)
{
_parent=_parent.parent;
}
}
//设置好级别
_depth++;
try{
//执行函数并返回值
return _parent.prototype[name].apply(this,Array.prototype.slice.apply(arguments,[1]));
}catch(e){
throw(e);
}finally{
//恢复级别
_depth--;
}
}
return this;
}

开源库件jpp.js

秉着这个歪门邪道的思想,我把这个功能封装到jpp.js这个库件中,库件的github地址如下:

当然这个库件不限于创建一个类,还可以实现函数的重载等。目前库件还处于开发阶段,欢迎各位提交建议。

p1.doSomething(); //子类方法
p1.print(); //父类方法

此外原型继承没有提供调用父类的方法
然而我们基于原型继承,通过静态变量记录父类来弥补这一缺陷

如何“歪门邪道”地做到禁止访问私有和保护属性?

这是个比较头疼的问题,正如本节开篇所说,我们在常规开发下,只能通过闭包来阻止某变量的访问。可是如果你使用了prototype,那么闭包这条路就走不通了。在这种情况下,我们的Object.defineProperty就出场了。我们知道,通过这个函数可以设定获取属性时返回的值,也可以设定更改属性时设置的值。有了这个函数,我们可以随时跟踪到某个属性是不是在被获取,或者是不是在被更改。我们还需要一个开关,我们在类内部的方法调用时,把这个开关打开,表明是在内部运行,方法调用结束后将开关关闭,表明回到外部运行状态。有了这两个状态,我们就可以跟踪privateprotected属性和方法了,一旦他们在开关关闭的时候被使用,就终止这个属性或方法的获取或设置。
于是乎,大难题就快解决了。

图片 3图片 4代码

Parent.prototype.hello.apply(this,arguments); //调用父类同名方法
};
//子类方法
Child.prototype.doSomething = function(){ alert(this.age + "Child doSomething"); };

复制代码 代码如下:

使用jpp.js创建一个类

JavaScript

var People = jpp.class({ extends : null, private : { id : null, hobby : null }, protected : { money : null, phoneNumber : null }, public : { firstName : null, lastName : null, age : null, birthday : null, occupation : null, constructor : function (name, id) { if (name) { var nameArray = name.split(" "); this.firstName = nameArray[0]; this.lastName = nameArray[1]; } if (id) { this.id = id; } }, setBirthday : function (date) { if (date) { this.birthday = date; } }, getBirthday : function () { return this.birthday; }, askForId : function () { return this.id; }, findHobby : function () { return this.hobby; } }, static : { OCCUPATION_PROGRAMMER : "programmer", OCCUPATION_ARTIST : "artist", OCCUPATION_MUSICIAN : "musician", OCCUPATION_STUDENT : "student" } }); var peter = new People("Peter Wong", 543232123565); peter.occupation = People.OCCUPATION_PROGRAMMER; peter.setBirthday("19980727"); // result: Peter alert(peter.firstName); // result: 19990727 alert(peter.getBirthday()); // result: 51092028 alert(peter.askForId()); // result: null alert(peter.findHobby()); // result: programmer alert(peter.occupation); // error alert(peter.id);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
var People = jpp.class({
    extends : null,
    private : {
        id : null,
        hobby : null
    },
    protected : {
        money : null,
        phoneNumber : null
    },
    public : {
        firstName : null,
        lastName : null,
        age : null,
        birthday : null,
        occupation : null,
 
        constructor : function (name, id) {
            if (name) {
                var nameArray = name.split(" ");
 
                this.firstName = nameArray[0];
                this.lastName = nameArray[1];
            }
 
            if (id) {
                this.id = id;
            }
        },
 
        setBirthday : function (date) {
            if (date) {
                this.birthday = date;
            }
        },
 
        getBirthday : function () {
            return this.birthday;
        },
 
        askForId : function () {
            return this.id;
        },
 
        findHobby : function () {
            return this.hobby;
        }
    },
    static : {
        OCCUPATION_PROGRAMMER : "programmer",
        OCCUPATION_ARTIST : "artist",
        OCCUPATION_MUSICIAN : "musician",
        OCCUPATION_STUDENT : "student"
    }
});
 
var peter = new People("Peter Wong", 543232123565);
peter.occupation = People.OCCUPATION_PROGRAMMER;
 
peter.setBirthday("19980727");
 
// result: Peter
alert(peter.firstName);
// result: 19990727
alert(peter.getBirthday());
// result: 51092028
alert(peter.askForId());
// result: null
alert(peter.findHobby());
// result: programmer
alert(peter.occupation);
// error
alert(peter.id);

 

对上面的代码进行分析:
使用jpp.class函数创建一个类,函数的参数是一个Object,这个Object可添加的属性如下:

  • extends 继承时的父类
  • private 装载私有属性,里面定义的成员外部不可使用且不能继承给子类
  • protected 装载保护属性,里面定义的成员外部不可使用但可以继承给子类
  • public 装载公有属性
  • static 装载静态方法和属性

在创建类的过程中,在public中添加constructor方法初始化构造器,this.super可访问父类构造器。

运行代码,可以看到浏览器正常运行前5个alert,而最后一个运行的时候浏览器报错:

图片 5

具体的实现过程有点复杂,不过原理在上文已经详细讲述了。代码可以在github里参看,欢迎各位研究。

2 赞 6 收藏 评论

图片 6

公有方法

复制代码 代码如下:

复制代码 代码如下:

静态属性和方法的定义

静态属性和方法以及静态类在js中的定义非常简单,先来看静态类:

JavaScript

var StaticClass = {};

1
var StaticClass = {};

这么写不是在定义一个Object吗?是的,不错,不过js中的静态类也是可以这样定义的。如果要添加静态类中的方法和属性,就可以这么写:

JavaScript

var StaticClass = { id : 5, sayHello : function () { alert("Hello"); } };

1
2
3
4
5
6
var StaticClass = {
    id : 5,
    sayHello : function () {
        alert("Hello");
    }
};

如果是要向类中添加静态属性或者方法,可以采用这种写法:

JavaScript

function People () { this.name = "Yorhom"; } People.prototype.getName = function () { return this.name; }; People.TYPE = "people"; People.sayHello = function () { alert("Hello"); };

1
2
3
4
5
6
7
8
9
10
11
12
function People () {
    this.name = "Yorhom";
}
 
People.prototype.getName = function () {
    return this.name;
};
 
People.TYPE = "people";
People.sayHello = function () {
    alert("Hello");
};

 

不像大多数其它面向对象的语言,JavaScript实际上并没有类的概念。在大多数其它的面向对象语言中,你可以初始化一个特定的类的实例,但是在JavaScript中的情况这是这样。在JavaScript中,对象能够创建新的对象,对象可以继承自其它对象。整个概念被称为"prototypal inheritance"(原型标本继承) 

function Child(name,age)
{
Parent.apply(this, arguments);//调用父类构造函数来继承父类定义的属性
this.age = age;
}
extend(Child,Parent); //继承Parent

例子:

 

//使用原型继承,中间使用临时对象作为Child的原型属性,临时对象的原型属性再指向父类的原型,
//防止所有子类和父类原型属性都指向通一个对象.
//这样当修改子类的原型属性,就不会影响其他子类和父类
function extend(Child, Parent) {
var F = function(){};
F.prototype = Parent.prototype;
Child.prototype = new F();
Child.prototype.constructor = Child;
Child.base = Parent.prototype;
}

解决的方法

图片 7图片 8代码

var test=Class.create().inherits(class1).extend({
b:function()
{
alert('test');
this.parent('b')
},
c:110
});

 实际上对象就这么回事了。然而,事情变得麻烦的地方,在于新对象(尤其是那些继承其它对象属性的对象)的创建。

复制代码 代码如下:

图片 9图片 10代码

复制代码 代码如下:

 

复制代码 代码如下:

 1 //一个表示教室的对象构造器
 2 function Classroom( students, teacher ) {
 3 //用来显示教室中的所有学生的私有方法
 4 function disp() {
 5 alert( this.names.join(", ") );
 6 }
 7 //课程的数据存储在公有的对象属性里
 8 this.students = students;
 9 this.teacher = teacher;
10 //调用私有方法显示错误
11 disp();
12 }
13 //创建一新的教室对象
14 var class = new Classroom( [ "John", "Bob" ], "Mr. Smith" );
15 //失败,因为disp不是该对象的公有方法
16 class.disp();

//创建名为class1的构造器
var class1=Class.create().extend({
b:function()
{
alert('clas');
alert(this.c);
},
c:100
});
//创建"对象"(构造器)的实例
var s=new class1();
s.b();// ==>"clas",100

 1 <script>
 2 //创建一个新的接受properties对象的对象
 3 function User( properties ) {
 4 //遍历对象属性,确保它作用域正确(如前所述)
 5 for ( var i in properties ) { (function(which){ var p=i
 6 //为属性创建获取器
 7 which[ "get" + i ] = function() {
 8 return properties[p];
 9 };
10 //为属性创建设置器
11 which[ "set" + i ] = function(val) {
12 properties[p] = val;
13 };
14 })(this); }
15 }
16 //创建一个新user 对象实例,传入一个包含属性的对象作为种子
17 var user = new User({
18 name: "Bob",
19 age: 44
20 });
21 //请注意name属性并不存在,因为它在properties 对象中,是私有的
22 alert( user.name == null );
23 //然而,我们能够使用用动态生成的方法getname 来访问它
24 alert( user.getname() == "Bob" );
25 //最后,我们能看到,通过新生成的动态方法设置和获取age 都是可以的
26 user.setage( 22 );
27 alert( user.getage() == 22 );
28 </script>

复制代码 代码如下:

 1 //一个简单的函数,接受一个参数name,
 2 //并将其保存于当前上下文中
 3 function User( name ) {
 4 this.name = name;
 5 }
 6 //用指定的name创建上述函数的新实例
 7 var me = new User( "My Name" );
 8 //我们可以看到name已经被成为对象本身的属性
 9 alert( me.name == "My Name" );
10 //而且它确实是User对象的一个新实例
11 alert( me.constructor == User );
12 //那么,既然User()只是一个函数,
13 //当我们这么处理它的时候,发生了什么?
14 User( "Test" );
15 //因为this上下文没有被设置,它缺省地指向全局的window对象,
16 //这意味着window.name将等于我们提供给它的那个name
17 alert( window.name == "Test" );

一个构造器产生的实例,其constructor属性默认总是指向该构造器
alert(obj.constructor);//==>flower
构造器原型的constructor属性 指向构造器本身
alert(flower.prototype.constructor==flower);//==>true
constructor会与原型继承发生的冲突

 

1 //附加在User对象上的一个静态方法
2 User.cloneUser = function( user ) {
3 //创建并返回一个新的User对象
4 return new User(
5 //该对象是其它user对象的克隆
6 user.getName(),
7 user.getAge()
8 );
9 };

 1 //创建一个新的User的构造器
 2 function User( name, age ){
 3 this.name = name;
 4 this.age = age;
 5 }
 6 //为prototype对象添加一个新方法
 7 User.prototype.getName = function(){
 8 return this.name;
 9 };
10 //为prototype对象添加另一个方法
11 //注意此方法的上下文将是被实例化的对象
12 User.prototype.getAge = function(){
13 return this.age;
14 };
15 //实例化一个新的User对象
16 var user = new User( "Bob", 44 );
17 //我们可以看到两个方法被附加到了对象上,有着正确的上下文
18 alert( user.getName() == "Bob" );
19 alert( user.getAge() == 44 );

程序1. 创建简单对象并设置其属性的两个例子

 1 //创建一个新的User对象构造器
 2 function User( name, age ) {
 3 //计算用户的出生年份
 4 var year = (new Date()).getFullYear() – age;
 5 //创建一个新特权方法,对变量year有访问权,
 6 //但又是公共可访问的
 7 this.getYearBorn = function(){
 8 return year;
 9 };
10 }
11 //创建一个User对象的新实例
12 var user = new User( "Bob", 44 );
13 //验证返回的出生年份是否正确
14 alert( user.getYearBorn() == 1962 );
15 //并注意我们不能访问对象的私有属性year
16 alert( user.year == null );

 

本质上,特权方法是动态生成的方法,因为它们是在运行时而不是代码初次编译时添加给对象的。这种技术在计算量上要比绑定一个简单的方法到对象的prototype 上来得昂贵,但同时也的强大和灵活得多。 

 

图片 11图片 12代码

 1 //创建一个新对象并将其存放在obj里
 2 var obj = new Object();
 3 //将该对象的一些属性设置成不同的值
 4 obj.val = 5;
 5 obj.click = function(){
 6 alert( "hello" );
 7 };
 8 //下面是等效的代码,使用了{...}式缩写,
 9 //和定义对象属性的"名称-值"对
10 var obj = {
11 //用名称-值对设置对象属性
12 val: 5,
13 click: function(){
14 alert( "hello" );
15 }
16 };

 

 

图片 13图片 14代码

私有方法  

私有方法和变量只能被其它的私有方法、私有变量的特权方法访问。这是一种定义只能在内象内部访问的代码的方式。

 

 

 

 

本文由金沙棋牌发布于金沙棋牌官方平台,转载请注明出处:js模拟类继承小例子,js面向对象基础

关键词: