java基础：泛型

（1）本质是“类型参数化”。
（2）在声明一个类、接口、方法的时候，需要涉及到到一个问题：要给属性确定一个类型，或者给方法的返回值确定一个类型，或者给方法的参数确定一个类型。之前，定义类、接口、方法的时候，上面所描述的类型都是直接写死，不会变化的。而类型参数化，顾名思义，就是将原来的具体的类型进行参数化，类似于方法中的参数变量，不过这里是将类型作为参数，在使用时会传入具体的类型。

public class Point{
	int x;
	int y;
}

这里Pint类里面的属性x和y的类型已经定义好了，都是int类型。如果希望x属性和y属性的类型更加灵活一点，就可以为这两个属性添加泛型参数T，如下：

public class Point{
	T x;
	T y;
}

（1）T表示泛型参数，表示一种数据类型，具体是什么类型，需要将来使用Point的时候进行传参来确定。
（2）如果将来Point在使用的时候，没有给泛型参数T传值，那么T默认就表示为Object类型。
（3）T是泛型参数的名字，也就是相当于形参，名字随便起，但是一般用一个有意义的大写字母，例如一般E用在集合中。

Print的使用如下

public static void main(String[] args){
	//p1对象中x和y的属性类型都是Integer
	Point p1 = new Point();
	p1.x = 1;
	p1.y = 2;
	
	 //p2对象中x和y的属性类型都是String
	Point p2 = new Point();
	p2.x = "1";
	p2.y = "2";

	//p3对象中x和y的属性类型都是Object
	Point p3 = new Point();
	p3.x = new Object();
	p3.y = new Object();
	
}

可以看到，Point类的中x和y属性的类型，是可以根据我们在使用时所传的参数，进行临时变化的。
如果没有传这个泛型参数，那么这个参数T就默认是Object类型。

注意：给泛型参照传的值，只能是引用类型，不能是基本类型：Point编译报错

有如下代码：

import java.util.ArrayList;
import java.util.List;

public class Demo01 {
	public static void main(String[] args) {
		//创建一个ArrayList集合
		List list = new ArrayList();
		
		//添加String类型的数据
		list.add("aaaa");
		//添加Integer类型的数据（int会自动包装为Integer）
		list.add(100);
		
		//第一种方式，用Object类型接收输出
//		for(int i = 0; i 
 
 
第一种方式输出的结果：
 aaaa
 100
 
 
 
 
第二种方式的输出结果：
 aaaa
 Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
 at Test9.test01.Demo01.main(Demo01.java:24)
 
 
可以看到，第二种方式报错了，ClassCastException，类型转换异常，为什么会报这个异常呢？因为这个list数组中存的是两种不同类型（String和Integer）的数据，如果你指定用其中某一种类型接收，如String类型（而不用object类型接收），那使用时就只能用String类型的数据，另外的一种类型（Integer）就不能被接收和使用，此时就会发生类型转换异常。在这种情况下，就要使用泛型了，对集合传入的数据进行类型限制。
 
在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。说人话就是限制所传入数据的类型。
 对上面的案例使用泛型，代码如下：
 
import java.util.ArrayList;
import java.util.List;

public class Demo01 {
	public static void main(String[] args) {
		//创建一个ArrayList集合
		List list = new ArrayList();
		
		//添加String类型的数据
		list.add("aaaa");
		//添加Integer类型的数据（int会自动包装为Integer）
//		list.add(100);  //这句代码报错了
		
		//指定用String类型接收
		for(int i = 0; i 
 
 
可以看到，在List list=new ArrayList();这句代码两边多出了两个，这就是表示为这个集合类型添加了泛型类型，且这个泛型类型指定为String类型。表示这个集合只能添加String类型的数据了，如果添加了其他类型的数据就会报错。
 
 
后面那对尖括号中的泛型类型是可以省略的，即可以写成下面这样子
 
List list = new ArrayList<>();
 
2、泛型的使用 
2.1 泛型类 
泛型参数定义在类上面，那这个类就是泛型类。
 
//泛型类
public class Point{...}

//创建泛型类对象
public static void main(String[] args){
	Point p = new Point();
	}
 
代码样例:
 
public class Generic{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

	//泛型构造方法形参key的类型也为T，T的类型由外部指定
    public Generic(T key) { 
        this.key = key;
    }

	//泛型方法getKey的返回值类型为T，T的类型由外部指定
    public T getKey(){ 
        return key;
    }
}
 
//在实例化泛型类时，必须指定T的具体类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic integer = new Generic(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic string = new Generic("lalala");

System.out.println(integer.getkey());
System.out.println(string.getkey());
 
注意：不能对确切的泛型类型使用instanceof操作
 如下是错误的
 if(Num instanceof Generic){ } //Number是所有与数字相关的父类
 
2.2 泛型接口 
泛型接口，如果泛型参数定义在接口上面，那么这个接口就是一个泛型接口。
 使用其实和泛型类差不太多。。。
 如下：
 
//泛型接口
public interface Action{...}

public static void main(String[] args){
	//使用匿名内部类实现接口，且指定了这个接口的类型为String
	Action a = new Action<>(){
		//...
	};
}
 
2.3 泛型方法 
泛型参数定义在方法上面，那么这个方法就是泛型方法
 
//泛型方法
public class Test{
	public  T test(T t){
		//...
	}
}

//泛型方法中的返回类型和参数类型都得是泛型才能叫泛型方法，否则只是带泛型参数的普通方法或者返回值为泛型的普通方法
public static void main(String[] args){
	Test t = new Test();    
	String str = t.test("hello");    
	Integer i = t.test(1);    
	Double d = t.test(10.5D);
}
 
3、泛型的类型 
先观察下面的代码
 
//编译通过，父类型的引用，指向子类对象
	Object o = new Integer(1);
	
//编译通过，Object[]类型兼容所有的【引用】类型数组，arr可以指向任意 引用类型 数组对象
	Object[] arr = new Integer[1];
	
//编译失败，类型不兼容，int[] 是基本类型数组
Object[] arr = new int[1];

//编译失败，错误信息：ArrayList无法转为ArrayList