泛型方法、泛型构造函数，通配符设定下限、擦除与装换。

package frank;
import java.lang.*;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;

/**
 * 泛型方法、泛型构造函数，通配符设定下限、擦除与装换。
 * */
public class App<S>
{
	public static void main(String[] args)throws Exception
	{
		String[] str = {"1"};
		List<String> list = new ArrayList<String>();
		App.add(str,list);

		List<String> ao = new ArrayList<>();
		List<String> as = new ArrayList<>();
		App.set(as,ao);

		A a = new <String> A("1");//实例化并调用泛型构造函数,如果传递的不是指定的类型则异常

		A<String> a2 = new <Integer> A<String>(5);//指定类的形参是String类型，但是传给构造函数的是Integer类型

		//A<String> a3 = new <Integer> A<>(1);//这里讲异常，必须显示指定，不然JVM就会糊涂。
		//
		/**类型擦除和装换**/
		/**
		 * Apple<Integer> l = new Apple<Integer>();
		 * l.getSize()返回Integer类型的
		 * Apple i = l;//丢失掉尖括号里面的类型
		 * i.getSize() 返回Number类型的
		 * Integer i2 = i.getSize()将会异常。因为返回是的Number类型的
		 * 把一个泛型转换成他的原始类型，将会把里面的实际类型丢失掉
		 * */
		/**转换
		 * List<Integer> li =new ArrayList<Integer>();
		 * li.add(1);
		 * List list = li;
		 * List<String> ls = list;//将会发生未经检查的转换警告
		 * ls.get(0);试着把List<Integer>类型的元素当成List<String>将引发异常。
		 * 
		 *第二种转换情况
		 List li = new ArrayList();
		 li.add(1);
		 (String)li.get(0);//将会发生异常，把一个Integer类型的装换为String类型
		 * */
		
	}
	static <T> void add(T[] a,Collection<T> c)//定义泛型方法
	{
		for(T item : a)
		{
			c.add(item);
		}
	}
	static <T,S extends T> void set(Collection<? extends T> from,Collection<T> to)//用通配符给泛型方法添加上限
	{
		for(T item : from)
		{
			to.add(item);
		}	
	}
}
class A<E>
{
	public <T> A(T t)//定义一个泛型构造函数
	{
		System.out.println(t);
	}
	//定义一个泛型方法并设定第一个参数的下限。第一个参数：是T本身或者是T的子类。
	void <T> T add(Collection<? super T> des,Collection<T> str)
	{
		T obj=null;
		for(T item : from)
		{
			obj=item;
			to.add(item);
		}
		return obj;
	}

	public static <T> void copy(Collection<T> dest,Collection<? extends T> src)
	{
		//两个copy方法冲突
		//如果有个地方调用copy方法将会发生编译错误！
	}
	public static <T> T copy(Collection<? super T> dest,Collection<T> src)
	{
		//两个copy方法冲突
	}
}