JavaScript基于原型的继承与Java类式继承有什么区别

一、核心模型差异：类蓝图实例化与对象委托链接

要理解两者的不同，首先必须厘清它们构建对象体系的思维起点。Java 遵循经典的基于类（Class-based）的面向对象范式，而 JavaScript 采用基于原型（Prototype-based）的委托范式。

在 Java 中，类是绝对的一等公民。类（Class）是定义实体属性类型与行为方法的抽象模板。你不能凭空创建对象，必须先编写类定义，经过编译器检查并生成字节码。当使用 new 关键字实例化时，JVM 会在堆内存中开辟空间，根据类蓝图拷贝属性槽位并绑定方法表引用。子类继承父类（class Dog extends Animal）是两个类声明之间的结构扩展，继承关系在编译期就已经固化。

而在 JavaScript 中，对象才是根本。JavaScript 本质上没有类的物理实体，即使 ES6 引入了 class 语法，其底层运行机制依旧完全构建在原型委托之上。在 JavaScript 里，每个对象都持有一个内置的隐藏属性 [[Prototype]]（在浏览器中暴露为 __proto__，规范推荐使用 Object.getPrototypeOf()）。当一个对象声明需要“继承”另一个对象时，并不是从父模板克隆一份全新结构，而是简单地将自身的内部原型指针直接指向目标对象。

图 1：Java 类式蓝图实例化与 JavaScript 原型委托模型对比

二、属性查找与方法调用机制：多态分发 vs 链路回溯

机制的不同直接决定了运行时方法调用的寻址路径。

1. Java 的虚方法表与早期绑定

Java 在编译期会为每个类生成结构元信息。在方法调用时，除了静态方法和私有方法走静态绑定外，普通的公有实例方法调用走虚方法调用指令（invokevirtual）。JVM 在类加载和链接阶段，为每个类构建一张虚方法表（vtable）。子类继承父类时，vtable 继承父类表项；若子类重写了方法，则替换表中对应索引的指针。当执行 dog.eat() 时，JVM 通过对象头的类型指针找到类 vtable，通过固定偏移量直接定位目标函数地址，寻址效率高且类型安全。

2. JavaScript 的原型链逐层向上回溯

JavaScript 中并没有固定结构的虚方法表。属性读取（包括方法调用）是一个纯粹的动态搜索过程：

1. 步骤一：检查自有属性。引擎首先在目标对象自身的属性表中查找该名称（hasOwnProperty）。如果找到，则直接返回。
2. 步骤二：检查原型指针。如果自身没有该属性，引擎读取对象的内部 [[Prototype]] 引用，跳转到其关联的原型对象。
3. 步骤三：原型递归。在原型对象中重复步骤一与步骤二。若命中则执行调用；若未命中则继续沿着原型链上升。
4. 步骤四：到达终点。原型链的尽头是 Object.prototype，其 [[Prototype]] 为 null。如果查到此处依然未找到，表达式最终返回 undefined（若尝试将其作为函数执行，则抛出 TypeError: ... is not a function）。

图 2：JavaScript 原型链属性解析与回溯步骤推导流程

三、代码实现与语法糖解构：ES6 Class 与 Java 的表面相似与本质不同

许多初学者认为 ES6 提供了 class 和 extends 之后，JavaScript 就变成了与 Java 相同的类继承。我们通过对比实际代码来证明这种认知偏差。

1. Java 类的标准继承示例

// Java 代码：基于类声明与静态类型系统
public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(this.name + " 正在进食");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name); // 显式调用父类构造函数
    }

    public void bark() {
        System.out.println(this.name + " 正在汪汪叫");
    }
}

在 Java 中，当编译期 new Dog("旺财") 时，内存中分配的实例结构是封闭且强类型的。你不能在运行时向 dog1 对象动态临时塞入一个新成员方法。

2. JavaScript ES6 Class 的底层原型还原

在 JavaScript 中写出与上面结构看起来几乎一致的代码：

// JavaScript ES6 语法
class Animal {
  constructor(name) {
    this.name = name;
  }
  eat() {
    console.log(`${this.name} 正在进食`);
  }
}

class Dog extends Animal {
  constructor(name) {
    super(name);
  }
  bark() {
    console.log(`${this.name} 正在汪汪叫`);
  }
}

