Design patterns 工厂设计模式下的重新分解

嗯，我在重新分解旧代码方面遇到了一些麻烦，这是学校的作业，所以。。。 我计划使用工厂设计模式或策略，无论如何，我不确定如何在这个特定场景中使用它们：

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

public void下沉（inti，intj）
{
如果（映射[i][j]==命中）
{
//如果打击不在边缘
if（i0&&j0）
{
//如果是奇数，则为上面的dec
如果（映射[i-1][j]！=命中和映射[i-1][j]%2==1）
{
//if（map[i-1][j]==13）
map[i-1][j]=map[i-1][j]-9；
}
//如果是偶数，则为12月
if（map[i-1][j]！=命中和映射[i-1][j]%2==0）
{
map[i-1][j]=map[i-1][j]-2；
}
//如果奇数，则在下面的12月
如果（映射[i+1][j]！=命中和映射[i+1][j]%2==1）
{
map[i+1][j]=map[i+1][j]-9；
}
//如果偶数的话，12月下旬
如果（映射[i+1][j]！=命中和映射[i+1][j]%2==0）
{
map[i+1][j]=map[i+1][j]-2；
}
//即使是偶数也要离开
如果（映射[i][j-1]！=命中和映射[i][j-1]%2==0）
{
map[i][j-1]=map[i][j-1]-4；
}
//如果是奇数，则为dec left
如果（映射[i][j-1]！=命中和映射[i][j-1]%2==1）
{
map[i][j-1]=map[i][j-1]-9；
}
//即使是对的
如果（映射[i][j+1]！=命中和映射[i][j+1]%2==0）
{
map[i][j+1]=map[i][j+1]-4；
}
//如果是奇数，则为dec right
如果（映射[i][j+1]！=命中和映射[i][j+1]%2==1）
{
map[i][j+1]=map[i][j+1]-9；
}
}

我继续说下去，因为我有很多if-else语句，所以我考虑使用上面的模式。

---

帮助

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

Factory

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

策略

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

---

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

你可以在那里有一个策略。首先，从策略的接口开始。我不知道你在使用哪种语言，所以我将使用类似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方法

那么，为什么有一堆if会更好呢？你可以使用继承。在你的例子中，你有两个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;
    }
}

希望能有帮助