Is there some template or something to implement iterface methods with accessing to wrapped member?
For example, suppose I have
public class MyClass implements List<Something> {
private final List<Something> core;
...
}
and now I want to implement List<Something> by passing calls to wrapped like
@Override
public int size() {
return core.size();
}
and so on.
I'll say a bit more about how the "Generate Delegate Methods" refactoring works to create a forwarding class like you describe.
You make a new class which optionally implements the interface, and provide it with a field with the type you want to delgate, e.g.:
public class NewClass implements ThatInterface {
private final ThatInterface delegate;
public MyClass(ThatInterface delegate) {
this.delegate = delegate();
}
}
Then you apply the eclipse refactoring. (Cmd-3 deleg... is an easy way to access it.) Select the checkbox for the new field. All of its methods will be added as delegates.
(There is a bug, I think, in the refactoring for Eclipse oxygen, where it will copy the default keyword from methods with that keyword on the interface. You may need to delete that keyword.)
So for a delegate to a List the refactoring produced:
public class NewClass {
private final List<String> delegate;
public NewClass(List<String> delegate) {
this.delegate = delegate;
}
public void forEach(Consumer<? super String> action) {
delegate.forEach(action);
}
public int size() {
return delegate.size();
}
public boolean isEmpty() {
return delegate.isEmpty();
}
public boolean contains(Object o) {
return delegate.contains(o);
}
and so on...
