Java泛型--使用总结

一、泛型的概念

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（源自：百度百科）。

什么是参数化类型？打个比方，在调用一个有参数方法时xxx.getIntValue(3,5)，需要向方法传入具体数据的值--实参。使用泛型类时，当传入的是具体数据类型而不是它的值,例：Color<String> myColor = new Color<String>()。所以参数化类型可以理解为传入的参数是一种数据类型，该数据类型可以为基本数据类型，int、double...也可为自定义类型。

二、为什么要引入泛型？

public class Person {
		
	private Object age;
        //Getter和Setter方法，略。。。。。
	public static void main(String[] args) {
		Person p = new Person();
		p.setAge(18);
		p.setAge("十八岁");
		Integer age1=(Integer)p.getAge();
		Integer age2 = (Integer)p.getAge();//该行运行时会抛异常
		System.out.println("age1:"+age1+"||age2:"+age2);
	}
}

如上,该类的目的是要用数字或汉字描述一个人年龄，通过int->Integer->Object或string->Object实现自动装箱和向上转型，所以设置其属性的类型为Object。当获取人的年龄时，对Object向下转型，汉字年龄转为Integer时，就会ClassCastException。这种异常只能在运行时被检测出来，存在安全隐患，有没有好的办法在编译时期就能够检测？泛型就应运而生了，它能够在编译时期就检测类型安全，很好的规避了那个安全隐患；同时它不再依赖于Object向下转型或强制类型转换来满足绝大多数需求，能够写出更灵活通用的代码。

使用泛型把上面的代码做下调整，会看到p.setAge("十八岁")时，编译直接不通过，证明了泛型在编译期就进行了安全性检查。

public class Person<T> {
		
	private T age;
        //Getter和Setter方法略
	public static void main(String[] args) {
		Person<Integer> p = new Person<Integer>();
		p.setAge(18);
		p.setAge("十八岁");//该行编译不通过
	}
}

三、泛型的规范

泛型在声明时，使用<>括起来，尖括号中为泛型标识符，常用的泛型标识符为T、S、U、V、E、K、V等，当泛型参数有多个时，通常第一个泛型类型标识符定义为T，第二个定义为S，第三个为U，第四个为V，E为集合泛型类型，K为映射泛型类型的键，V为映射泛型类型的值；当然也可以自定义，当尖括号中可以有一个或多个泛型标识符，中间用“，”隔开。泛型的使用，常见为：泛型类、泛型接口、泛型通配符、泛型方法。

四、泛型类

当在类名称后加上<泛型标识符>，说明此类为泛型类，具体用法如下：

/**
 * @ClassName: GenericClass
 * @Description: (泛型类)
 * @author: 阿Q
 * @date 2019年9月3日
 *
 * @param <T>
 */
public class GenericClass<T> {
	
	private T value;
	
	public GenericClass(T value){
		this.value=value;
	}

	public T getValue() {
		return value;
	}
	
	public static void main(String[] args) {
		GenericClass<String> gc = new GenericClass<String>("String类型");
		GenericClass<Integer> gd= new GenericClass<Integer>(123);				
		System.out.println("传入String:"+gc.getValue());
		System.out.println("传入Integer:"+gd.getValue());
		//当不传入泛型类型参数，泛型类型的成员变量可以为任意类型
		GenericClass ge = new GenericClass(1.25f);
		GenericClass gf = new GenericClass(false);		
		System.err.println("不传泛型类型，传浮点参数："+ge.getValue());
		System.err.println("不传泛型类型，传整型参数："+gf.getValue());
	}
}

控制台输出结果：（注意，定义泛型，不一定要传入泛型类型参数，也可以不传，结果如下。）

传入String:String类型
传入Integer:123
不传泛型类型，传浮点参数：1.25
不传泛型类型，传整型参数：false

五、泛型接口

/**
 * @ClassName: GenericAPI
 * @Description: (泛型接口)
 * @author: 阿Q
 * @date 2019年9月3日
 *
 * @param <T>
 */
public interface GenericAPI<T> {
	public T printColor();
}

泛型接口的实现类（不做详细说明）

/**
 * @ClassName: GenericAPImpl
 * @Description: (泛型接口的实现类)
 * @author: 阿Q
 * @date 2019年9月3日
 *
 */
public class GenericAPImpl implements GenericAPI<String> {

	@Override
	public String printColor() {		
		return "中国红";
	}
}

六、泛型方法

6.1泛型通配符

