如何在中间添加抽象类并使用Java调用函数？

Question

I have the following structure:

public abstract class BaseCall<T> implements Callable<T> {

    public abstract T innerCall();

    protected Structure getProxy() {
       return SomeStructure;
    }
}

And at least 4 classes that look like that:

public class GetXCall extends BaseCall<Set<String>> {

    private final Credentials credentials;

    public GetXCall (Credentials credentials) {
        this.credentials = credentials;
    }

    @Override
    public Set<String> innerCall() {
        return getProxy().getXfromVC(credentials);
    }

}

public class GetYCall extends BaseCall<Set<String>> {

    private final Credentials credentials;

    public GetYCall (Credentials credentials) {
        this.credentials = credentials;
    }

    @Override
    public Set<String> innerCall() {
        return getProxy().getYfromVC(credentials);
    }
}

I'm trying to figure out how to make it prettier and add another abstract class in the middle so I can just pass the function getYfromVC or getXfromVC and the abstract class will call something like :

getProxy()._____(credentials)

This is what I tried but it doesn't seem to work as I can't use run inside

public abstract class RunVcTask<T> extends BaseCall<T> {

    private final Credentials credentials;

    public RunVcTask(Credentials credentials)    {
        this.credentials = credentials;
    }

    public abstract T run();

    @Override
    public T innerCall() {
        return getProxy().run(credentials); //HERE the run can't work
    }
}

As InnerCall not always uses credentials, I can't change it to abstract innerCall(Credentials c)

can someone advise if there is a nice way to do it? (I'm currently using java 7)

Answer 1

If you stick to inheritance, there is no simplification possible beyond

public abstract class BaseCall<T> implements Callable<T> {

    public abstract T innerCall();

    protected Structure getProxy() {
       return SomeStructure;
    }
}
public abstract class RunVcTask<T> extends BaseCall<T> {

    private final Credentials credentials;

    public RunVcTask(Credentials credentials) {
        this.credentials = credentials;
    }

    public abstract T actualOp(Structure proxy, Credentials credentials);

    @Override
    public T innerCall() {
        return actualOp(getProxy(), credentials);
    }
}

public class GetXCall extends RunVcTask<Set<String>> {
    public GetXCall(Credentials credentials) {
        super(credentials);
    }

    @Override
    public Set<String> actualOp(Structure proxy, Credentials credentials) {
        return proxy.getXfromVC(credentials);
    }
}
public class GetYCall extends RunVcTask<Set<String>> {
    public GetYCall(Credentials credentials) {
        super(credentials);
    }

    @Override
    public Set<String> actualOp(Structure proxy, Credentials credentials) {
        return proxy.getXfromVC(credentials);
    }
}

A better approach is using delegation :

public class RunVcTask<T> extends BaseCall<T> {
    interface ActualTask<T> {
        T actualOp(Structure proxy, Credentials credentials);
    }
    enum BuiltIn implements ActualTask<Set<String>> {
        GetX {
            public Set<String> actualOp(Structure proxy, Credentials credentials) {
                return proxy.getXfromVC(credentials);
            }
        },
        GetY {
            public Set<String> actualOp(Structure proxy, Credentials credentials) {
                return proxy.getYfromVC(credentials);
            }
        },
    }

    private final Credentials credentials;
    private final ActualTask<T> delegate;

    public RunVcTask(Credentials credentials, ActualTask<T> task) {
        this.credentials = credentials;
        this.delegate = task;
    }

    @Override
    public T innerCall() {
        return delegate.actualOp(getProxy(), credentials);
    }
}

Here, no special subclass for GetX , GetY , etc is needed, you can instantiate such a call via

BaseCall<Set<String>> getXInstance = new RunVcTask<>(credentials, RunVcTask.BuiltIn.GetX);
BaseCall<Set<String>> getYInstance = new RunVcTask<>(credentials, RunVcTask.BuiltIn.GetY);

so the specialization code of a particular function reduces to the four lines within the BuiltIn enum . Only actions with the same return type can be aggregated within such an enum , so you would have to use multiple enum s for different types (they don't need to be nested within RunVcTask ) or use anonymous inner classes instead, which is only slightly bigger:

BaseCall<Set<String>> getXInstance = new RunVcTask<>(credentials,
    new RunVcTask.ActualTask<Set<String>>() {
        public Set<String> actualOp(Structure proxy, Credentials credentials) {
            return proxy.getXfromVC(credentials);
        }
    });
BaseCall<Set<String>> getYInstance = new RunVcTask<>(credentials,
    new RunVcTask.ActualTask<Set<String>>() {
        public Set<String> actualOp(Structure proxy, Credentials credentials) {
            return proxy.getYfromVC(credentials);
        }
    });

You could also use anonymous inner classes of RunVcTask in the inheritance example, shortening the code to a similar degree, but the delegation approach also provides you with a road map to Java 8, once you are able to switch:

BaseCall<Set<String>> getXInstance = new RunVcTask<>(credentials, Structure::getXfromVC);
BaseCall<Set<String>> getYInstance = new RunVcTask<>(credentials, Structure::getYfromVC);