抽象类构造函数参数与最终数据的抽象方法

Question

使用抽象类构造函数与将最终数据传递给抽象类的抽象方法的利弊是什么？

通过构造函数传递：

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) { ... }
}

我知道抽象方法可能被滥用，因为它并不强制总是返回相同的值。

但是除此之外，这仅仅是个人喜好问题，还是使用一个相对于另一个有任何真正的（不利）优势？

Answer 1

希望我能正确理解你的问题。

通常，当类的属性始终保存在字段中时，使用抽象构造函数会更加简洁。例如，考虑以下两种情况....

// 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...
}