If statement 如何重构深度嵌套的函数？

我的代码当前如下所示：

If (case = 1)
{
    If (option = 1)
    {
        If (otherOption = 1)
            ;do something
        else if (otherOption = 2)
            ;do something
        else if (otherOption = 3)
            ;do something
    }
    else
    {
        If (otherOption = 1)
            ;do something
        else if (otherOption = 2)
            ;do something
        else if (otherOption = 3)
            ;do something
    }
}

else if (case = 2)
{
    If (option = 1)
    {
        If (otherOption = 1)
            ;do something
        else if (otherOption = 2)
            ;do something
        else if (otherOption = 3)
            ;do something
    }
    else
    {
        If (otherOption = 1)
            ;do something
        else if (otherOption = 2)
            ;do something
        else if (otherOption = 3)
            ;do something
    }
}

else if (case = 3)
{
    If (option = 1)
    {
        If (otherOption = 1)
            ;do something
        else if (otherOption = 2)
            ;do something
        else if (otherOption = 3)
            ;do something
    }
    else
    {
        If (otherOption = 1)
            ;do something
        else if (otherOption = 2)
            ;do something
        else if (otherOption = 3)
            ;do something
    }
}

显然很糟糕，很难维护。我想在上面添加另一个super If语句，它将这棵树拆分6次。每个做某事只需要一行代码

---

关于如何重构这个怪物有什么帮助吗？我已经写了很多这样的代码，我害怕每次都使用它。我需要一种新的方法来解决这些问题。扩展此代码的功能需要大量的工作。

即使您没有指定应用程序的上下文，这似乎是一个可以从的应用程序中获益的场景

您发布的代码可以设置为充当上下文对象，负责控制外部if-else语句的更高级别条件。
在if-else语句的每个块中，可以使用ConcreteStrategy对象（通常实现策略接口）加载特定行为

对于内部if-else块，可以重复此模式

例子 考虑一个游戏，其中一个角色在2D地图上移动。根据其寿命指示器（例如0-200），如果其分别处于疲劳、正常或超级状态，则可移动2、5、8个瓷砖

角色对象的行为类似于策略模式的“上下文，他有责任使移动策略适合于这种情况。 将正确的MoveStrategy对象放入生命，并通过字符的move（）方法转发方法move（）进行调用

示例的Java实现提示：

public class Character{

    private int life=100;
    private int x=0 
    private int y=0; 
    private MoveStrategy strategy=new DefaultStrategy();


    public int getLife(){
        return life;
        }

        public void setLife(int value){
        this.life=value;
        }

    public void move(){
        if(life<30)
            strategy=new TiredStrategy();
        else if(life > 100)
            strategy=new SuperStrategy();
        else
            strategy=new DefaultStrategy();


        strategy.move();

    }
}



public interface MoveStrategy{

    public abstract void move();

}

public DefaultStrategy implements MoveStrategy{

    public void move(){
        System.out.println("Move character of 5 tiles");
    }
}

public TiredStrategy implements MoveStrategy{

    public void move(){
        System.out.println("Move character of 2 tiles");
    }
}

public SuperStrategy implements MoveStrategy{

    public void move(){
        System.out.println("Move character of 8 tiles");
    }
}

公共类字符{
私人寿命=100；
私有整数x=0
私有整数y=0；
private MoveStrategy strategy=新的DefaultStrategy（）；
公共生活{
回归生活；
}
公共void setLife（int值）{
这就是：生命=价值；
}
公开作废动议（）{
如果（生活100）
战略=新的超级战略（）；
其他的
策略=新的DefaultStrategy（）；
策略。移动（）；
}
}
公共接口策略{
公共抽象无效移动（）；
}
公共默认策略实施移动策略{
公开作废动议（）{
System.out.println（“移动5个瓦片的字符”）；
}
}
公共疲劳战略实施移动战略{
公开作废动议（）{
System.out.println（“移动2个瓦片的字符”）；
}
}
公共超战略实施战略{
公开作废动议（）{
System.out.println（“移动8个瓦片的字符”）；
}
}
什么是编程范式需要考虑？结构化还是面向对象？非常有用的答案。这是更好的，并使它更容易扩展功能。更容易理解。非常感谢。