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

Question

What are the pros/cons of using the abstract class constructor vs. an abstract method for passing final data to an abstract class?

Pass via constructor:

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

Pass via abstract method:

public abstract class MyAbstractClass<T> {
  abstract String getType();

  abstract T getFactoryFn(String value);

  public T doSomething(String value) { ... }
}

I'm aware that the abstract methods can potentially be misused, because it doesn't enforce to always return the same value.

But apart from that, is it just a matter of personal preference, or are there any real (dis)advantages for using one over the other?

Answer 1

I hope I am understanding your question correctly..

Usually, when a property of a class is always held in a field, it is more concise to use an abstract constructor. For example, consider the two following scenarios....

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

Scenario 1 is shorter since the getter logic for field only needs to be specified once. Whereas in scenario 2, the getter logic must be overridden by both subclasses. I find scenario 2 to be redundant... why write the same code twice when you can use java inheritance to your advantage.

As a final note, I usually don't hold functions in fields unless totally necessary. Whenever you have a function in a field, it's usually a sign that an abstract function can be applied.

Here is your original code with my advice applied...

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

Hope this helped!