Optimization 如何简化此代码或更好的设计？

我正在开发一个游戏，游戏有不同的模式。简单、正常、困难。 所以，我在考虑如何存储游戏模式。我的第一个想法是用数字来表示难度

容易=0正常=1困难=2

因此，我的代码将有如下内容：

switch(gameMode){

case 0:
//easy
break;

case 1:
//normal
break;

case 3:
//difficult
break;

}

    class GameMode{
    int maxEnemyNumber;
    int maxWeaponNumber;
      public static GameMode init(){
         GameMode gm = GameMode();
         gm.maxEnemyNumber = 0;
         gm.maxWeaponNumber = 0;
         return gm;
      }    

    }

class EasyMode extends GameMode{

      public static GameMode init(){
         GameMode gm = super.init();
         gm.maxEnemyNumber = 10;
         gm.maxWeaponNumber = 100;
         return gm;
      }    
}


class NormalMode extends GameMode{

      public static GameMode init(){
         GameMode gm = super.init();
         gm.maxEnemyNumber = 20;
         gm.maxWeaponNumber = 80;
         return gm;
      }    
}

但我认为它有一些问题，如果我添加一个新模式，例如“极端”，我需要添加案例4。。。这似乎不是gd设计

所以，我想制作一个gameMode对象，不同的gameMode是超级类gameMode的子类。 gameMode对象如下所示：

switch(gameMode){

case 0:
//easy
break;

case 1:
//normal
break;

case 3:
//difficult
break;

}

    class GameMode{
    int maxEnemyNumber;
    int maxWeaponNumber;
      public static GameMode init(){
         GameMode gm = GameMode();
         gm.maxEnemyNumber = 0;
         gm.maxWeaponNumber = 0;
         return gm;
      }    

    }

class EasyMode extends GameMode{

      public static GameMode init(){
         GameMode gm = super.init();
         gm.maxEnemyNumber = 10;
         gm.maxWeaponNumber = 100;
         return gm;
      }    
}


class NormalMode extends GameMode{

      public static GameMode init(){
         GameMode gm = super.init();
         gm.maxEnemyNumber = 20;
         gm.maxWeaponNumber = 80;
         return gm;
      }    
}

---

但我认为创建一个对象来存储gameMode似乎太“庞大”，我的“gameMode”只存储游戏设置的不同变量。。。。这是存储数据而不是创建对象的简单方法吗？thz u.

在GameMode类的构造函数中使用切换方法。

除了一些语法问题之外，我认为您的方法是正确的。考虑到一次可能只有一种模式，我认为你不必担心记忆。这是一种形式的。您可以对其进行扩展，使模式可以做更多的工作。例如，可能会有一个generateEnemies方法来创建一组或一组敌人，而不是基本上只保存常量。这会将更多策略移到模式对象中。超类中的合理默认值有助于避免冗余代码。

很难说这里可以进行哪种重构，因为关于其他类的信息太少了。但是您可以检查在不同状态对象中封装不同行为的。扩展基本GameMode类的方法与状态模式非常相似。我觉得这比一个开关盒好。。。如果应用得当，模式是可靠的做事方式。

我不懂java（你的例子就是这样的），所以我用一些简单的C语言来表达我的想法

这里有一个想法。将您的游戏模式用作标志。如果您从以下内容开始：

[Flags]
enum GameModes
{
    Unknown = 0,
    ModeA = 1,
    ModeB = 2,
    ModeC = 4,
}

现在你有了1-7级

GameModes Difficulty = GameModes.ModeA | GameModes.ModeB;    // difficulty = 3
GameModes Difficulty = GameModes.ModeB;    // difficulty = 2

---

此外，如果级别（模式）更改、添加等，您显示的任何一种方法都需要您添加更多选项。让您的模式模板从XML（或您选择的其他源）读入，将模式数据保存到可序列化的类中。我认为您不需要对基类进行任何扩展。

我认为您试图表示一个配置数据表。如果您使用的语言支持此功能，请将其放入配置文件中，或者在代码中使用文字数据

例如，您可以用C编写：

typedef enum difficulties {
  DIFFICULTY_EASY,
  DIFFICULTY_MEDIUM,
  DIFFICULTY_HARD
} difficulties;

struct {
  int max_enemies;
  int max_weapons;
} difficulty_settings[] = {
  {10, 4},
  {20, 5},
  {30, 6}
};

当你想阅读一个特定的设置时，例如简单级别的最大敌人，那么你可以写

难度设置[defestion\u easy]。最大敌人

---

通过扩展表格可以轻松添加更多配置（更多参数或更多难度级别）。

为什么您认为交换机更难维护？如果您添加了另一种模式，那么无论您采用何种解决方案，都必须添加代码

我能想到的唯一一种情况是，如果你添加了另一种模式，你不必添加代码，如果你从

gameMode

的值生成游戏的参数

例如：

max敌军=5*游戏模式

我认为，除非您有非常复杂的初始化，否则执行切换就足够了。我知道，我知道，对象和类都很好，所有这些都很有趣，但是如果你只需要定义几个变量，事情就可以进行了，那么花时间开发一个复杂的游戏模式类可能毕竟不是一个有价值的解决方案（我的意思是，你打算添加多少游戏模式？）。
利用

用Java语言来说：

public interface Strategy {
    void execute();
}

public class SomeStrategy implements Strategy {
    public void execute() {
        System.out.println("Some logic.");
    }
}

您可以按如下方式使用：

Map<String, Strategy> strategies = new HashMap<String, Strategy>();
strategies.put("strategyName1", new SomeStrategy1());
strategies.put("strategyName2", new SomeStrategy2());
strategies.put("strategyName3", new SomeStrategy3());

// ...

strategies.get(s).execute();

Map strategies=newhashmap（）；
strategies.put（“strategyName1”，newsomestrategy1（））；
strategies.put（“strategyName2”，newsomestrategy2（））；
strategies.put（“strategyName3”，newsomestrategy3（））；
// ...
strategies.get（s.execute（）；
在这里，您应该实现的首要目标是集中逻辑以检索与不同级别相关的值。通过提供一个存储这些值的位置，可以最大限度地减少在添加其他级别、添加其他值等时需要更改的代码中的位置数

对于这个解决方案，类接口是一个很好的选择。但是，如果类表示的配置选项数量有限，则没有理由需要使用继承。您可以从封装逻辑的单个类开始。如果代码的其余部分通过类接口检索其设置，您可以稍后引入更复杂的设计，例如每个模式的子类，如果需要对游戏的其余部分进行有限的修改

例如，第一个实现可能类似于

enum mode {
    MODE_EASY = 0,
    MODE_NORMAL = 1,
    MODE_DIFFICULT = 2,
};

class gameSettings {
    public gameSettings(mode GameMode) {
        m_mode = GameMode;
    }

    public int getMaxWeaponNumber() {
        int maxWeaponNumber;
        switch(m_mode) {
            case EASY_MODE:
                maxWeaponNumber = 100;
                break;

            // Other mode settings.               
         }

         return maxWeaponNumber;
    }

    // Other game settings....

    private mode m_mode;

}

这结合了switch（）语句的直截了当性和类接口的优点。您还可以按照另一张海报的建议，使用查找表或其他适合您的应用程序的机制替换switch（）语句。
为什么？这不是很难维持吗？