这段代码在 V8 引擎内部等价于经典的寄生组合式继承：

// JavaScript 底层运行的真实机制（ES5 等价实现）
function Animal(name) {
  this.name = name;
}
Animal.prototype.eat = function() {
  console.log(this.name + " 正在进食");
};

function Dog(name) {
  // 1. 盗用构造函数，初始化实例自有属性
  Animal.call(this, name);
}

// 2. 原型链接：建立委托对象
Dog.prototype = Object.create(Animal.prototype);
// 3. 修正构造器指针
Dog.prototype.constructor = Dog;

Dog.prototype.bark = function() {
  console.log(this.name + " 正在汪汪叫");
};

// 4. 静态方法继承链接
Object.setPrototypeOf(Dog, Animal);

在 JavaScript 中，class 关键字只是让原型写法看起来更规范的语法糖。Animal 和 Dog 的本质依然是函数对象，eat 和 bark 也依然挂载在原型对象上，完全没有发生类字节码模板定义与实例克隆的转换。

图 3：ES6 Class 语法糖与底层原型链结构对应细节

四、动态性与运行期可变性对比

机制上的差异带来工程实践中最重要的行为特征：运行期可变性（Runtime Mutability）。

1. 原型的运行时热插拔与动态污染

在 JavaScript 中，对象与其原型之间的链接是实时的动态指针。这意味着：

• 后发添加生效：即使 dog 实例在 10 分钟前就已经被创建，如果现在在控制台执行 Animal.prototype.sleep = function() { ... }，dog.sleep() 就能立即调用并成功执行。
• 原型替换风险：如果直接修改 Object.prototype，会污染整个执行上下文中的所有普通对象；如果随意修改某个现有实例的 __proto__，现代 JavaScript 引擎（如 V8）会将该对象的优化结构打散，直接导致隐藏类（Hidden Class）和内联缓存（Inline Cache, IC）失效，产生严重性能衰减。

2. Java 类结构的不可变与强类型屏障

Java 的类在经过类加载器装载到 JVM 方法区后，其字段布局、方法槽位在字节码层面上已经锁定。普通业务代码无法在运行时往 Animal 类动态添加一个未定义的方法并让所有现有实例调用。这种约束在牺牲了部分灵活性的同时，带来了严格的编译期安全检查与运行期高度内联优化的确定性。

五、多重继承与行为组合能力

单一继承往往无法满足复杂的系统抽象需求，两者在实现行为组合时给出了截然不同的方案：

• Java 的方案：接口（Interface）与多实现。Java 类只允许单一继承（extends 只能跟一个父类），从根本上避免了 C++ 风格的“菱形继承”二义性。为了实现多态组合，Java 引入了接口（implements A, B, C），并在 Java 8 中引入了接口默认方法（default method），允许在契约规范下复用行为代码。
• JavaScript 的方案：对象混入（Mixin）与原型链桥接。JavaScript 原型链本质上也是单一指针（一个对象只能有一个 [[Prototype]]）。但由于 JavaScript 的动态特性，开发者可以通过 Object.assign(Dog.prototype, canSwimMixin, canFlyMixin) 直接将其他对象的属性与方法拷贝到目标原型上，或者通过高阶函数动态生成继承链路链条，组合方式更加自由轻量。

六、全维度对比总结

为了帮助读者在技术选型与认知建立时获得清晰的全局视图，我们将两种继承机制的核心维度归纳如下：

图 4：JavaScript 原型继承与 Java 类式继承全维度总结与对比架构

七、总结

回顾两者，区别从来不在于语法上的 class 与 extends 关键字，而在于运行时的对象关系模型：

Java 的继承是静态契约，类是铸造对象的模具，一旦实例脱离模板，其字段结构与可调用的方法表均已确立，多态依靠严谨的虚方法表和名义类型系统支持；

JavaScript 的继承是动态委托，原型本身就是一个鲜活的对象实体，实例通过内置指针与之相连。方法调用是沿着链条层层向上的属性寻址。即便引入了 ES6 类语法，本质依然是在操作原型对象。掌握这一核心本质，不仅能彻底看清 JavaScript 的动态特性与行为边界，也能在面对跨语言设计模式时做出更为合理的工程取舍。