Question

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

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

从上面的示例中可以看出，这两个方法基本上是完全相同的，除了测试哪个容器为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
}

无论如何，这种类型的陈述是否会减少为1？

对不起，如果我的问题真的是无趣/迟钝，我可能会对这方面有点缺乏，特别考虑我在这里问的最后一个问题：/

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

Answer 1

您可以引入一种新方法，该方法实际上可以完成从一个方法移动到另一个方面的工作，并根据常用功能表达另外两个方法。
拾取=从 - 移动 - ＆gt;球员
drop =从播放器移动 - ＆gt;出

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

Answer 2

我会处理这个问题，如果可能的话，我想以这种方式使用的每个类都实现相同的接口。例如，我将创建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的参数应调整为实际使用的值。

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

如果你没有你需要实现接口的类的代码，你可以扩展它们并使子类实现接口。

Answer 3

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

我强烈建议您阅读Single Responsibility Principle。如果不使用面向对象的原则，问题很可能会再次发生。

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

Answer 4

对于第二部分，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;
}

代码重复，在与多个对象相反的方法中使用类似的代码

4 个答案: