Java 泛型
1.概念
泛型在java中有很重要的地位，有广泛的应用，那么什么是泛型，简单理解为一种不确定的类型或者说参数化类型，将类型由原来的类型参数化，比如定义一个变量的时候指定String a，那么现在这个类型String也作为参数，然后在使用的时候传入具体的参数；
2.泛型的使用
泛型有三种使用方式，分别是泛型类，泛型接口和泛型方法。
1>泛型类
泛型类用于类的定义，最常见的就是容器类，可以包含不同的对象，如List,Set,Map。基本语法格式：
class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
private 泛型标识 /*（成员变量类型）*/ var;
}
}例如：
public class Generic {
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
public Generic(T key) {
this.key = key;
}
} 注意，泛型的类型参数只能是类类型，不能是简单类型，这样的都是不可以的
另外，对应泛型类的时候不一定要传入实参，
Generic genericInteger = new Generic(123456);
Generic genericString = new Generic("ssss"); 这两种方式都是可以的，区别是：如果传入实参会进行限制，不传入实参那么里面放任何类型都是可以的；举个例子
List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);
for(int i = 0; i< arrayList.size();i++){
String item = (String)arrayList.get(i);
Log.d("泛型测试","item = " + item);
}这种情况就会报错，就是因为定义的时候没有限制泛型类型，然后再取出来的时候使用类型转换，导致报错，正确的做法是，在定义的时候就限制类型；
List arrayList = new ArrayList();
...
//arrayList.add(100); 在编译阶段，编译器就会报错 如果不需要做类型的转换，那么就不需要定义实际的类型，比如
Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);
Log.d("泛型测试","key is " + generic.getKey());
Log.d("泛型测试","key is " + generic1.getKey());
Log.d("泛型测试","key is " + generic2.getKey());
Log.d("泛型测试","key is " + generic3.getKey());2>泛型接口
泛型接口和泛型类的定义一样
//定义一个泛型接口
public interface Generator {
public T next();
} 当定义实现泛型的接口的类时，有两种情况，一种是传入实参，一种是不传入实参
/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator implements Generator{
* 如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错："Unknown class"
*/
class FruitGenerator implements Generator{
@Override
public T next() {
return null;
}
} /**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator，public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator { 3>通配符
先举个例子
package com.example.springbootDemo.service.arrayT;
public class ResultTest {
public void showKeyValue1(Generic obj){
System.out.println(obj.getKey());
}
public static void main(String[] args) {
Generic gInteger = new Generic(123);
Generic gNumber = new Generic(456);
ResultTest resultTest = new ResultTest();
resultTest.showKeyValue1(gNumber);
resultTest.showKeyValue1(gInteger);
}
} 这种情况，编译器就会报错的，提示类型不对；
那么这种情况怎么办那，总不能再定义一个方法?
public void showKeyValue1(Generic obj){
System.out.println(obj.getKey());
} 这样也太low了吧，于是引入了通配符的概念"？",这样就可以了，如下所示
public void showKeyValue1(Generic obj){
System.out.println(obj.getKey());
}这里的？代替了具体的类型实参，此处的？是实参，可以把？看成一种类型，是所有类型的父类；可以解决当类型不确定时的情况；如果想限制showKeyValue1的泛型是Number类型的，可以使用extends
public void showKeyValue1(Generic obj){
System.out.println(obj.getKey());
}标识出入的类型，只能是Number的子类
4>泛型方法
先通过一些列子来了解下什么才是泛型方法
//这个类是个泛型类，在上面已经介绍过
public class Generic{
private T key;
public Generic(T key) {
this.key = key;
}
//我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
//这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
//所以在这个方法中才可以继续使用 T 这个泛型。
public T getKey(){
return key;
}
/**
* 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
* 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。正确的是在返回的E之前加个泛型的声明
public E setKey(E key){
this.key = keu
}
*/
}
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如：public K showKeyName(Generic container){
* ...
* }
*/
public T showKeyName(Generic container){
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
}
//这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic这个泛型类做形参而已。
public void showKeyValue1(Generic obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
//这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
//同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
public void showKeyValue2(Generic obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
/**
* 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
* 虽然我们声明了,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
public T showKeyName(Generic container){
...
}
*/ /**
* 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
* 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
public void showkey(T genericObj){
}
*/
public static void main(String[] args) {
}}
另外，泛型方法在泛型类中的使用要注意一些情况，通过代码演示下：
package com.example.springbootDemo.service.arrayT;
public class GenericFruit {
public class Fruit{
@Override
public String toString() {
return "fruit";
}
}
class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}
class Person{
@Override
public String toString() {
return "Person";
}
}
class GenerateTest{
public void show_1(T t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
//由于泛型方法在声明的时候会声明泛型，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
public void show_3(E t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
public void show_2(T t){
System.out.println(t.toString());
}
}
} 然后通过main方法进行测试
public static void main(String[] args) {
Apple apple = new Apple();
Person person = new Person();
GenerateTest generateTest = new GenerateTest();
//apple是Fruit的子类，所以这里可以
generateTest.show_1(apple);
//编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
//generateTest.show_1(person);
//使用这两个方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);
//使用这两个方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
} 5>.泛型方法和可变参数
通过一个简单例子了解下
public void printMsg( T... args){
for(T t : args){
Log.d("泛型测试","t is " + t);
}
}
printMsg("111",222,"aaaa","2323.4",55.55); 6>静态方法与泛型
静态方法是无法访问类上定义的泛型，如果静态方法操作的引用数据类型不确定的时候，必须将泛型定义在该方法上
public class StaticGenerator {
....
....
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void show(T t){..},此时编译器会提示错误信息：
"StaticGenerator cannot be refrenced from static context"
*/
public static void show(T t){
}
}