Java泛型可行与不可行的原理示例解析

public class TupleTest<T, R> {
    public final T t;
    public final R r;
    public TupleTest(T t, R r) {
        this.t = t;
        this.r = r;
    }
    public static <A, B> TupleTest<A, B> make(A a, B b) {
        return new TupleTest<>(a, b);
    }
    /**
     * 如果返回值声明里声明了泛型，那么在方法返回值 new 时就要有尖括号，不然会警告
     * jdk1.5中返回值声明时的泛型去掉，也会有编译警告
     *
     * @return tupleTest
     */
    public TupleTest<String, String> make() {
        return new TupleTest<>("a", "b");
    }
     public R getR() {
        return r;
    }
}

 public com.zoro.thinkinginjava.four.TupleTest<String, String> make() {
    return new com.zoro.thinkinginjava.four.TupleTest((T)"a", (R)"b");
  }

public class TupleMain {
    public static void main(String[] args) {
        TupleTest<Apple, Orange> tuple = new TupleTest<>(new Apple(), new Orange());
        Orange orange = tuple.getR();
    }
}

public class TupleMain {
  public static void main(String[] args) {
    TupleTest<Apple, Orange> tuple = new TupleTest(new Apple(), new Orange());
    Orange orange = (Orange)tuple.getR();
  }
}

public class EraseMain {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
//        list1 = list2; // 编译期是不同的
        System.out.println(list1.getClass().getName());
        System.out.println(list2.getClass().getName());
        // 运行期类型是相同的
        System.out.println(list1.getClass() == list2.getClass());
    }
}

public T getNewInstance() {
        // return new T();
        // Error:(12, 20) java: 意外的类型
        //  需要: 类
        //  找到:    类型参数T
        try {
            return t.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

public class EraseEntity<T> {
    Class<T> tClass;
    public EraseEntity(Class<T> tClass) {
        this.tClass = tClass;
    }
    public boolean instanceOf(Object t) {
//        return t instanceof T; // 这样就不可以了
        return tClass.isInstance(t); // 这样是可以的
    }
}

    public T[] createArray(){
        return (T[]) Array.newInstance(t,5);
    }

//        List<int> list2 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();

public class ImplTest extends AbstractA implements InterfaceA<Integer> {
//public class ImplTest extends AbstractA implements InterfaceA<String> {
// ImplTest类实现InterfaceA接口时声明的泛型参数是String,AbstractA实现InterfaceA时声明的泛型参数是 Integer,这时就不可以了，
// 如果可以会导致类型冲突,比如 get方法，在AbstractA中返回值是Integer,但是在ImplTest中就变成了String，无论重载或重写都不能解决这个问题
}
interface InterfaceA<T> {
    T get(T t);
}
abstract class AbstractA implements InterfaceA<Integer> {
    public Integer get(Integer integer) {
        return 0;
    }
}

public class OverLoadTest {
    public <T> void test(T t) { }
    // 因为T与R没有设置边界在运行时 T与R 都是类似Object，所以不能通过方法签名区分这两个方法
//    public <R> void test(R r) { }
    // 这样是可以的 因为R一定会是一个List的子类，List与Object（T）是有区别的，就可以通过方法签名区分了
    public <R extends List<?>> void test(R r) {    }
}

public class WildCardTest<T extends List<String> & Iterable<String> & InterfaceA<?>> {
    public void test(T t) {
        t.add("");  // List接口的方法
        t.iterator(); // Iterable接口的方法
        t.testMethod(); // InterfaceA方法
    }
}
interface InterfaceA<T>{
    //    void add(T t); // List接口也有同样方法签名的方法，所以在 同时将 List与InterfaceA设置为上边界时List与InterfaceA的泛型参数要兼容，否则也会出错
    void testMethod();
}

public class WildCardTest<T extends List<String> & Iterable<String> & InterfaceA<?>> {
    public static void main(String[] args) {
        List<InterfaceA<String>> list ;
        List<Impl> impls = new ArrayList<>();
//        list = impls;
        // 将 impls赋值给 list是不可以的，原因：
        // 1. 编译期 List<InterfaceA<String>> 与 List<Impl>是不同的且不能向上转型
        // 2. 一旦允许这样赋值，那么之后 的操作会出现类型问题，比如此例，将一个ArrayList<Impl> 赋值给 List<InterfaceA>变量list，
        // 那么之后可以向list 中add 一个 Impl2对象，Impl2与Impl不兼容
    }
}
interface InterfaceA<T>{}
class Impl implements InterfaceA<String> {}
class Impl2 implements InterfaceA<String> {}

public class WildCardTest2 {
    public static void main(String[] args) {
        InterfaceA<?>[] arr1 = new Impl[3];
        arr1[0] = new Impl();
        //会报错
        //arr1[2] = new Impl2();
        // 兼容的类型可以
        InterfaceA<?>[] arr2 = new InterfaceA[4];
        arr2[0] = new Impl();
        arr2[0] = new Impl2();
    }
}

class TestClass<T>{
	public void test(T t){
		// somecode
	}
    public void test2(Object o){
        // somecode
    }
}

TestClass<? extends Fruit> f = new TestClass<Apple>;

public class WildcardTest4 {
    public static void main(String[] args) {
        List<? super Apple> appleList = new ArrayList<Fruit>();
        List<? super Apple> appleList2 = new ArrayList<Apple>();
        List<? super Apple> appleList3 = new ArrayList<>();
        // 前三种情况都可以，但是这种不可以
//    List<? super Apple> appleList4 = new ArrayList<BigApple>();
        // 不可以
        //appleList3.add(new Orange());
        appleList3.add(new Apple());
        appleList3.add(new BigApple());
        // 虽然字面上是 任何 Apple 的父类，但是Apple父类很多，不能确定类型，所以实际上任何Apple 的父类都不行
        //appleList3.add(new Fruit());
        // 只能Object 接
        Object a = appleList3.get(1);
    }
}
class Fruit {}
class Orange extends Fruit {}
class Apple extends Fruit {}
class BigApple extends Apple implements Runnable {
    @Override
    public void run() {
    }
}
class SmallApple extends Apple {}

public class WildcardTest5 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Apple());// 有警告，但是不会编译报错
        Object o = list.get(0);
        List<?> list1 = new ArrayList<>();
//        list1.add(new Apple());// 不可这样写，编译报错
    }
}