避免泛型类型形式的Foo <ActualType延伸富<ActualType>>

Question

我经常发现自己想要写的形式

public class Foo<ActualType extends Foo<ActualType>> 

例如在这样的设置的通用类定义：

public interface ChangeHandler<SourceType> { 
    public void onChange(SourceType source); 
} 


public class Foo<ActualType extends Foo<ActualType>> { 

    private final List<ChangeHandler<ActualType>> handlers = new ArrayList<>(); 

    public void addChangeHandler(ChangeHandler<ActualType> handler) { 
     handlers.add(handler); 
    } 

    @SuppressWarnings("unchecked") 
    protected void reportChange() { 
     for (ChangeHandler<ActualType> handler: handlers) 
      handler.onChange((ActualType) this); 
    } 
} 


public class Bar extends Foo<Bar> { 
    // things happen in here that call super.reportChange(); 
} 


public static void main(String[] args) throws IOException { 

    Bar bar = new Bar(); 
    bar.addChangeHandler(new ChangeHandler<Bar>() { 

     @Override 
     public void onChange(Bar source) { 
      // Do something with the changed object 
     } 
    }); 
} 

这里的变化事件只是一个例子。当我想让超类为每个特定的子类提供“个性化”的功能时（不确定如何更好地描述这个更好......），这更多的是我遇到的一个普遍问题在“个性化”之上的事实是ChangeHandler被称为具有实际子类型的对象（Bar）而不是调用处理程序的超类的类型（Foo）。

不知何故这种方法对我来说似乎有点混乱。它实际上允许潜在的问题，因为没有什么能阻止我从那时候定义：

public class Baz extends Foo<Bar> { /* ... */ } 

是否有一个更清洁的替代？

的圣杯将是始终定义包含当前类的一些类型的参数，像this.getClass()静态版本，让我写这样的事情，而不是：

public class Foo { 

    private final List<ChangeHandler<this.Class>> handlers = new ArrayList<>(); 

    public void addChangeHandler(ChangeHandler<this.Class> handler) { 
     handlers.add(handler); 
    } 

    protected void reportChange() { 
     for (ChangeHandler<this.Class> handler: handlers) 
      handler.onChange(this); 
    } 
} 

凡this.Class会等于Bar，类型为Bar。

Answer 1

这是一个非常抽象的问题。在我看来，“如何使这个更清洁”的简短答案是：只在需要的地方使用泛型。

public class List<T extends List<T>> 

这是什么试图表达（取代）？一个只允许持有（T扩展）其他列表本身持有Ts（List）的列表，这是我们之前知道的列表，它只允许持有...等等。通告的种类，我不明白你会如何结束这样的事情？

public interface ChangeHandler<SourceType> { 
    public void onChange(SourceType source); 
} 

为什么你想在这里使用泛型？如果你想有一个可以处理多种资源类型的变更处理程序，那么你可以创建一个超类，所有的实际源代码都继承它，或者你创建一个由源代码实现的接口。就像那样，你可以精确地指定源代码暴露的内容。或者，源可以在通知时创建源对象而不是传递“this”（然后它更像是一条消息）。例如：

public interface ChangeHandler { 
    public void onChange(Source source); 
} 

public abstract class Source { 
    private List<ChangeHandler> handlers; 
    protected int nr; 
    public Source(int nr) { 
     this.nr = nr; 
    } 
    public abstract Something getSomething(); 
    public String toString() { 
     return "SRC" + nr; 
    } 
    ... 
    private notify(int index) { 
     handlers.get(i).onChange(this); 
    } 
} 

public class Foo extends Source { 
    public Foo(int nr) { 
     super(nr); 
    } 
    public String toString() { 
     return super.toString() + "Foo"; 
    } 
    public Something getSomething() { 
     return new Something(); 
    } 
} 

你永远不需要演员......或者你呢？我不确定我是否理解这个问题。

Answer 2

我会建议我们只需使用<This>来表示“自我类型”。不需要绑定，因为它看起来很复杂，不能传达意图，也无法强制约束。

public class Foo<This> { 

    private final List<ChangeHandler<This>> handlers = new ArrayList<>(); 

    public void addChangeHandler(ChangeHandler<This> handler) { 
     handlers.add(handler); 
    } 

    @SuppressWarnings("unchecked") 
    protected void reportChange() { 
     for (ChangeHandler<This> handler: handlers) 
      handler.onChange((This)this); 
    } 
} 

注意演员表(This)this。

也Java generics: Use this type as return type?