`
menjoy
  • 浏览: 422840 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

JavaScript 面向对象程序设计(下)——继承与多态

阅读更多
1 又是几个基本概念
为什么要说又呢? 

在讨论继承时,我们已经列出了一些基本概念了,那些概念是跟封装密切相关的概念,今天我们要讨论的基本概念,主要是跟继承与多态相关的,但是它们跟封装也有一些联系。

1.1 定义和赋值
变量定义是指用

var a;
这种形式来声明变量。

函数定义是指用

function a(...) {...}
这种形式来声明函数。

var a = 1;
是两个过程。第一个过程是定义变量 a,第二个过程是给变量 a 赋值。

同样

var a = function(...) {};
也是两个过程,第一个过程是定义变量 a 和一个匿名函数,第二个过程是把匿名函数赋值给变量 a。

变量定义和函数定义是在整个脚本执行之前完成的,而变量赋值是在执行阶段完成的。

变量定义的作用仅仅是给所声明的变量指明它的作用域,变量定义并不给变量初始值,任何没有定义的而直接使用的变量,或者定义但没有赋值的变量,他们的值都是 undefined。

函数定义除了声明函数所在的作用域外,同时还定义函数体结构。这个过程是递归的,也就是说,对函数体的定义包括了对函数体内的变量定义和函数定义。

通过下面这个例子我们可以更明确的理解这一点:

alert(a);
alert(b);
alert(c);
var a = "a";
function a() {}
function b() {}
var b = "b";
var c = "c";
var c = function() {}
alert(a);
alert(b);
alert(c);


猜猜这个程序执行的结果是什么?然后执行一下看看是不是跟你想的一样,如果跟你想的一样的话,那说明你已经理解上面所说的了。

这段程序的结果很有意思,虽然第一个 alert(a) 在最前面,但是你会发现它输出的值竟然是 function a() {},这说明,函数定义确实在整个程序执行之前就已经完成了。

再来看 b,函数 b 定义在变量 b 之前,但是第一个 alert(b) 输出的仍然是 function b() {},这说明,变量定义确实不对变量做什么,仅仅是声明它的作用域而已,它不会覆盖函数定义。

最后看 c,第一个 alert(c) 输出的是 undefined,这说明 var c = function() {} 不是对函数 c 定义,仅仅是定义一个变量 c 和一个匿名函数。

再来看第二个 alert(a),你会发现输出的竟然是 a,这说明赋值语句确实是在执行过程中完成的,因此,它覆盖了函数 a 的定义。

第二个 alert(b) 当然也一样,输出的是 b,这说明不管赋值语句写在函数定义之前还是函数定义之后,对一个跟函数同名的变量赋值总会覆盖函数定义。

第二个 alert(c) 输出的是 function() {},这说明,赋值语句是顺序执行的,后面的赋值覆盖了前面的赋值,不管赋的值是函数还是其它对象。

理解了上面所说的内容,我想你应该知道什么时候该用 function x(..) {…},什么时候该用 var x = function (…) {…} 了吧?

最后还要提醒一点,eval 中的如果出现变量定义和函数定义,则它们是在执行阶段完成的。所以,不到万不得已,不要用 eval!另外,即使要用 eval,也不要在里面用局部变量和局部方法!

1.2 this 和执行上下文
在前面讨论封装时,我们已经接触过 this 了。在对封装的讨论中,我们看到的 this 都是表示 this 所在的类的实例化对象本身。真的是这样吗?

先看一下下面的例子吧:

var x = "I'm a global variable!";
function method() {
    alert(x);
    alert(this.x);
}
function class1() {
    // private field
    var x = "I'm a private variable!";
    // private method
    function method1() {
        alert(x);
        alert(this.x);
    }
    var method2 = method;
    // public field
    this.x = "I'm a object variable!";
    // public method
    this.method1 = function() {
        alert(x);
        alert(this.x);
    }
    this.method2 = method;
    // constructor
    {
        this.method1();     // I'm a private variable!
                            // I'm a object variable!
        this.method2();     // I'm a global variable!
                            // I'm a object variable!
        method1();          // I'm a private variable!
                            // I'm a global variable!
        method2();          // I'm a global variable!
                            // I'm a global variable!
        method1.call(this); // I'm a private variable!
                            // I'm a object variable!
        method2.call(this); // I'm a global variable!
                            // I'm a object variable!
    }
}
 
var o = new class1();
method();       // I'm a global variable!
                // I'm a global variable!
o.method1();    // I'm a private variable!
                // I'm a object variable!
o.method2();    // I'm a global variable!
                // I'm a object variable!


为什么是这样的结果呢?

那就先来看看什么是执行上下文吧。那什么是执行上下文呢?

如果当前正在执行的是一个方法,则执行上下文就是该方法所附属的对象,如果当前正在执行的是一个创建对象(就是通过 new 来创建)的过程,则创建的对象就是执行上下文。

如果一个方法在执行时没有明确的附属于一个对象,则它的执行上下文是全局对象(顶级对象),但它不一定附属于全局对象。全局对象由当前环境来决定。在浏览器环境下,全局对象就是 window 对象。

定义在所有函数之外的全局变量和全局函数附属于全局对象,定义在函数内的局部变量和局部函数不附属于任何对象。

那执行上下文跟变量作用域有没有关系呢?

执行上下文与变量作用域是不同的。

一个函数赋值给另一个变量时,这个函数的内部所使用的变量的作用域不会改变,但它的执行上下文会变为这个变量所附属的对象(如果这个变量有附属对象的话)。

Function 原型上的 call 和 apply 方法可以改变执行上下文,但是同样不会改变变量作用域。

要理解上面这些话,其实只需要记住一点:

变量作用域是在定义时就确定的,它永远不会变;而执行上下文是在执行时才确定的,它随时可以变。

这样我们就不难理解上面那个例子了。this.method1() 这条语句(注意,这里说的还没有进入这个函数体)执行时,正在创建对象,那当前的执行上下文就是这个正在创建的对象,所以 this 指向的也是当前正在创建的对象,在 this.method1() 这个方法执行时(这里是指进入函数体),这个正在执行的方法所附属的对象也是这个正在创建的对象,所以,它里面 this.x 的 this 也是同一个对象,所以你看的输出就是 I’m a object variable! 了。

而在执行 method1() 这个函数时(是指进入函数体后),method1() 没有明确的附属于一个对象,虽然它是定义在 class1 中的,但是他并没有不是附属于 class1 的,也不是附属于 class1 实例化后的对象的,只是它的作用域被限制在了 class1 当中。因此,它的附属对象实际上是全局对象,因此,当在它当中执行到 alert(this.x) 时,this.x 就成了我们在全局环境下定义的那个值为 “I’m a global variable!” 的 x 了。

method2() 虽然是在 class1 中定义的,但是 method() 是在 class1 之外定义的,method 被赋值给 method2 时,并没有改变 method 的作用域,所以,在 method2 执行时,仍然是在 method 被定义的作用域内执行的,因此,你看到的就是两个 I’m a global variable! 输出了。同样,this.method2() 调用时,alert(x) 输出 I’m a global variable! 也是这个原因。

因为 call 会改变执行上下文,所以通过 method1.call(this) 和 method2.call(this) 时,this.x 都变成了 I’m a object variable!。但是它不能改变作用域,所以 x 仍然跟不使用 call 方法调用时的结果是一样的。

而我们后面执行 o.method1() 时,alert(x) 没有用 this 指出 x 的执行上下文,则 x 表示当前执行的函数所在的作用域中最近定义的变量,因此,这时输出的就是 I’m a private variable!。最后输出 I’m a object variable! 我想不用我说大家也知道为什么了吧?:D

2 继承和多态
2.1 从封装开始
前面我们说了,封装的目的是实现数据隐藏。

但是更深一层来说,在 javascript 中进行封装还有以下几个好处:

1、隐身实现细节,当私有部分的实现完全重写时,并不需要改变调用者的行为。这也是其它面向对象语言要实现封装的主要目的。

2、javascript 中,局部变量和局部函数访问速度更快,因此把私有字段以局部变量来封装,把私有方法以局部方法来封装可以提高脚本的执行效率。

3、对于 javascript 压缩混淆器(据我所知,目前最好的 javascript 分析、压缩、混淆器就是 JSA)来说,局部变量和局部函数名都是可以被替换的,而全局变量和全局函数名是不可以被替换的(实际上,对于 javascript 脚本解析器工作时也是这样的)。因此,不论对于开源还是非开源的 javascript 程序,当私有字段和私有方法使用封装技术后,编写代码时就可以给它们定义足够长的表意名称,增加代码的可读性,而发布时,它们可以被替换为一些很短的名称(一般是单字符名称),这样就可以得到充分的压缩和混淆。及减少了带宽占用,又可以真正实现细节的隐藏。

所以,封装对于 javascript 来说,是非常有用的!

那么在 javascript 实现继承是为了什么呢?

2.2 为什么要继承
在其它面向对象程序设计语言中,继承除了可以减少重复代码的编写外,最大的用处就是为了实现多态。尤其是在强类型语言中,尤为如此:

1、在强类型语言中,一个变量不能够被赋予不同类型的两个值,除非这两种类型与这个变量的类型是相容的,而这个相容的关系就是由继承来实现的。

2、在强类型语言中,对一个已有的类型无法直接进行方法的扩充和改写,要扩充一个类型,唯一的方法就是继承它,在它的子类中进行扩充和改写。

因此,对于强类型的面向对象语言,多态的实现是依赖于继承的实现的。

而对于 javascript 语言来说,继承对于实现多态则显得不那么重要:

1、在 javascript 语言中,一个变量可以被赋予任何类型的值,且可以用同样的方式调用任何类型的对象上的同名方法。

2、在 javascript 语言中,可以对已有的类型通过原型直接进行方法的扩充和改写。

所以,在 javascript 中,继承的主要作用就是为了减少重复代码的编写。

接下来我们要谈的两种实现继承的方法可能大家已经都很熟悉了,一种是原型继承法,一种是调用继承法,这两种方法都不会产生副作用。我们主要讨论的是这两种方法的本质和需要注意的地方。

2.3 原型继承法
在 javascript 中,每一个类(函数)都有一个原型,该原型上的成员在该类实例化时,会传给该类的实例化对象。实例化的对象上没有原型,但是它可以作为另一个类(函数)的原型,当以该对象为原型的类实例化时,该对象上的成员就会传给以它为原型的类的实例化对象上。这就是原型继承的本质。

原型继承也是 javascript 中许多原生对象所使用的继承方法。

function parentClass() {
    // private field
    var x = "I'm a parentClass field!";
    // private method
    function method1() {
        alert(x);
        alert("I'm a parentClass method!");
    }
    // public field
    this.x = "I'm a parentClass object field!";
    // public method
    this.method1 = function() {
        alert(x);
        alert(this.x);
        method1();
    }
}
parentClass.prototype.method = function () {
    alert("I'm a parentClass prototype method!");
}
parentClass.staticMethod = function () {
    alert("I'm a parentClass static method!");
}
 
function subClass() {
    // private field
    var x = "I'm a subClass field!";
    // private method
    function method2() {
        alert(x);
        alert("I'm a subClass method!");
    }
    // public field
    this.x = "I'm a subClass object field!";
    // public method
    this.method2 = function() {
        alert(x);
        alert(this.x);
        method2();
    }
    this.method3 = function() {
        method1();
    }
}
 
// inherit
subClass.prototype = new parentClass();
subClass.prototype.constructor = subClass;
 
// test
var o = new subClass();
 
alert(o instanceof parentClass);    // true
alert(o instanceof subClass);       // true
 
alert(o.constructor);  // function subClass() {...}
 
o.method1();    // I'm a parentClass field!
                // I'm a subClass object field!
                // I'm a parentClass field!
                // I'm a parentClass method!
o.method2();    // I'm a subClass field!
                // I'm a subClass object field!
                // I'm a subClass field!
                // I'm a subClass method!
o.method();     // I'm a parentClass prototype method!
 
o.method3();               // Error!!!
subClass.staticMethod();   // Error!!!


上面这个例子很好的反映出了如何利用原型继承法来实现继承。

利用原型继承的关键有两步操作:

首先创建一个父类的实例化对象,然后将该对象赋给子类的 prototype 属性。

这样,父类中的所有公有实例成员都会被子类继承。并且用 instanceof 运算符判断时,子类的实例化对象既属于子类,也属于父类。

然后将子类本身赋值给它的 prototype 的 constructor 属性。(注意:这里赋值的时候是没有 () 的!)

这一步是为了保证在查看子类的实例化对象的 constructor 属性时,看到的是子类的定义,而不是其父类的定义。

接下来,通过对 o.method1() 调用的结果我们会看到,子类继承来的公有实例方法中,如果调用了私有实例字段或者私有实例方法,则所调用的这些私有实例成员是属于父类的。

同样,通过对 o.method2() 调用的结果我们看到,子类中定义的实例方法,如果调用了私有实例字段或者私有实例方法,则所调用的这些私有实例成员是属于子类的。

通过对 o.method() 调用的结果我们看到,定义在父类原型上的方法,会被子类继承。

通过对 o.method3() 调用的结果我们看到,子类中定义的实例方法是不能访问父类中定义的私有实例成员的。

最后,通过对 subClass.staticMethod() 调用的结果我们看到,静态成员是不会被继承的。

2.4 调用继承法
调用继承的本质是,在子类的构造器中,让父类的构造器方法在子类的执行上下文上执行,父类构造器方法上所有通过 this 方式操作的内容实际上都都是操作的子类的实例化对象上的内容。因此,这种做法仅仅为了减少重复代码的编写。
function parentClass() {
    // private field
    var x = "I'm a parentClass field!";
    // private method
    function method1() {
        alert(x);
        alert("I'm a parentClass method!");
    }
    // public field
    this.x = "I'm a parentClass object field!";
    // public method
    this.method1 = function() {
        alert(x);
        alert(this.x);
        method1();
    }
}
parentClass.prototype.method = function () {
    alert("I'm a parentClass prototype method!");
}
 
parentClass.staticMethod = function () {
    alert("I'm a parentClass static method!");
}
 
function subClass() {
    // inherit
    parentClass.call(this);
 
    // private field
    var x = "I'm a subClass field!";
    // private method
    function method2() {
        alert(x);
        alert("I'm a subClass method!");
    }
    // public field
    this.x = "I'm a subClass object field!";
    // public method
    this.method2 = function() {
        alert(x);
        alert(this.x);
        method2();
    }
    this.method3 = function() {
        method1();
    }
}
 
// test
var o = new subClass();
 
alert(o instanceof parentClass);    // false
alert(o instanceof subClass);       // true
 
alert(o.constructor);  // function subClass() {...}
 
o.method1();    // I'm a parentClass field!
                // I'm a subClass object field!
                // I'm a parentClass field!
                // I'm a parentClass method!
o.method2();    // I'm a subClass field!
                // I'm a subClass object field!
                // I'm a subClass field!
                // I'm a subClass method!
 
o.method();                // Error!!!
o.method3();               // Error!!!
subClass.staticMethod();   // Error!!!


上面这个例子很好的反映出了如何利用调用继承法来实现继承。

利用调用继承的关键只有一步操作:

就是在子类定义时,通过父类的 call 方法,将子类的 this 指针传入。使父类方法在子类上下文中执行。

这样,父类中的所有在父类内部通过 this 方式定义的公有实例成员都会被子类继承。

用 instanceof 运算符判断时,子类的实例化对象只属于子类,不属于父类。

查看子类的实例化对象的 constructor 属性时,看到的是子类的定义,不是其父类的定义。

接下来,通过对 o.method1() 和 o.method2() 调用的结果跟原型继承法的调用结果是相同的,所说明的问题也是一样的,这里不再重复。

通过对 o.method() 调用的结果我们看到,定义在父类原型上的方法,不会被子类继承。

通过对 o.method3() 调用的结果我们看到,子类中定义的实例方法同样不能访问父类中定义的私有实例成员的。

最后,通过对 subClass.staticMethod() 调用的结果我们看到,静态成员同样不会被继承的。

最后,还有一点,在这个例子中没有体现出来,就是通过调用继承法,可以实现多继承。也就是说,一个子类可以从多个父类中继承通过 this 方式定义在父类内部的所有公有实例成员。

作为一种弱类型语言,javascript 提供了丰富的多态性,javascript 的多态性是其它强类型面向对象语言所不能比的。

多态
重载和覆盖
先来说明一下重载和覆盖的区别。重载的英文是 overload,覆盖的英文是 override。发现网上大多数人把 override 当成了重载,这个是不对的。重载和覆盖是有区别的。

重载的意思是,同一个名字的函数(注意这里包括函数)或方法可以有多个实现,他们依靠参数的类型和(或)参数的个数来区分识别。

而覆盖的意思是,子类中可以定义与父类中同名,并且参数类型和个数也相同的方法,这些方法的定义后,在子类的实例化对象中,父类中继承的这些同名方法将被隐藏。

重载
javascript 中函数的参数是没有类型的,并且参数个数也是任意的,例如,尽管你可以定义一个:

function add(a, b) {
    return a + b;
}


这样的函数,但是你仍然可以再调用它是带入任意多个参数,当然,参数类型也是任意的。至于是否出错,那是这个函数中所执行的内容来决定的,javascript 并不根据你指定的参数个数和参数类型来判断你调用的是哪个函数。

因此,要定义重载方法,就不能像强类型语言中那样做了。但是你仍然可以实现重载。就是通过函数的 arguments 属性。例如:

function add() {
    var sum = 0;
    for (var i = 0; i < arguments.length; i++) {
        sum += arguments[i];
    }
    return sum;
}
这样你就实现了任意多个参数加法函数的重载了。

当然,你还可以在函数中通过 instanceof 或者 constructor 来判断每个参数的类型,来决定后面执行什么操作,实现更为复杂的函数或方法重载。总之,javascript 的重载,是在函数中由用户自己通过操作 arguments 这个属性来实现的。

覆盖
实现覆盖也很容易,例如:

function parentClass() {
    this.method = function() {
        alert("parentClass method");
    }
}
function subClass() {
    this.method = function() {
        alert("subClass method");
    }
}
subClass.prototype = new parentClass();
subClass.prototype.constructor = subClass;
 
var o = new subClass();
o.method();


这样,子类中定义的 method 就覆盖了从父类中继承来的 method 方法了。

你可能会说,这样子覆盖是不错,但 java 中,覆盖的方法里面可以调用被覆盖的方法(父类的方法),在这里怎么实现呢?也很容易,而且比 java 中还要灵活,java 中限制,你只能在覆盖被覆盖方法的方法中才能使用 super 来调用次被覆盖的方法。我们不但可以实现这点,而且还可以让子类中所有的方法中都可以调用父类中被覆盖的方法。看下面的例子:

function parentClass() {
    this.method = function() {
        alert("parentClass method");
    }
}
function subClass() {
    var method = this.method;
    this.method = function() {
        method.call(this);
        alert("subClass method");
    }
}
subClass.prototype = new parentClass();
subClass.prototype.constructor = subClass;
 
var o = new subClass();
o.method();


你会发现,原来这么简单,只要在定义覆盖方法前,定义一个私有变量,然后把父类中定义的将要被覆盖的方法赋给它,然后我们就可以在后面继续调用它了,而且这个是这个方法是私有的,对于子类的对象是不可见的。这样跟其它高级语言实现的覆盖就一致了。

最后需要注意,我们在覆盖方法中调用这个方法时,需要用 call 方法来改变执行上下文为 this(虽然在这个例子中没有必要),如果直接调用这个方法,执行上下文就会变成全局对象了。
分享到:
评论
1 楼 hax 2007-09-29  
引用
2、javascript 中,局部变量和局部函数访问速度更快,因此把私有字段以局部变量来封装,把私有方法以局部方法来封装可以提高脚本的执行效率。


这种说法是不成立的。构造函数中this.xxx和xxx访问,从理论上分析应该没有差别,即使有一点差别也绝对可以忽略不计,根本没有必要仅为了这点(可能不存在的)效率提升去采取这样的方式。局部变量还有个问题,如果要在构造函数之外访问,必须通过一个特权方法(即this.getXXX = function(){return xxx}这样的)来暴露出去,而方法调用比简单的this.xxx存取要慢太多了。此外,特权方法都是closure。而BE(JS之父,mozilla的CTO)举过例子,同样的对象,以closure(即内部函数)的方式比普通的通过this访问的方式,其对象创建要多耗3倍内存,慢3倍(还仅是就所举的很简单的例子而言)。

请参考《JS优化原则

引用
局部变量和局部函数名都是可以被替换的,而全局变量和全局函数名是不可以被替换的


这种说法并不完全,首先,命名约定方式既然是约定,当然也可以被压缩。JSA完全可以提供这样的选项。其次,JS源代码压缩本身并不是唯一的方式,实际上多数场合,使用HTTP协议中允许的gzip压缩编码,效果就不错了,不必一定要用JS压缩器,因为边际效用可能很小了。

相关推荐

    面向对象JavaScript开发

    JavaScript,作为一种广泛应用...JavaScript 面向对象程序设计——继承与多态.pdf 和 JavaScript 面向对象程序设计——封装.pdf 这两个文档可能深入探讨了这些主题,帮助读者深入理解并掌握JavaScript的面向对象开发。

    JavaScript中的面向对象.pdf

    JavaScript,作为一种广泛使用的脚本语言,常常被误解为非面向对象的语言,但实际上,JavaScript完全支持面向对象编程(OOP)的三大核心原则:封装、继承和多态。尽管它的实现方式与传统的面向对象语言(如Java或C++...

    JAVA面向对象程序设计教案.doc

    其中,Java语言由于其独特的跨平台特性、丰富的类库支持和良好的生态,成为了学习面向对象程序设计的优选语言之一。本次课程《JAVA面向对象程序设计教案》正是为了帮助西南财经大学天府学院13级专科电脑、网络、软件...

    第5章对象教学设计.docx

    【JavaScript 面向对象教学】本章主要探讨JavaScript中的面向对象编程,这是一种重要的编程思想,可以提升程序的灵活性、健壮性、可重用性和可维护性,特别是在大型项目中有着广泛的应用。面向对象思想源于计算机...

    写给大家看的面向对象编程书(第3版).[美]Matt Weisfeld(带详细书签).pdf

    此外,本书还讨论了各种与面向对象概念密切相关的应用主题,包括XML、UML建模语言、持久存储、分布式计算和客户/服务器技术等。  本书内容精炼,示例简单明了,适合各层次面向对象开发人员阅读,也是高校相关专业...

    从面向过程到面向对象

    面向对象的三大特性——封装、继承和多态,使得代码结构更加清晰,更易于理解和扩展。 接着,面向组件编程(Component-Oriented Programming)如.NET平台下的C#语言,进一步提升了软件开发的效率,组件可以被视为...

    java面向对象

    `Java面向对象常识.docx`可能涵盖了封装、继承和多态这三个面向对象的基本原则。封装是将数据和操作数据的方法捆绑在一起,形成一个独立的单元,保护数据不被外部直接访问。继承允许子类继承父类的属性和方法,从而...

    Java语言程序设计教程--电子教案

    面向对象的三大特性——封装、继承和多态也会被详尽地阐述。封装允许我们隐藏实现细节,提供公共接口供外部调用;继承使得子类可以继承父类的属性和方法,实现代码复用;多态则提供了灵活的接口,允许不同的子类对象...

    JavaScript程序天下实例参考手册随书光盘(之三)——入门教程

    6. **面向对象编程**:JavaScript支持基于原型的面向对象编程,包括对象创建、构造函数、原型链、继承以及封装和多态的概念。 7. **ES6及后续版本的新特性**:介绍ECMAScript新版本带来的新功能,如箭头函数、模板...

    王义强_面向对象课设_longery5u_高校人员管理系统_王义强_

    OOP的四大原则——封装、继承、多态和抽象,在这个系统设计中都会有所体现。 首先,封装是面向对象的基础,它保护了数据的安全性,防止外部代码随意修改。在高校人员管理系统中,教师对象的敏感信息如身份证号、...

    java课程设计计算器的设计与实现.pdf

    面向对象课程设计报告——基于Java的计算器设计与实现 本报告旨在详细阐述一款基于Java的计算器应用程序的设计与实现过程,该计算器具备基本的数学运算功能,并具有历史记录和检查功能,便于用户验证之前的计算结果...

    山东大学面前对象实验打字游戏javaweb版

    5. **面向对象编程**:包括类的设计、对象的创建和操作,以及继承、封装和多态的应用。 6. **用户认证与授权**:登录注册功能涉及到用户身份验证和权限控制。 7. **AJAX异步通信**:提高用户体验,实现页面无刷新...

    jOOPL:JavaScript的面向对象编程

    总的来说,jOOPL和相关的PDF资源为开发者提供了一个深入了解和实践JavaScript面向对象编程的平台。通过学习和掌握这些知识,开发者可以构建更高效、更易于维护的Web应用,同时提升自己的编程技能和职业竞争力。

    thinkphp, ThinkPHP3.2 ——基于PHP5的简单快速的面向对象的PHP框架.zip

    10. **面向对象编程**:ThinkPHP3.2全面支持面向对象编程,包括类、接口、继承、多态等特性,使得代码更易于维护和扩展。 在压缩包中的`thinkphp-master`目录下,你可能找到以下关键文件和目录: - `ThinkPHP`:...

    JavaScript 权威指南(第6版)PDF版本下载.txt

    - **面向对象编程**:探讨如何在JavaScript中实现封装、继承、多态等面向对象编程特性。 - **性能优化**:提供实用的技巧和建议,帮助开发者提高应用程序的运行效率。 4. **框架和库**: - **React**:作为前端...

    Java语言程序设计(一)04747-汇总(2016——2017全).doc

    3. **面向对象特性**:面向对象编程(OOP)的四个基本概念是封装、继承、多态和抽象。在提供的选项中,`方法`、`线程`和`继承`是OOP的重要概念,而`模块`更多与模块化编程相关,不是Java特有的面向对象机制。 4. **...

    沈阳师范---Java程序设计---实验题.docx

    当需要添加新类型的雇员时,只需要创建一个新的类继承自`Employee`并实现`computeSalary()`即可,这就是面向对象编程的“开闭原则”——对扩展开放,对修改关闭。 综上所述,这两个Java程序设计实验题主要涵盖了...

    前端关于JS的面向对象概念

    面向对象是编程领域中一种重要的设计思想,尤其在JavaScript这种多范式语言中,它扮演着关键角色。面向对象编程(OOP)的核心是将数据和操作这些数据的方法结合在一起,形成独立的、可复用的实体——对象。与面向...

Global site tag (gtag.js) - Google Analytics