1 泛型

其本质为：参数化类型

作用即指定能够存放的数据类型（统一类型防止出现类型转换异常）

1.1 泛型的擦除

泛型只在编译阶段有效。编译之后JVM会采取去泛型化的措施。

（通过反射的方式跳过编译步骤）

泛型在运行阶段是没有效果的。

1.2 泛型通配符

1.2.1 无边界通配符

<?> 即无边界通配符

表示通用的类型

public static void main(String[] args){
    List<String> list1  = new ArrayList<>();
    list1.add("aa");
    list1.add("bb");
    loop(list1);   
}

public static void loop(List<?> list){
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }

}

1.2.2 上边界通配符

<? extends Number>即上边界通配符

代表从Number往下的子类或孙类对象都可以使用

即指定上限

public static void main(String[] args){
    List<Number> list2  = new ArrayList<>();
    list2.add(1);
    list2.add(2);
    loop(list2);   
}
/**
*? extends Number
通用的类型必须是Number及其子类
*@param:list
*/
public static void loop(List<? extends Number> list){
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }

}

1.2.3 下边界通配符

<? super Integer>即下边界通配符

代表从Integer到Object所有的对象都可以

即指定下限

public static void main(String[] args){
    List<Number> list3  = new ArrayList<>();
    list3.add(3);
    list3.add(4);
    loop(list3);   
}
/**
*? super Integer
*通用类型必须是Integer到Object类型的对象
*@param:list
*/
public static void loop(List<? super Integer> list){
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }

}

1.3 泛型的使用

1.3.1 使用规则

必须先声明再使用

声明通过“<>”实现

约定泛型可以使用单个大写字母来表示（K E T V 等）

1.3.2 泛型类

如下代码所示，泛型类即在类的头部声明了一个泛型。

在类体中使用了泛型

增加了代码的灵活度

//泛型类
public class PersonNew <T> {
	private T t;
	

	public T getT() {
		return t;
	}


	public void setT(T t) {
		this.t = t;
	}


	public PersonNew(T t) {
		this.t = t;
	}
	
}

泛型类的调用：

public class PersonBean {
	private Integer id;
	private String name;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	

}
public class GenericsClass{
	public static void main(String[] args) {
		PersonBean p = new PersonBean();
		p.setId(1);
		p.setName("ya");
		
		PersonNew<PersonBean> pn = new PersonNew<>(p);
		PersonNew<String> ss = new PersonNew<>("sname");
		
	}
}

1.3.3 泛型方法

public class GenericsMethod <K,V>{
	/**
	 * 普通方法 可以使用 类中定义的泛型
	 * @param k
	 * @param v
	 * @return
	 */
	public K method1(K k,V v) {
		return (K)null;
	}
	
	/**
	 * 普通方法 使用方法中定义的泛型
	 * @param <T>
	 * @param t
	 * @param v
	 * @return
	 */
	public <T> T method2(T t,V v){
		return (T)null;
	}
	
	/**
	 * 静态方法  无法使用  类中定义的泛型
	 * @param <T>
	 * @param t
	 * @param v
	 * @return
	 */
    //	public static K method2(){  错误的用法 （会报错）
    //		return null;
    //	}
	public static <K> K method2(){
		return null;
	}
}

1.3.4 泛型接口

一般的接口以及接口方法的实现只能实现特定参数类型的（如下代码只能实现int类型的操作）

public interface Cal {
	int add(int a,int b);
	int sub(int a,int b);
	int mul(int a,int b);
}

定义泛型接口：

public interface GenericsCal <T> {
	T add(T a,T b);
	T sub(T a,T b);
	T mul(T a,T b);
}

去实现Double类型的实现：

public class GenericsCalDoubleGenerate implements GenericsCal<Double> {

	@Override
	public Double add(Double a, Double b) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Double sub(Double a, Double b) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Double mul(Double a, Double b) {
		// TODO Auto-generated method stub
		return null;
	}


}

JAVA核心之泛型