Java 泛型名称冲突，方法未正确覆盖

Question

我已经看到了不同的问题，但我仍然觉得这个话题很混乱。

我想做的就是有一个实现接口的抽象类，并有一个扩展这个抽象类的类，这样hard类需要实现getKommune()和setKommune(Kommune kommune)，而不是其他方法，因为那是在抽象类中。

我有如下界面。

public interface KommuneFilter {

    <E extends AbstractKommune<?>> void addKommuneFromCurrentUser(E e);

    Kommune getKommune();

    void setKommune(Kommune kommune);
}

还有这个抽象类

public abstract class AbstractKommune<E extends AbstractKommune<?>> implements KommuneFilter {
    @PrePersist
    void addKommuneFromCurrentUser(E e) {
            Kommune k = e.getKommune();
    }
}

我想这样使用它

    public class Person extends AbstractKommune<Person> {
        private Kommune kommune;             
        public void setKommune(Kommune kommune) {this.kommune=kommune;}
        public Kommune getKommune() {return kommune;}
    }

但是，我明白了

名称冲突： 的方法具有相同的擦除类型但不覆盖它

为什么它没有被正确覆盖？

更新

感谢@Bozho，解决方案是这样的：

public interface KommuneFilter<E extends AbstractKommune<?>> {
    public void addKommuneFromCurrentUser(E e);
}

public abstract class AbstractKommune<E extends AbstractKommune<?>> implements KommuneFilter<E> 

public class Person extends AbstractKommune<Person>

Answer 1

我建议使接口通用，而不仅仅是它的方法：

interface KommuneFilter<E extends AbstractKommune<?>> { .. }

然后

public abstract class AbstractKommune<E extends AbstractKommune<?>> 
     implements KommuneFilter<E> 

Answer 2

它是名称冲突而不是覆盖的原因是因为它不是。接口指定的方法是泛型方法；您的抽象类尝试覆盖它不是。

重现您的问题的更简洁的代码如下：

interface I {
    <E> void foo(E e);
}

class C<E> implements I {
    public void foo(E e) { // name clash at compile time!
    }
}

这里的问题是interface I 指定实现者必须提供一个泛型方法<E>foo（它可以是<Integer>foo、<Boolean>foo 等），但是说C<String> 真的只有@987654327 @。

解决此问题的一种方法是使C.foo 成为泛型方法，正确地将@Override 设为interface I 的泛型方法：

interface I {
    <E> void foo(E e);
}

class C<E> implements I {
    @Override public <T> void foo(T t) {
    }

    public static void main(String args[]) {
        C<String> o = new C<String>();
        o.<Integer>foo(0);
        o.<Boolean>foo(false);
    }
}

你可以在上面的代码中看到它做了什么：你有一个泛型类型C<E> 和一个泛型方法<T>foo（你可以使用E 代替T，但这不会改变任何东西 - - 它仍然是一个具有自己类型参数的泛型方法）。

现在C<String> 也有<Integer>foo 等，由interface I 指定。

如果这不是您需要的东西，那么您可能希望将interface I<E> 改为通用：

interface I<E> {
    void foo(E e);
}

class C<E> implements I<E> {
    @Override public void foo(E e) {
    }
}

现在类型和方法共享相同的类型参数（例如，I<Boolean> 仅具有 foo(Boolean)，C<String> 仅具有 foo(String)）这很可能是您最初的意图。