Java多态-如何在不同的类中调用相同的方法

Question

所以我正在用 java 制作一个游戏，并且我的对象都具有 2 种方法； update() 和 render()。

在游戏循环所在的主类中，我必须为每个可更新和可渲染的对象调用 update() 和 render() 方法。
有什么方法可以设置某种形式的接口，我可以在其中调用方法一次，它会在所有实现的对象中调用它？

Answer 1

其他答案都是正确的，但是使用composite pattern会更好：

public interface GameComponent {

    void render();

    void update();
}

public abstract class ChildComponent implements GameComponent {

    protected ContainerComponent parent; // (see below)

    // getter and setter for parent
}

public class ContainerComponent implements GameComponent {

    protected List<GameComponent> children = new ArrayList<>();

    public void add(GameComponent child) {
        this.children.add(child);
        child.setParent(this);
    }

    @Override
    public void update() {
        for (GameComponent c : this.children) {
            c.update();
        }
    }

    @Override
    public void render() {
        for (GameComponent c : this.children) {
            c.render();
        }
    }

}

然后你实现你的特定GameComponents 以便它们扩展ChildComponent 或ContainerCompoenent：

public class Player extends ChildComponent {

    @Override
    public void update() {
        // update player
    }

    @Override
    public void render() {
        // render player
    }

}

public class World extends ContainerComponent {

    @Override
    public void update() {
        super.update(); // update world's children (the player)
        // update the world (this can be done either after or before updating children,
        // you choose how to update your world)
    }

    @Override
    public void render() {
        super.render(); // render world's children (the player)
        // render the world (this can be done either after or before rendering children,
       // you choose how to render your world)
    }

}

然后，在你的主循环中：

// Create player and world
Player p = new Player();
World w = new World();

// Add player to world
w.add(p);

// Update everything
w.update();

// Render everything
w.render();

这样，您创建了GameComponents 的合成，然后您将update() 和render() 只是最顶层的ContainerComponent。

Answer 2

即接口用于：

interface I {
    void render();
}

class A implements I {
     public void render() {
         // render an A object ...
     }
}

class B implements I {
     public void render() {
         // render an B object ...
     }
}

以及您可能拥有的任何地方

List<I> list = new ArrayList();
list.add(new A());
list.add(new B());

for(I i:list) {
    i.render();
}

A 类和 B 类的对象不同，但它们实现相同的协定（接口）。

Answer 3

这是面向对象编程的支柱之一，polymorphism。

基本上，您需要使用所需的方法定义一个接口。请注意，在 java 中，接口方法默认是公共的。

public interface Renderable {
  void render();
  void update();
}

然后你定义实现。要实现一个接口，您需要使用“implements”关键字。在下面的示例中，您将看到“implements Renderable”

public class MyRenderable implements Renderable {
  public void render() {
     ... // method impl
  }

  public void update() {
     ... // method impl
  }
}

最后，您创建一个实例并通过接口调用方法。

Renderable r = new MyRenderable();
r.render();
r.update();

从这里您可以使用您的界面类型填充一个列表。您可以遍历该列表，从接口调用方法，调用实现。

Answer 4

接口的主要用途之一是实现多态性，或对多个不同对象执行相同操作的能力。例如，如果不同的对象都实现了相同的接口并具有相同的方法，则可以将所有这些对象存储在 Vector/List 中，并通过对每个对象调用该方法的 Vector 进行迭代。

根据您的要求：

    interface I {
    void render();
    void update();
   }

class first implements I {
     public void update(){
       // doWhaterver you want to do 
     }
     public void render() {
         // doWhaterver you want to do 
     }
}

class second implements I {
     public void update(){
       // doWhaterver you want to do 
     }
     public void render() {
         // doWhaterver you want to do 
     }
}

现在将它们添加到列表中

List<I> list = new ArrayList();
list.add(new first());
list.add(new second());

for(I i:list) {
    i.update();
    i.render();
}

它将调用实现的函数，即多态