重写 Java 泛型方法

Question

我想创建一个接口，用于将对象复制到同一类的目标对象。 简单的方法是使用强制转换：

import org.junit.Test;
import org.junit.internal.runners.JUnit4ClassRunner;
import org.junit.runner.RunWith;

@RunWith(JUnit4ClassRunner.class)
public class TestGenerics {
public static interface Copyable {
    public void copy(Copyable c);
}

public static class A implements Copyable {
    private String aField = "--A--";
    protected void innerCopy(Copyable c) {
        A a = (A)c;
        System.out.println(a.aField);
    }
    public void copy(Copyable c) {
        innerCopy(c);
    }
}

public static class B extends A {
    private String bField = "--B--";
    protected void innerCopy(Copyable c) {
        B b = (B)c;
        super.innerCopy(b);
        System.out.println(b.bField);
    }
}

@Test
public void testCopy() {
    Copyable b1 = new B();
    Copyable b2 = new B();
    b1.copy(b2);
}
}

但我也找到了一种可以使用泛型来完成的方法：

import org.junit.Test;
import org.junit.internal.runners.JUnit4ClassRunner;
import org.junit.runner.RunWith;

@RunWith(JUnit4ClassRunner.class)
public class TestGenerics {
    public static interface Copyable<T> {
        public void copy(T t);
    }

    public static class A<T extends A<?>> implements Copyable<T> {
        private String a = "--A--";
        public void copy(T t) {
            System.out.println(t.a);
        }
    }

    public static class B<T extends B<?>> extends A<T> {
        private String b = "--B--";
        public void copy(T t) {
            super.copy(t);
            System.out.println(t.b);
        }
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testCopy() {
        Copyable b1 = new B();
        Copyable b2 = new B();
        b1.copy(b2);
    }
}

虽然我发现摆脱警告的唯一方法是注释。 而且感觉好像有什么不对劲。 那么出了什么问题呢？ 我可以接受问题的根源是有问题的。 因此，欢迎任何形式的澄清。

Answer 1

我已经学会了 Scala，现在我知道我两年前想要的东西可以通过逆变类型参数来实现，而 Scala 的类型系统：

trait CopyableTo[-T] {
  def copyTo(t: T)
}

class A(private var a: Int) extends CopyableTo[A] {
  override def copyTo(t: A) {
    println("A:copy")
    t.a = this.a
  }
}

class B(private var a: Int, private var b: Int) extends A(a) with CopyableTo[B] {
  def copyTo(t: B) {
    println("B:copy")
    super.copyTo(t)
    t.b = this.b
  }
}

@Test
def zzz {
  val b1 = new B(1, 2)
  val a1 = new A(3)
  val b2 = new B(4, 5)
  b1.copyTo(a1)
  a1.copyTo(b1)
  b1.copyTo(b2)
}

Java 类型系统对此太弱了。

Answer 2

这是第二种方法的最佳代码。 它编译时没有任何警告。

import static org.junit.Assert.fail;

import org.junit.Test;
import org.junit.internal.runners.JUnit4ClassRunner;
import org.junit.runner.RunWith;

@RunWith(JUnit4ClassRunner.class)
public class TestGenerics {
    public static interface Copyable<T> {
        public void copy(T t);
    }

    public static class A<T extends A<T>> implements Copyable<T> {
        private String a = "--A--";
        public void copy(T t) {
            System.out.println(t.a);
        }
        @SuppressWarnings("unchecked")
        public static Copyable<Object> getInstance() {
            return new A();
        }

    }

    public static class B<T extends B<T>> extends A<T> {
        private String b = "--B--";
        public void copy(T t) {
            super.copy(t);
            System.out.println(t.b);
        }
        @SuppressWarnings("unchecked")
        public static Copyable<Object> getInstance() {
            return new B();
        }
    }


    @Test
    public void testCopy() {
        Copyable<Object> b1 = B.getInstance();
        Copyable<Object> b2 = B.getInstance();
        Copyable<Object> a = A.getInstance();
        b1.copy(b2); // this works as intended
        try {
            b1.copy(a); // this throws ClassCastException
            fail();
        } catch (ClassCastException cce) {
        }
    }
}

而且我在反射的帮助下弄清楚了这个程序中发生的所有事情：

       for (Method method : A.class.getMethods()) {
               if (method.getName().equals("copy")) {
                       System.out.println(method.toString());
               }

       }
       for (Method method : B.class.getMethods()) {
               if (method.getName().equals("copy")) {
                       System.out.println(method.toString());
               }

       }

这是输出：

public void com.sbp.core.TestGenerics$A.copy(com.sbp.core.TestGenerics$A)
public void com.sbp.core.TestGenerics$A.copy(java.lang.Object)

public void com.sbp.core.TestGenerics$B.copy(com.sbp.core.TestGenerics$B)
public void com.sbp.core.TestGenerics$B.copy(com.sbp.core.TestGenerics$A)
public void com.sbp.core.TestGenerics$A.copy(java.lang.Object)

这意味着：

1. A和B中的copy(...)方法使编译器生成“桥梁” -
   每种方法有 2 种不同的方法，其中一种方法的参数类型来自
   祖先（具体化 T 从 Copyable 变为 Object，具体化“T 扩展
   A”从 A 变成 A)，这就是为什么它是覆盖而不是过载，
   另一个具有用于定义类的具体化参数类型。 第一的
   方法（带有自动生成的主体）向下转型其参数以调用
   第二（他们称之为桥梁）。 由于这种沮丧，我们得到
   如果我们调用 b1.copy(a)，则会在运行时出现 ClassCastException。

2. 对于我来说，直接类型转换似乎更干净、更好的工具
   问题和泛型最好用于其直接目的 -
   强制编译时类型检查。

Answer 3

我一直在试图找出一种方法来消除第一种方法中的警告，但我想不出任何有效的方法。 即便如此，我认为第一种方法是两害相权取其轻。 不安全的强制转换比需要为类提供如此复杂的 api 更好。

一种完全独立的方法是重写 Object.clone() 并实现 Cloneable。

Answer 4

在 testCopy 中，警告之一是因为您正在实例化 Copyable 的“原始类型”，而不是某些具体的 Copyable。 一旦实例化 Copyable，它就只能应用于 T（包括 T 的子类型）。 为了用正式类型实例化，需要稍微更改类定义：

public static class A<T extends A> implements Copyable<T>
public static class B<T extends B> extends A<T>

下一个问题是 Copyable 。 只能传递 B 的编译时类型（基于 Copyable 的定义）。 上面的 testCopy() 向它传递了一个 Copyable 的编译时类型。 以下是一些可行的示例，并附有简要说明：

public void testExamples()
{
    // implementation of A that applies to A and subtypes
    Copyable<A> aCopier = new A<A>();

    // implementation of B that applies to B and subtypes
    Copyable<B> bCopier = new B<B>();

    // implementation of A that applies to B and subtypes
    Copyable<B> bCopier2 = new A<B>();
}

Answer 5

假设您不想进一步子类化，您只需要：

public static /*final*/ class AClass implements Copyable<AClass> {

对于抽象类，您可以执行“枚举”操作：

public static abstract class AClass<T extends AClass<T>> implements Copyable<T> {

Answer 6

您的接口定义：

public interface Copyable<T extends Copyable<T>> {
    void copy(T copyFrom);
}

您的实现：

public class Example implements Copyable<Example> {
    private Object data;
    void copy(Example copyFrom) {
        data = copyFrom.data;
    }
    //nontrivial stuff
}

这应该处理您的警告。