0

我想知道是否有办法删除这种重复的代码（它出现在我的程序中）

public void pickUp(Cointainer in)
{
    if(playerContainer.returnSomething() == null)
    {
        playerContainer.setSomething(in.returnSomething());
        in.setSomething(null);
    }
}

public void dropContainer (Container out)
{
    if(out.returnSomething() == null)
    {
        out.setSomething(playerContainer.returnSomething());
        playerContainer.setSomething(null);
    }
}

正如您从上面的示例中看到的那样，这两种方法基本上完全相同，除了哪个容器被测试为空，以及对象最终进入哪个容器。无论如何，有没有将这样的东西简化为一种方法？另一个示例出现在代码的后面，其中多个对象以不同的顺序进行测试：

if (control = 1)
{
  if(con1 == null)
    return con1
  else if (con2 == null)
    return con2
  else
    return con3
}
else
{
  if(con3 != null)
    return con3
  if(con2 != null)
    return con2
  else
    return con1
}

无论如何，这种类型的语句是否可以简化为一个 if？

抱歉，如果我的问题真的很愚蠢/迟钝，我可能在这方面有点缺乏，特别是考虑到我在这里问的最后一个问题：/

无论如何，感谢您花时间阅读本文：）

4

4 回答 4

2

您可以引入一种新方法，该方法实际上完成了从一个移动到另一个的工作，并根据通用功能来表达另外两个。
拾取 = 从进入 -> 玩家
掉落 = 从玩家移动 -> 离开

public void pickUp(Container in)
{
    moveContainer(in, playerContainer);
}

public void dropContainer (Container out)
{
   moveContainer(playerContainer, out);
}

public void moveContainer(Container from, Container to) {
    if (to.returnSomething() == null) {
        to.setSomething(from.returnSomething());
        from.setSomething(null);
    }
}
于 2013-04-28T09:00:37.237 回答
0

如果可能的话，我将处理这个问题，我想以这种方式使用的每个类都实现相同的接口。例如，我将创建 PlayerContainer 类，实现一个包含 returnSomething 和 setSomething 方法的新 Doable 接口。然后，该方法将采用 Doable 类型的两个参数，每个对象一个工作宽度，结果是：

public interface Doable {
    Object returnSomething();
    setSomething(Object);
}

class MyClass {
    public void pickUp(Doable one, Doable two) {
        if(two.returnSomething() == null) {
            two.setSomething(one.returnSomething());
            one.setSomething(null);
        }
    }
}

编辑：请注意，returnSomething 的返回类型和 setSomething 的参数应调整为他们实际使用的类型。

当然，这可以应用于大部分代码。

如果您没有实现接口所需的类的代码，您可以扩展它们并让子类实现接口。

于 2013-04-28T08:51:40.337 回答
0

首先，您应该清楚地定义每个函数的作用。您的代码重复的根本原因可能是开发人员需要该功能，然后在不知道已经实现的确切功能的情况下实现它。为了防止这种情况发生，开发人员应该知道在哪里寻找该功能。

我强烈建议您阅读单一职责原则。如果不使用面向对象的原则，问题很可能会再次出现。

对于第二种情况，我建议尽可能合并条件。但这在很大程度上取决于您的条件。

于 2013-04-28T08:55:08.227 回答
0

对于第二部分 Dev Blanked 已经建议你可以做这样的事情。但这增加了额外的空间和时间复杂度。

private Object getMatch(Object obj1, Object obj2, Object obj3, boolean reverse) {
    List<Object> availableObjects = new ArrayList<Object>();
    availableObjects.add(obj1);
    availableObjects.add(obj2);
    availableObjects.add(obj3);
    int size = availableObjects.size();
    for (int i = 0 ; i < size ; i++) {
        Object nxtObject = reverse ? availableObjects.get(size - i -1) :  availableObjects.get(i);
        if (nxtObject != null) {
            return nxtObject;
        }
    }
    return null;
}
于 2013-04-28T09:52:59.813 回答