有时也叫构造器偷窃（Constructor Stealing，按字面翻译的，有点不好听）或者叫经典继承（Classical Inheritance）。基本思想很简单：在子类的构造器上调用超类构造器。更确切的说是在子类构造器执行上下文来中执行超类构造器（父类构造器中的 this指向子类实例），js提供了apply()和call()函数，它们可以实现这种调用。基本代码如下：
1 function BaseClass()
2 {
3 this.colors=["red","blue"];
4 }
5 function ChildClass()
6 {
7 //inherit
8 BaseClass.call(this);
9 }
10
11 var instance1 = new ChildClass();
12
13 var instance2 = new ChildClass();
14 instance2.colors.push("green");
15
16 var instance3 = new ChildClass();
17
18 alert(instance1.colors);//red,blue
19 alert(instance2.colors);//red,blue,green
20 alert(instance3.colors);//red,blue
结果正是我们所预期的，即使对某个实例继承的属性进行了修改，对其他实例也没影响。代码很简单，核心的是子类构造器里的call()的执行，与它具有相同功效的是apply()，所以这里有必要对这两个神奇的函数进行简单说明。
js中每个function都有这call()和apply()方法。call()函数的功能是在指定的对象上执行函数，它的第一个参数就是指定的对象。它还可以有多个参数，除第一个之外的参数都是调用指定函数所需要的参数，例如：
1 function fun(x,y)
2 {
3 this.pointX = x;
4 this.pointY = y;
5 }
6
7 var dot = {};
8 fun.call(dot,10,20);
9 alert(dot.pointX);//10
10 alert(dot.pointY);//20
其中代码fun.call(dot,10,20)使得dot具有了fun定义的属性。它的意思就是在dot对象上运行fun（），在运行时，fun中的this指向dot,同时向fun()传递了两个参数10和20，分别传给了fun的形参x和y。
而apply()功用上与call()相同，但是调用形式上有些不同，将上个示例中将call()改成apply(),如下：
1 function(x,y)
2 {
3 this.pointX = x;
4 this.pointY = y;
5 }
6
7 var dot={};
8 fun.apply(dot,[10,20]);
9 alert(dot.pointX);//10
10 alert(dot.pointY);//20
区别在于第一个实参（dot）之后的参数，fun()调用所需的实参以数组的形式传递给形参了。在这个示例中apply()的优点似乎不够明显，设想一下 这样的场景：用户调用一个函数，在执行这个函数时，同时要运行另外一个函数，但必须是同一个上下文中（this指向的是同一个对象），而用户传给第一个函 数的参数是不确定的，第一个函数传给第二个函数的参数也是将是不确定的，这种情况下用apply()就很合适了。如:
1 function fun2(x,y,z)
2 {
3 x=x||0;
4 y=y||0;
5 z=z||0;
6 var list = [];
7 list.push(x);
8 list.push(y);
9 list.push(z);
10 alert(list);
11 }
12 function fun1()
13 {
14 fun2.apply(this,arguments);
15 }
16 fun1(10);//10,0,0
17 fun1(10,20);//10,20,0
18 fun1(10,20,30);//10,20,30
可见，如果函数参数传递时是固定的，用call()或apply()都可以，如果参数不是固定的，就要用apply()。
构造器伪装存在一个问题，子类没有办法继承到父类原型上的属性和方法，它只能继承到在父类构造器里定义的属性和方法。而很多时候我们定义类时，为了避免每次new时重复定义方法，会将方法定义到它的原型上，而不是构造器里。考虑以下代码：
1 function BaseClass(n,g)
2 {
3 this.name = n;
4 this.gender = g;
5 this.getName = function(){return this.name;};
6 }
7 BaseClass.prototype.getGender = function(){return this.gender;};
8
9 function ChildClass(n,g,a)
10 {
11 BaseClass.call(this,n,g);
12 this.age = a;
13 }
14 ChildClass.prototype.getAge=function(){return this.age;};
15
16 var instance = new ChildClass("sds","M",30);
17
18 alert(instance.getName());//sds
19 alert(instance.getAge());//30
20 alert(instance.getGender());//error,The getGender() don't inherit from BaseClass;
预想的是getGender()返回"M"，要命的是报了个致命错误。这个示例给我的们展示了，仅靠构造器伪装方式，继承是不可靠的。这里还要说明一点， 对于getName()，由于它定义在父类构造器里，就意味这每次创建父类对象或子类对象时，它都会重新被创建，而这种重复工作，大多数时候是我们要极力 避免的。很多时候，我们将属性定义在构造器里，而将方法定义在原型对象上。这在OO里是讲得通的，因为每个对象拥有不同的数据（属性），但是拥有相同的行 为（方法）。好比我们人类自己，每个人（实例对象）都有自己区别于其他人的特征：姓名、年龄、性别等，但却拥有相同的行为：说话()、行走()等（请别跟 我讲残疾人士，因为我会将你变成残疾人士）。