如何让类继承另一个类的特定实例？游戏类场景示例

针对你遇到的「既要让Character拥有Entity的能力，又要避免参数冗余、重复实例化」的问题，以下是几种实用的解决方案：

方案一：组合模式（推荐，解耦且灵活） #

采用组合而非继承的思路，让Character持有一个已创建的Entity实例，并代理Entity的方法到自身，既避免重复渲染，又能让外部调用保持一致。

代码实现 #

class Character {
  constructor(entity, name, talkimg = name + ".webp", talkpos = [70, 20], talkflip = false) {
    this.entity = entity;
    this.name = name;
    this.talkimg = talkimg;
    this.talkpos = talkpos;
    this.talkflip = talkflip;

    // 代理Entity的move方法，外部可直接调用ben.move()
    this.move = (...args) => this.entity.move(...args);

    // 可选：代理Entity的属性，方便直接访问ben.x/ben.y等
    Object.defineProperties(this, {
      x: { get: () => this.entity.x },
      y: { get: () => this.entity.y },
      sprite: { get: () => this.entity.sprite }
    });
  }

  async talk(...strings) {
    speechSet(this.name, this.talkimg, this.talkpos, this.talkflip);
    await speech(...strings);
  }
}

// 使用示例
const benEntity = new Entity("ben.webp", [10, 6], benEvent, [9, 6], [9, 5]);
const ben = new Character(benEntity, "Ben", "ben-angry.webp", [60, 30]);

// 直接调用两类方法
ben.move([11, 6], [10, 6]);
await ben.talk("Hey! How's it going?");

优势 #

• 完全分离两类参数，不用牺牲默认参数或剩余参数
• 仅创建一次Entity实例，避免重复渲染
• 解耦Entity和Character的逻辑，后续修改其中一类不影响另一类
• 可灵活扩展：比如给同一个Entity绑定不同的Character逻辑，反之亦然

方案二：工厂函数（极简实现） #

用工厂函数合并Entity和Character的实例，快速生成同时拥有两类能力的对象。

代码实现 #

function createCharacter(entityArgs, characterArgs) {
  const entity = new Entity(...entityArgs);
  const character = new Character(...characterArgs);
  // 合并两个实例的属性和方法
  return Object.assign({}, entity, character);
}

// 使用示例
const ben = createCharacter(
  ["ben.webp", [10, 6], benEvent, [9, 6], [9, 5]],
  ["Ben", "ben-angry.webp", [60, 30]]
);

ben.move([11, 6]);
await ben.talk("Hi there!");

优势 #

• 代码极简，无需修改原有类结构
• 直接得到统一的对象，调用方式一致

注意 #

如果Entity和Character存在同名属性/方法，后者会覆盖前者，需确保两类逻辑无命名冲突。

方案三：参数对象优化继承 #

修改类的构造函数，用参数对象替代零散参数，既保留继承关系，又避免参数冗余。

代码实现 #

// 改造Entity，使用对象参数
class Entity {
  constructor({ sprite, pos, func, intcoords = [] }) {
    this.sprite = sprite;
    this.func = func;
    this.move(pos, ...intcoords);
  }

  move(pos, ...intcoords) {
    this.y = pos[0]; this.x = pos[1];
    this.sprite = drawImg(this.sprite, this.y, this.x);
    for (let coord of intcoords) {
      // 处理交互坐标逻辑
    }
  }
}

// Character继承改造后的Entity
class Character extends Entity {
  constructor(entityOpts, { name, talkimg = name + ".webp", talkpos = [70, 20], talkflip = false }) {
    super(entityOpts);
    this.name = name;
    this.talkimg = talkimg;
    this.talkpos = talkpos;
    this.talkflip = talkflip;
  }

  async talk(...strings) {
    speechSet(this.name, this.talkimg, this.talkpos, this.talkflip);
    await speech(...strings);
  }
}

// 使用示例
const ben = new Character(
  { sprite: "ben.webp", pos: [10, 6], func: benEvent, intcoords: [[9, 6], [9, 5]] },
  { name: "Ben", talkimg: "ben-angry.webp", talkpos: [60, 30] }
);

ben.move([11, 6]);
await ben.talk("Greetings!");

优势 #

• 保留类的继承关系，符合面向对象设计
• 参数结构清晰，避免零散参数带来的混乱
• 原有逻辑改动小，易维护

内容的提问来源于stack exchange，提问作者Commenter25