如何减少子类中方法签名中的变量数量?Java重构

Question

我有一个抽象类A来完成主要工作，还有两个类B和C来扩展类A并实现方法doTheFinalMove((。

public abstract class A {
public Object aMethod() {
Integer var1 = calculateVar1();
String var2 = calculateVar2();
Boolean var3 = calculateVar3();
Object var4 = calculateVar4();
Object var5 = calculateVar5();
return doTheFinalMove(var1,
var2,
var3,
var4,
var5
);
}
protected abstract Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5);
}
public class B extends A {
@Override
protected Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5) {
return doMyStaff(
var1,
var2,
var3,
var4,
var5);
}
}
public class C extends A {
@Override
protected Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5) {
return doMyStaff(var1, var2);
}
}

因此，类C与类B不同，只需要五个变量中的两个来完成它的工作，但为了保持类A的继承性，我应该在A和C类中使用doTheFinalMove()签名中的所有五个变量。我想以C类在签名中只保留它真正需要的变量(var1和var2(的方式重构这段代码。我想避免使用Object... args之类的东西，所以我想把这些变量包装到一个Object中(我指的是一些继承，比如BasicParams和ExtendedParams(，然后使用AbstractFactory或类似的smth，但我不知道如何正确地做到这一点。如果有任何建议，我将不胜感激。

Answer 1

根据建议，您可以在抽象中重载多种形式的方法。在抽象中，从更具体的调用到不太具体的调用，然后只覆盖所需的方法。

public abstract class A {
public Object aMethod() {
Integer var1 = calculateVar1();
String var2 = calculateVar2();
Boolean var3 = calculateVar3();
Object var4 = calculateVar4();
Object var5 = calculateVar5();
return doTheFinalMove(var1,
var2,
var3,
var4,
var5
);
}    
protected Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5){
return doTheFinalMove(var1,var2);
}
protected Object doTheFinalMove(Integer var1,
String var2){
throw new UnsupportedOperationException("You have to override one of the doTheFinalMove method");
}

}

public class B extends A {
@Override
protected Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5) {
return doMyStaff(
var1,
var2,
var3,
var4,
var5);
}
}
public class C extends A {
@Override
protected Object doTheFinalMove(Integer var1,
String var2) {
return doMyStaff(var1, var2);
}
}

如果你想避免异常并强制编译器实现该方法，你可以添加抽象级别，但只有当你有超过1个实现imho(即超过B和C(时，复杂性增加才是有用的

多了一个抽象的变体：

public abstract class A {
public Object aMethod() {
Integer var1 = calculateVar1();
String var2 = calculateVar2();
Boolean var3 = calculateVar3();
Object var4 = calculateVar4();
Object var5 = calculateVar5();
return doTheFinalMove(var1,
var2,
var3,
var4,
var5
);
}    
protected Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5);

}

公共抽象类A2扩展了A｛

protected Object doTheFinalMove(Integer var1,
String var2,
Boolean var3,
Object var4,
Object var5){
return doTheFinalMove(var1,var2);
}
protected abstract Object doTheFinalMove(Integer var1,
String var2);
}
// Then C should extends A2 instead of A

Answer 2

想到的最简单的事情就是重载函数：

public Object doTheFinalMove(var1, var2) {
return doTheFinalMove(var1, null, null, var2, null);
}

其中，您放置的值对您的实现是正确的，而不是null。

我把它列为公共方法，因为受保护的方法通常只供内部使用，而公共方法则供通用。

此外，您不能直接更改重写的方法，因为它可能可以在父类内部或其他应用程序中使用。这就是为什么只有当您使用完全相同的格式(并且可能在主类中按预期行为(时，重写才有效。