使用抽象类构造函数与抽象方法将最终数据传递给抽象类有何优缺点?
通过构造函数传递:
public abstract class MyAbstractClass<T> {
private final String type;
private final Function<String, T> factoryFn;
protected MyAbstractClass(String type, Function<String, T> factoryFn) {
this.type = type;
this.factoryFn = factoryFn;
}
public T doSomething(String value) { ... }
}
通过抽象方法传递:
public abstract class MyAbstractClass<T> {
abstract String getType();
abstract T getFactoryFn(String value);
public T doSomething(String value) { ... }
}
我知道抽象方法可能会被滥用,因为它并不强制始终返回相同的值。
但除此之外,这只是个人喜好问题,还是使用其中一种相对于另一种有任何真正的(缺点)优势?
最佳答案
我希望我正确理解你的问题..
通常,当类的属性始终保存在字段中时,使用抽象构造函数会更简洁。例如,考虑以下两种情况......
// Scenario 1:
abstract class AClass {
final int field;
public AClass(int f) {
field = f;
}
public int getField() {
return field;
}
}
class Class1 extends AClass {
public Class1(int f) {
super(f);
}
// Class Unique Code...
}
class Class2 extends AClass {
public Class2(int f) {
super(f);
}
// Class Unique Code...
}
// Scenario 2:
abstract class AClass {
public abstract int getField();
}
class Class1 extends AClass {
final int field;
public Class1(int f) {
field = f;
}
@Override
public int getField() {
return field;
}
// Class Unique Code...
}
class Class2 extends AClass {
final int field;
public Class2(int f) {
field = f;
}
@Override
public int getField() {
return field;
}
// Class Unique Code...
}
场景 1 较短,因为 field
的 getter 逻辑只需指定一次。而在场景 2 中,getter 逻辑必须被两个子类覆盖。我发现场景 2 是多余的...当您可以使用 java 继承来发挥您的优势时,为什么要编写两次相同的代码呢?
最后一点,除非完全必要,否则我通常不会在字段中保留函数。每当某个字段中有一个函数时,通常就表明可以应用抽象函数。
这是您应用了我的建议的原始代码...
public abstract class MyAbstractClass<T> {
private final String type;
protected MyAbstractClass(String t) {
type = t;
}
protected abstract T applyFactoryFunction(String value);
public T doSomething(String value) { ... }
}
希望这有帮助!
关于java - 抽象类构造函数参数与最终数据的抽象方法,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/61535194/