Question

所以我在java中制作一个游戏，我有两个方法的对象; 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();
        }
    }

}

然后，您实施特定的GameComponent，以便他们延伸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();

这样，您创建了GameComponent的复合，然后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

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

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

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

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

4 个答案: