6

背景

这个问题适用于 Java 和 Android 开发人员。

在 Android 上，我希望有一个函数返回从View扩展并实现Checkable的东西，两者都是 Android API 的一部分。

我试过的

在这里和互联网上的其他地方搜索了一下后，我找到了这个解决方案：

private <T extends View & Checkable> T get() {
    return (T) mView;
}

请注意，mView 是扩展 View 的任何类型（并且有很多），但我保证它实现了 Checkable 因为只有那些类型才能存在。

这显示了 "Type safety: Unchecked cast from View to T" 的警告，但这不是问题。问题是我不能正确使用这个方法，例如：

View v=get(); //this works fine
Checkable c=get(); // this shows error

第二行显示错误：

绑定不匹配：类型 ... 的泛型方法 get() 不适用于参数 ()。推断类型 Checkable&View 不是有界参数的有效替代品

所以我尝试使用 "," 而不是 "&" 。同样的错误。

但是，当我使用 "," 并反转 order 时，我收到警告 "The type parameter View is hidden type View" ，并且两条线都可以正常工作。

这是代码：

private <T extends Checkable, View> T get() {
    return null;
}

private void foo() {
    final View v = get(); // this works fine
    final Checkable c = get();// this works fine too
}

但是，当我将返回的类型发送给其他函数时，它们不会将类型本身作为扩展类和接口的东西，并且需要一直转换（到 View）。

问题

正确的方法是什么？

如果我展示的最后一种方式是正确的，为什么我会收到警告？如果总是有最多一个类要扩展，为什么顺序很重要？

4

3 回答 3

5

在我深入研究泛型之前......你为什么不直接引入 aCheckableView并返回该类型？

public class CheckableView extends View implements Checkable {
}


 private CheckableView getCheckableView() {
     return checkableView;
 }

如果它View是一个接口，它可以工作：

interface View {}
interface Checkable {}
class CheckableView implements Checkable, View {}

public class Main {

    private static CheckableView checkableView;

    private static  <T extends View & Checkable> T get() {
        return (T) checkableView;
    }

    public static void main(String[] args) {
        View view = Main.get();
        Checkable checkable = Main.get();
    }
}

我认为理解泛型的问题在于，T extends View & Checkable在实际情况下并不意味着您可以返回任何扩展View和实现的类型Checkable。

这意味着客户端可以将返回的类型转换为扩展View和实现的任何类型Checkable。

客户可以这样做：

class CheckableView extends View implements Checkable {}
class OtherView extends View implements Checkable {}

private static  <T extends View & Checkable> T get() {
    return (T) checkableView;
}

OtherView otherView = Main.get();
CheckableView checkableView = Main.get();

但是您现在想对实施做什么？

 private <T extends View & Checkable> T get() {
      return ...;
 }

这个方法应该返回什么？如果您返回 a CheckableView，编译器会说您必须将其强制转换为T，因为客户端可能会将其强制转换为任何类型T。但这也意味着您将收到一个从 CheckableView 到 T 的 Unchecked cast警告，因为如果客户端将其转换为除 之外的任何其他类型CheckableView，例如OhterView，您将收到一个ClassCastException.

由于get方法实现者无法知道客户端会将其转换为哪种类型，因此他无法确定返回哪个对象。

如果实现者返回一个特定的对象（例如CheckableView），那么客户端只能将其转换为该类型。那么为什么实现者不更改方法签名以准确返回该类型呢？.... 或者为这种情况引入一个特殊的类型或接口？

也许这是您的解决方案

创建该get方法将返回的接口，例如

public interface CheckableView {
}

更改 get 方法以返回一个CheckableView

private CheckableView get() {
}

编写一个适配器，使您View实现的 sCheckable适应CheckableView

public class CheckableViewAdapter<T extends View & Checkable> implements CheckableView {

    private T checkableView;

    public  CheckableViewAdapter(T checkableView) {
        this.checkableView = checkableView;
    }
}

CheckableView现在您可以为每个View实现的 a 创建实例Checkable

class SomeView extends View implements Checkable {}

SomeView someView = ...;
CheckableView checkableView = new CheckableViewAdapter<SomeView>(someView);

将方法的客户端get需要的方法添加到CheckableView接口中，并在CheckableViewAdapter.

public interface CheckableView {
     public void bringToFront();
}

public class CheckableViewAdapter<T extends View & Checkable> implements CheckableView {

    private T checkableView;

    public  CheckableViewAdapter(T checkableView) {
        this.checkableView = checkableView;
    }

        public void bringToFront(){
            checkableView.bringToFront();
        }
}

要不就

public interface CheckableView {
     public View getView();
     public Checkable getCheckable();
}
于 2013-10-30T09:15:12.483 回答
3

您会收到错误，因为在第二个调用站点为参数推断的类型T，即Checkable c = get()，只是Checkable，因为错误消息正确报告。

如果您强制调用使用兼容的类型View & Checkable，它将编译。为此，您必须明确提供类型，例如：

private <T extends View & Checkable> T get() {
   return (T) mView;
}

private <T extends View & Checkable> void useGeneric() {
    View v = this.get(); // no need for an explicit type
    Checkable c = this.<T>get(); // an explicit type needed
    T t = this.get(); // best way
}

private void useSpecific() {
    class Specific extends View implements Checkable {}
    Checkable c = this.<Specific>get(); // risk of ClassCastException
    Specific s = this.get(); // best way; risk of ClassCastException
}

事实上，在分配给一个类的情况下，它不需要显式类型，而在接口情况下它需要一个，在我看来，它就像一个类型推断算法工件，一个类/接口不对称。

于 2016-08-24T14:06:29.743 回答
0

问题是你有一个逗号而不是一个＆符号！这个定义：

private <T extends Checkable, View> T get() {

不是路口！相反，它声明了 2 种泛型类型，一种是 named T，另一种是 named View，这在您的类中没有使用 - 它与编码相同：

private <T extends Checkable, V> T get() {

因此，将其更改为：

private <T extends View & Checkable> T get() {

注意泛型交集，类必须在接口之前。

于 2013-10-30T09:26:29.613 回答