使用工厂设计模式进行重新分解

Question

我在重新分解旧代码时遇到了一些麻烦，这是学校的作业，所以...我打算使用工厂设计模式或策略，但我不确定如何在这个特定的场景中使用它们:

public void sunk(int i, int j)
{
    if(map[i][j]==hit)
    {

    //if the hit is not on an edge
    if(i<9 && i>0 && j<9 && j>0)
    {

        //dec above if odd
        if(map[i-1][j]!= hit && map[i-1][j]%2==1)
        {
            //if(map[i-1][j]==13)
            map[i-1][j]= map[i-1][j] -9;
        }

        //dec above if even
        if(map[i-1][j]!= hit && map[i-1][j]%2==0)
        {
            map[i-1][j]= map[i-1][j] -2;
        }

        //dec below if odd
        if(map[i+1][j]!= hit && map[i+1][j]%2==1)
        {
            map[i+1][j]= map[i+1][j] -9;
        }

        //dec below if even
        if(map[i+1][j]!= hit && map[i+1][j]%2==0)
        {
            map[i+1][j]= map[i+1][j] -2;
        }

        //dec left if even
        if(map[i][j-1]!= hit && map[i][j-1]%2==0)
        {
            map[i][j-1]= map[i][j-1] -4;
        }

        //dec left if odd
        if(map[i][j-1]!= hit && map[i][j-1]%2==1)
        {
            map[i][j-1]= map[i][j-1] -9;
        }

        //dec right if even
        if(map[i][j+1]!= hit && map[i][j+1]%2==0)
        {
            map[i][j+1]= map[i][j+1] -4;
        }

        //dec right if odd
        if(map[i][j+1]!= hit && map[i][j+1]%2==1)
        {
            map[i][j+1]= map[i][j+1] -9;
        }
    }

我一直在继续，因为我有很多if-else语句，所以我正在考虑使用上面的模式。帮助

Answer 1

你可以在那里有一个策略。首先，从策略的界面开始。我不知道你在使用哪种语言，所以我将使用类似java的语言。

interface HitStrategy {
    bool AppliesTo(map, i, j);
    void Apply(map,i,j);
}

每个类都将实现不同的if块：

class DecRightIfOdd implements HitStrategy { 
    public bool AppliesTo(map, i, j){
        return map[i][j+1]!= hit && map[i][j+1]%2==1;
    }

    public void Apply(map,i,j){
         map[i][j+1]= map[i][j+1] -9;
    }
}

然后在您的代码中，您可以有一个HitStrategy列表，并找到适用于地图和位置的列表，然后调用Apply方法。

那么，为什么这比拥有一堆如果更好呢？您可以使用继承。在您的示例中，您有两个 Dec Right，一个用于奇数，一个用于偶数。您可以这样做：

abstract class DecRight implements HitStrategy { 
    public bool AppliesTo(map, i, j){
        return map[i][j+1]!= hit;
    }
    public abstract Apply(map,i,j);
}

class DecRightIfOdd inherits DecRight { 
    public bool AppliesTo(map, i, j){
        return base(map,i,j) && map[i][j+1]%2==0;
    }

    public void Apply(map,i,j){
         map[i][j+1]= map[i][j+1] -4;
    }
}

class DecRightIfEven inherits DecRight { 
    public bool AppliesTo(map, i, j){
        return base(map,i,j) && map[i][j+1]%2==1;
    }

    public void Apply(map,i,j){
         map[i][j+1]= map[i][j+1] -9;
    }
}

希望有帮助。

Answer 2

我不确定这两种模式是否对你有帮助。

工厂将用于根据输入参数实例化对象的不同子类（或子类集）。

策略将用于在运行时替换类中的行为。

如果不进一步了解上面的代码试图实现什么，很难提出建议。对于上面这样的代码，可以封装到查找表中，这将为您提供一个简洁的实现（巨大？）可读性成本。