在上面的泛型类中，定义了泛型类GenericClass<T>,已知Object为string的父类，当一个方法中的参数为(GenericClass<Object> gc)，能否为其传入GenericClass<String>类型的参数呢？下面实验一下

public class GenericMark {
	
	public void printInfo(GenericClass<Object> gc){
		System.out.println(gc.getValue());
	}
	
	public static void main(String[] args) {
		GenericMark gm= new GenericMark();
		GenericClass<String> gc = new GenericClass<String>("测试未使用通配符");
		//该行编译不通过
		gm.printInfo(gc);
	}

}

上述代码中gm.printInfo(gc);编译不通过。怎么解决这个问题呢？当然我们也可以定义一个printInfo(GenericClass<String> gc)的方法，但是代码却又冗余。泛型给出了一个更好的解决方案，通配符”？“，通配符旨代表所有的类型的父类，它是具体的类型参数，不是形参，和Integer、string..意义相同。

将方法改变一下，编译通过。

public void printInfo(GenericClass<?> gc){
		System.out.println(gc.getValue());
	}

通配符经常被用在方法参数中，它还具有上限<? extends T>和下限<? super T>的特性。当使用上限通配时，只能传入T类型和其子类型，如下：

public class GenericMarkAll {
	
	public void print(GenericClass<? extends Number> gc){
		System.out.println(gc.getValue());
	}
	
	public static void main(String[] args) {
		GenericMarkAll all = new GenericMarkAll();
                //Object为Number的父类，下面一行代码编译不通过
		//all.print(new GenericClass<Object>(123));
                //Interger为Number的子类，编译通过
		all.print(new GenericClass<Integer>(123));
	}
}

当使用下限通配时，只能传如T类型和其父类

public class GenericMarkAll {
	
	public void print(GenericClass<? super Number> gc){
		System.out.println(gc.getValue());
	}
	
	public static void main(String[] args) {
		GenericMarkAll all = new GenericMarkAll();
		//只能传入Number类型和其父类
		//all.print(new GenericClass<Integer>(123));
		all.print(new GenericClass<Object>(123));
	}
	
}

6.2泛型方法

在public修饰符和返回值之间加<泛型标志符>,表明这是一个泛型方法。为什么要使用泛型方法呢？如果没有定义泛型类会泛型接口，却想让某几个方法接收泛型参数，这时候就可以用泛型方法来处理。泛型类是在类实例化的时候就指定的泛型参数类型，而泛型方法是在方法调用的时候才指定泛型参数类型，更加灵活。关于泛型方法的内容很多，暂时只记录两个示例，供回忆。

示例1：

/**
 * @ClassName: GenericMethod
 * @Description: (泛型方法)
 * @author: 阿Q
 * @date 2019年9月3日
 *
 */
public class GenericMethod {
	
	public <K,V> boolean printInfo(Person<K,V> p1,Person<K,V> p2){
		return p1.getKey().equals(p2.getKey())&&p1.getValue().equals(p2.getValue());
	}
	
	public static void main(String[] args) {
		Person<Integer,String> p1 = new Person<Integer, String>(1,"1");
		Person<Integer,String> p2 = new Person<Integer, String>(2,"2");
		GenericMethod gm = new GenericMethod();
		//显示调用泛型方法
		boolean b = gm.<Integer,String>printInfo(p1, p2);
		//隐式调用泛型方法
		boolean c = gm.printInfo(p1, p2);
		System.out.println(b+"||"+c);
	}
}

public class Person<K,V> {
	
	private K key;
	private V value;
	
	public Person(K key,V value){
		this.key=key;
		this.value=value;
	}
	
	public K getKey() {
		return key;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
	
}

 

示例2：

/**
 * @ClassName: GenericMethod
 * @Description: (泛型方法)
 * @author: 阿Q
 * @date 2019年9月3日
 *
 */
public class GenericMethod {
	
	public <T> T printInfo(Class<T> gc) throws Exception{
		T t=gc.newInstance();
		return t;
	}
	
	public static void main(String[] args) {
		GenericMethod gm = new GenericMethod();
		Object info=null;
		try {
			info = gm.printInfo(Object.class);
		} catch (Exception e) {
			e.printStackTrace();
		}
		if(info instanceof Integer){
			System.out.println("true");
		}else{
			System.out.println("false");
		}
		
	}
}

 

参考文章：https://www.cnblogs.com/cat520/p/9353291.html

参考文章：https://www.cnblogs.com/coprince/p/8603492.html