ArrayList<type>//type只能是引用类型,即只能是类
//泛型前后类型必须一致,即必须写相同的类,就是父子类之间也不允许
ArrayList<String> arrayList = new ArrayList<String>();
Collection<Object> c = new Collection<String>();//会报错,因为泛型前后类型不一致

ArrayList<String > arrayList = new ArrayList<String >();
arrayList.add("hello");
arrayList.add("world");
arrayList.add("java");
Iterator<String> it = arrayList.iterator();
while (it.hasNext()){
	String s = it.next();
	System.out.println(s);
}
//JDK7新特性,泛型推断
ArrayList<String > arrayList2 = new ArrayList<>();

public class GenericClass<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public static void main(String[] args) {
        GenericClass<String> genericClass=new GenericClass<>();
        genericClass.setData("Generic Class");
        System.out.println(genericClass.getData());
    }
}

interface Inter<T>{
    public abstract void show(T t);
}

//方式一:已经知道该泛型的明确类型
class InterImple implements Inter<String>{
  //不常用
    @Override
    public void show(String str) {
        System.out.println("from normal imple"+str);
    }
}
//方式二:并不知道泛型的明确类型
class InterImple2<T> implements Inter<T>{
    //此时泛型接口的使用与泛型类相同
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
public static void main(String[] args) {
	Inter<String> inter = new InterImple2<String>();
	inter.show("String");
	Inter<Integer> inter2 = new InterImple2<Integer>();
	inter2.show(123);
	Inter<Boolean> inter3 = new InterImple2<Boolean>();
	inter3.show(true);
}

public <T> T show(T t);//public 后的<T>声明使用泛型

class ObjectTool{
    //将泛型定义在方法上
    public <T> void show(T t){
        System.out.println(t);
    }
}
//show方法可以接受任何一种参数
public static void main(String[] args) {
	ObjectTool objectTool = new ObjectTool();
	objectTool.<String>show("this is string type");
	//不知道形式参数类型,泛型参数可以不用明确指定,编译器会自动识别
	objectTool.show("hello world");
	objectTool.<Integer>show(100);
	objectTool.show(true);
}

/**
* 限定类型使用extends关键字指定
* 可以使类，接口，类放在前面接口放在后面用&符号分割
* 例如：<T extends ArrayList & Comparable<T> & Serializable>
*/
public static <T extends Comparable<T>> T getMin(T a, T b) {
	return (a.compareTo(b) < 0) ? a : b;
}

public class TypeLimitForClass<T extends List & Serializable> {
	private T data;
	public T getData() {
		return data;
	}
	public void setData(T data) {
		this.data = data;
	}
	public static <T extends Comparable<T>> T getMinListSize(T a, T b) {
		return (a.compareTo(b) < 0) ? a : b;
	}
}

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

Collection<?> c1 = new ArrayList<Animal>();
Collection<?> c2 = new ArrayList<Dog>();
Collection<?> c3 = new ArrayList<Cat>();

Collection<? extends Animal> c4 = new ArrayList<Animal>();
Collection<? extends Animal> c5 = new ArrayList<Dog>();
Collection<? extends Animal> c6 = new ArrayList<Object>();//出错,只能是子类

Collection<? super Animal> c7 = new ArrayList<Object>();
Collection<? super Animal> c8 = new ArrayList<Dog>();//出错,只能是父类

public class GenericRestrict1<T> {
    static class NormalClass {

    }

    private T data;

    /**
     * 不能实例化泛型类
     * Type parameter 'T' cannot be instantiated directly
     */
    public void setData() {
        //this.data = new T();
    }

    /**
     * 静态变量或方法不能引用泛型类型变量
   private static T result;
   private static T getResult() {
       return result;
   }
     */

    /**
     * 静态泛型方法是可以的
     */
    private static <K> K getKey(K k) {
        return k;
    }

    public static void main(String[] args) {
        NormalClass normalClassA = new NormalClass();
        NormalClass normalClassB = new NormalClass();
        /**
         * 基本类型无法作为泛型类型
       GenericRestrict1<int> genericRestrictInt = new GenericRestrict1<>();
         */
        GenericRestrict1<Integer> genericRestrictInteger = new GenericRestrict1<>();
        GenericRestrict1<String> genericRestrictString = new GenericRestrict1<>();
        /**
         * 无法使用instanceof关键字判断泛型类的类型
         * Illegal generic type for instanceof
       if(genericRestrictInteger instanceof GenericRestrict1<Integer>){
           return;
       }
         */

        /**
         * 无法使用“==”判断两个泛型类的实例
         * Operator '==' cannot be applied to this two instance
       if (genericRestrictInteger == genericRestrictString) {
           return;
       }
         */

        /**
         * 泛型类的原生类型与所传递的泛型无关，无论传递什么类型，原生类是一样的
         */
        System.out.println(normalClassA == normalClassB);//false
        System.out.println(genericRestrictInteger == genericRestrictInteger);//
        System.out.println(genericRestrictInteger.getClass() == genericRestrictString.getClass()); //true
        System.out.println(genericRestrictInteger.getClass());//restrict.GenericRestrict1
        System.out.println(genericRestrictString.getClass());//restrict.GenericRestrict1

        /**
         * 泛型数组可以声明但无法实例化
         * Generic array creation
         */
        GenericRestrict1<String>[] genericRestrict1s;
//        genericRestrict1s = new GenericRestrict1<String>[10];
        genericRestrict1s = new GenericRestrict1[10];
        genericRestrict1s[0]=genericRestrictString;
    }

}

public class GenericRestrict2 {

    private class MyException extends Exception {
    }

    /**
     * 泛型类不能继承Exception或者Throwable
     * Generic class may not extend 'java.lang.Throwable'
	 private class MyGenericException<T> extends Exception {

	 }
	 private class MyGenericThrowable<T> extends Throwable {
   }
     */

    /**
     * 不能捕获泛型类型限定的异常
     * Cannot catch type parameters
    public <T extends Exception> void getException(T t) {
       try {

       } catch (T e) {

       }
    }
     */

    /**
     *可以将泛型限定的异常抛出
     */
    public <T extends Throwable> void getException(T t) throws T {
        try {

        } catch (Exception e) {
            throw t;
        }
    }
}

public interface ParameterizedType extends Type {
    // 返回确切的泛型参数, 如Map<String, Integer>返回[String, Integer]
    Type[] getActualTypeArguments();

    //返回当前class或interface声明的类型, 如List<?>返回List
    Type getRawType();

    //返回所属类型. 如,当前类型为O<T>.I<S>, 则返回O<T>. 顶级类型将返回null
    Type getOwnerType();
}

public class Pair<T>
{
	private T first;
	private T second;
	public Pair() { first = null ; second = null ; }
	public PairfT first, T second) { this,first = first; this.second = second; }
	public T getFirstO { return first; }
	public T getSecondO { return second; }
	public void setFirst(T newValue) { first = newValue; }
	public void setSecond(T newValue) { second = newValue; }
}
//T 是无限定变量，直接使用Object替换
public class Pair
{
	private Object first;
	private Object second;
	public Pair(Object first, Object second)
	{
		this,first = first;
		this.second = second;
    }
	public Object getFirstO { return first; }
	public Object getSecondO { return second; }
	public void setFirst(Object newValue) { first = newValue; }
	public void setSecond(Object newValue) { second = newValue; }
}