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

Question

所以我在用java做一个游戏，我有两个方法的对象update()和render()

在游戏循环所在的主类中，我必须为每个可更新和可渲染的对象调用update()和render()方法
有没有办法建立某种形式的接口，我可以在其中调用一次方法，然后它将在所有实现的对象中调用它

Answer 1

也就是说，接口用于：

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 2

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

基本上，您需要使用所需的方法定义一个接口。注意，在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 3

接口的主要用途之一是实现多态性，或在多个不同对象上执行相同操作的能力。如果不同的对象都实现相同的接口并具有相同的方法，那么您可以将所有这些对象存储在一个向量/列表中，并在每个对象上迭代调用该方法的向量

根据您的要求：

    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();
}

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

Answer 4

其他答案是正确的，但是最好使用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