Question

我在Android Studio中创建游戏。游戏具有简易模式和硬模式（分别为hard=False和hard=True）。

Easy模式和Hard模式都有自己的类。这两个类都包含相同的功能，但它们的实现方式不同。我在我的Gameplay课程中调用这些类中的函数。这意味着在我的Gameplay课程中的每个函数中，我都必须执行以下操作：

if (hard == True):
    HardGameplay gameplayMode = new HardGameplay();
else:
    EasyGameplay gameplayMode = new EasyGameplay();

functionResult = gameplayMode.myFunction();

但是，我不想在每个函数中执行if-else检查，而是只想检查一次。因此，我创建了一个checkDifficulty（）函数，我在onCreate的开头调用它：

public ??? gameplayMode;
public Boolean easyOrHard() {
    if (hard == True):
        HardGameplay gameplayMode = new HardGameplay();
    else:
        EasyGameplay gameplayMode = new EasyGameplay();
}

问题是，我不知道我应该在???放置什么类型。它应该是HardGameplay或EasyGameplay，但我事先并不知道这两者中的哪一个。将Object置于其中也不起作用，因为我调用的每个函数都会产生错误Cannot resolve method 'myFunction()'。

有人知道该怎么办吗？或者我可以忽略一个更容易的实现？非常感谢任何帮助！

Answer 1

你需要多态性。

因此，创建一个名为GamePlay的超类，并使HardGamePlay和EasyGamePlay扩展这些类。这个超类定义了将由其子类

实现的函数

public abstract class GamePlay {
    public abstract void myFunction();
}

public class HardGamePlay extends GamePlay {
    public void myFunction() {
         //your code here
    }
}

然后你可以使用

public GamePlay gamePlayMode

在您的GameActivity中执行此操作：

Gameplay gameplay = null;
if (hardmode)
    gameplay = new HardGamePlay();
else
    gameplay = new EasyGamePlay();

Answer 2

您只需使用界面：

public interface GamePlay {
    ... // Your different methods declaration
}

您的两个类将实现此接口：

public class HardGamePlay implements GamePlay {
    ... // You override  the methods here
}

public class EasyGamePlay implements GamePlay {
    ... // You override  the methods here
}

然后您可以使用：

GamePlay gamePlayMode = easyOrHard();
public GamePlay easyOrHard() {
if (hard) {
    return new HardGameplay();
} else {
   return new EasyGameplay();
}

这称为Polymorphism：http://www.artima.com/objectsandjava/webuscript/PolymorphismInterfaces1.html

Answer 3

如果两个类都包含相同的方法，您只需创建一个Game接口，您可以将其用作变量类型。

public interface Game {
    void methodA();
    void methodB();
}

这两种模式现在都可以从这个界面实现

public class HardGameplay implements Game{
    @Override
    public void methodA() {
        // Do something
    }

    @Override
    public void methodB() {
        // do something
    }
}

public class EasyGameplay implements Game{
    @Override
    public void methodA() {
        // Do something
    }

    @Override
    public void methodB() {
        // do something
    }
}

您现在可以创建变量Game并为其指定特定类型的模式。由于它们都具有通用接口，您仍然可以以相同的方式访问这两个类，如方法中所示doSomethingHere

public class GamePlayManager {
    private boolean hardMode;

    private Game gameMode;

    public GamePlayManager(boolean hardMode) {
        this.hardMode = hardMode;
    }

    public void createGame() {
        if(hardMode) {
            gameMode = new HardGameplay();
        } else {
            gameMode = new EasyGameplay();
        }
    }

    public void doSomethingHere() {
        gameMode.methodA();
    }

}

Answer 4

基本上你到目前为止得到了2个答案：

1）使用抽象基类和抽象myFunction（）

2）与myFunction（）有一个共同界面，即EasyGameplay和HardGameplay都可以实现

您在两种方法之间做出决定的方式是两者之间有多少常见的实现数据和行为：如果至少可以共享一个方法实现（不仅仅是方法签名）和/或类具有相同的类成员属性，你应该使用抽象的超类，并只使用myFunction（）抽象。否则，使用一个通用接口，它只定义两个实现者（EasyGameplay和HardGameplay）将实现的方法签名。

Answer 5

正如Simon所说，你可以通过 HardGamePlay 和 EasyGamePlay 创建一个超类扩展。如果两个类都具有相同的方法命名法，这将有效。

但是，如果EasyGamePlay和HardGamePlay类有不同的方法，您可以尝试使用Object，但请记住，您需要强制它之前适当的类调用方法。

public class Person {
    public void sayHello() {
        System.out.println("I am a person");
    }
}

public class Dog {
    public void bark() {
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Object thing = new Dog();

        //This won't work as the program 
        //does not know which instance to call
        //thing.bark();

        if(thing instanceof Person) {
            ((Person)thing).sayHello();
        } else if(thing instanceof Dog) {
            ((Dog)thing).bark();
        }
    }
}

然而，最好的方法是使用多态，以避免使用对象变量/字段。如果您不能使用多态，请考虑检查您的软件架构

Java / Android：定义未知类型的对象

5 个答案: