主页 / 问题 / 1599362
Accepted
Perfect Voyage
Asked:2024-11-10 17:07:44 +0000 UTC2024-11-10 17:07:44 +0000 UTC

接口方法参数中未定义的类

  • 772
public interface ClassWithList {
    public void clearList();
    public void tryAdd(Class<T> b);
    public void update(Class<T> c);
}

扩展时，我指定了特定的类，并且发生错误。

public class Test implements ClassWithList {
    @Override
    public void clearList() {}
    
    @Override
    public void tryAdd(Test b) {
        // Error
    }
    
    @Override
    public void update(Test c) {
        // Error
    }
}

Java可以这样扩展接口吗？
告诉我我做错了什么。谢谢你！

java

1 个回答

  1. Best Answer

    由于所提供的代码存在与T接口中未定义类型相关的编译错误ClassWithList，因此我们首先需要解决此问题。

    cannot find symbol  
public void tryAdd(Class<T> b);
                         ^
symbol:   class T
location: interface ClassWithList

error: cannot find symbol
public void update(Class<T> c);
                         ^

    有两种方法可以做到这一点：

    1. 声明接口ClassWithList泛型
      在这种情况下tryAdd，方法的参数update将使用相同的类型。
      同时，在方法中tryAdd，update参数必须是类型T，而不是类型Class<T>，如果在实现该接口的类中Test，所提到的方法中的参数必须是类型Test：
    public interface ClassWithList<T> {
    public void clearList();
    public void tryAdd(T b);
    public void update(T c);
}

    然后，在声明类时，Test应该在尖括号中指明参数类的类型：

    public class Test implements ClassWithList<Test> {
    @Override public void clearList() {}
    @Override public void tryAdd(Test b) {}
    @Override public void update(Test c) {}
}

    这种实现是最自然的；可以将类的实例传递给指定的方法Test：

    Test t = new Test();
t.tryAdd(t);

    1.a) 如果上述方法中的参数出于任何原因必须保留类型Class<T>，则需要更改实现以匹配接口。

    public interface ClassWithListA<T> {
    public void clearList();
    public void tryAdd(Class<T> b);
    public void update(Class<T> c);
}

public class TestA implements ClassWithListA<TestA> {
    @Override public void clearList() {}
    @Override public void tryAdd(Class<TestA> b) {}
    @Override public void update(Class<TestA> c) {}
}

    在此实现中调用方法时，只能传递编译时已知的类型，即TestA.class:

    ClassWithListA t2 = new TestA();
// ок
t2.update(TestA.class);
// ошибка
t2.update(t2.getClass()); 
// Class cannot be converted to Class
// where CAP#1 is a fresh type-variable:
//   CAP#1 extends TestA from capture of ? extends TestA
    1. 将每个方法声明为tryAdd通用方法update
    public interface ClassWithListB {
    public void clearList();
    public <T> void tryAdd(Class<T> b);
    public <T> void update(Class<T> c);
}

    由于该接口的声明没有指定类型参数，因此它本身不是泛型的，因此泛型方法也会保留在实现中：

    class TestB implements ClassWithListB {
    @Override public void clearList() {}
    @Override public <T> void tryAdd(Class<T> b) {}
    @Override public <T> void update(Class<T> c) {}
}

    也就是说，可以将任何类的对象传输给它们：

    ClassWithListB t3 = new TestB();

t3.update(ClassWithListA.class);
t3.tryAdd("abcd".getClass());
t3.update(t2.getClass());
t3.tryAdd(t3.getClass());

    是否需要实施此类措施的问题仍然悬而未决。

    • 1

相关问题