java泛型的使用_java静态类使用泛型-CSDN博客

本文链接：https://blog.csdn.net/u014434491/article/details/22508025

一、概述

1、概念：泛型就是参数化的类型，使用广泛的类型。

2、作用：

*安全：指定容器要持有什么类型的对象，而且由编译器来保证类型的正确性。

*省心：所有的类型转换都是自动的和隐式的，提高代码的重用率

二、泛型类

1、格式：< 字母列表>

class类名 <字母列表>{

修饰符字母属性；

修饰符构造器（字母）{

}

修饰符返回类型方法名（字母）{

}

字母列表中的每个字母都代表一种还未确定的引用类型（泛型是在使用时确定具体类型），可以使用任何字母表示，但为了规范使用，一般使用以下常见字母

T 表示Type即类型；

K 和V 分别表示键值中的key和Value

E 表示Element

？表示不确定的类型（通配符）

2、泛型类在声明时使用泛型，不能将泛型字母使用在静态方法和静态属性上，因为泛型是在使用时确定具体类型，而static是在编译时确定。

3、泛型不能使用基本数据类型，必须使用引用类型，否则编译出错。

下面举一个泛型类的例子说明

public class Student<T1,T2> {
	private T1 javaScore;
	private T2 oracleScore;
	
	//泛型声明时不能使用 静态属性|静态方法上
	//private static T1 test;
	
	
	public T1 getJavaScore() {
		return javaScore;
	}

	public void setJavaScore(T1 javaScore) {
		this.javaScore = javaScore;
	}

	public T2 getOracleScore() {
		return oracleScore;
	}

	public void setOracleScore(T2 oracleScore) {
		this.oracleScore = oracleScore;
	}

	public static void main(String[] args) {
		//使用时指定类型(引用类型)
		Student<String,Integer> stu = new Student<String,Integer> ();
		//1、安全：类型检查
		stu.setJavaScore("优秀");
		//2、省心:类型转换
		int it =stu.getOracleScore(); //自动拆箱
	}

}

三、泛型接口

泛型在接口中的使用与泛型类基本一致，需要注意的是在接口中泛型字母只能使用在方法中，不能使用在全局常量中（接口中的成员变量均为全局常量）。

四、泛型方法

泛型方法就是为方法的返回类型签名，< >位于返回类型前面，泛型方法因为类型还未确定，所以只能访问对象信息，不能修改信息。

五、泛型的擦除

1.擦除：

*在使用时没有指定具体类型

*子类继承|实现时没有指定具体类型

2.后果：

*擦除后不类型检查

*擦除后按Object接收，以Object对待

*存在编译警告，加上Object可以去除，但显得有些画蛇添足

/**
 * 父类为泛型类
 * 1、属性
 * 2、方法
 * 
 * 要么同时擦除，要么子类大于等于父类的类型,
 * 不能子类擦除，父类泛型
 * 1、属性类型
 *  父类中，随父类而定
 *  子类中，随子类而定
 * 2、方法重写:
 *  随父类而定
 */
public abstract class Father<T,T1> {
	T name;
	public abstract void test(T t);

}
/**
 * 子类声明时指定具体类型
 * 属性类型为具体类型
 * 方法同理
 */
class Child1 extends Father<String,Integer>{
	String t2;
	@Override
	public void test(String t) {
	}	
}
/**
 * 子类为泛型类 ,类型在使用时确定，大于等于父类的类型
 * @author Administrator
 *
 */
class Child2<T1,T,T3> extends Father<T,T1>{
	T1 t2;

	@Override
	public void test(T t) {
		
	}	
}
/**
 * 子类为泛型类，父类不指定类型 ,泛型的擦除，使用Object替换
 */
class Child3<T1,T2> extends Father{
	T1 name2;
	@Override
	public void test(Object t) {
		// TODO Auto-generated method stub		
		
	}
}
/**
 * 子类与父类同时擦除
 */
class Child4 extends Father{
	String name;	
	@Override
	public void test(Object t) {
		
	}	
}
/**
 *错误:子类擦除，父类使用泛型
class Child5 extends Father<T,T1>{
	String name;	
	@Override
	public void test(T t) {
		
	}
*/

/**
*泛型的擦除
*1、继承|实现声明 不指定类型
*2、使用时 不指定类型 
*统一Object 对待 
*1、编译器警告 消除使用Object
*2、不完全等同于Object ,编译不会类型检查
 */
public class Student<T> {
	private T javaScore;
	private T oracleScore;
	
	//泛型声明时不能使用 静态属性|静态方法上
	//private static T1 test;
	
	
	public T getJavaScore() {
		return javaScore;
	}
	public void setJavaScore(T javaScore) {
		this.javaScore = javaScore;
	}

	public T getOracleScore() {
		return oracleScore;
	}
	public void setOracleScore(T oracleScore) {
		this.oracleScore = oracleScore;
	}

	public static void main(String[] args) {
		Student stu1 = new Student(); 
		//消除警告 使用 Object
		Student<Object> stu = new Student<Object>(); 
		//stu.setJavaScore("af"); //以Object对待
		
		test(stu1); //stu1 相当于Object 但是不完全等同Object
		//擦除，不会类型检查
		//test(stu);
		test1(stu1);
		test1(stu);
	}
	
	public static  void test(Student<Integer> a){
		
	}
	public static  void test1(Student<?> a){
		
	}
}

六、泛型没有多态

public class Fruit {

}
class Apple extends Fruit{
	
}
public class App {
	public static void main(String[] args) {
		//A<Fruit> f = new A<Apple>();错误，泛型没有多态
		A<Fruit> f =new A<Fruit>();
		//test(new A<Apple>());错误
	}
	//形参使用多态
	public static void test(A<Fruit> f){
		
	}
	//返回类型使用多态
	public static A<Fruit>  test2(){
		//return (A<Fruit>)(new A<Apple>());错误
		return null;
	}
}

七、通配符？、extends和super在泛型中的使用

1.通配符的作用：虽然泛型没有多态，但通过通配符的使用，我们可以实现类似多态的功能。

2.通配符的使用：通配符使用在声明类型|方法上，不能用在声明类或使用时（使用时必须确定类型）。

3.？：表示类型不定，使用时确定类型。

4.？ extends classA ：表示小于等于，也称作上限，即该类型只能是classA的子类或自身。

5.？ super classA ：表示大于等于，也称作下限，即该类型只能是classA的父类或自身。

public class Student<T> {
	T score;
		
	public static void main(String[] args) {
		Student<?> stu = new Student<String>();
		test(new Student<Integer>());
		
		test2(new Student<Apple>());
		//test3(new Student<Apple>()); //泛型没有多态		
		
		//test4(new Student<Apple>()); //<
		 stu  = new Student<Fruit>();
		//test4(stu); //使用时确定类型
		test4(new Student<Object>());
		test4(new Student<Fruit>());		
	}
	
	public static void test(Student<?> stu){
		
	}
	public static void test3(Student<Fruit> stu){
		
	}
	//extends <=
	public static void test2(Student<? extends Fruit> stu){
		
	}
	//super >=
	public static void test4(Student<? super Fruit> stu){
		
	}
	
}

八、泛型的嵌套

1.声明：嵌套使用泛型
A<B<C>> = new A<B<C>>()；
2.使用：从外到内，层层拆分

public class Bjsxt <T>{
 T stu ;
  
 public static void main(String[] args) {
	 //泛型的嵌套 
	 Bjsxt<Student<String>> room =new  Bjsxt<Student<String>>();
	 //从外到内拆分
	 room.stu = new Student<String>();
	 Student<String> stu = room.stu;
	 String score =stu.score;
	 System.out.println(score);
}
}

九、没有泛型数组

可以声明泛型数组，但是不能创建泛型数组。虽然如此，但是我们可以通过使用Object接收，再将其强制转换为泛型数组。

public static void main(String[] args) {
		Integer[]  arr = new Integer[4]; 
		//Student<String>[] arr2 = new Student<String>[10];
		Student<?>[] arr2 = new Student[10];
		
		MyArrayList<String> strList =new MyArrayList<String>();
		strList.add(0, "a");
		String elem =strList.getElem(0);
		System.out.println(elem);}
class MyArrayList<E>{
	//E[] cap =new E[10]; 没有泛型数组
	Object[] cap = new Object[10];
	
	public void add(int idx,E e){
		cap[idx] =e;
	}
		
	@SuppressWarnings("unchecked")
	public E[] getAll(){
		return (E[]) cap;
	}
	@SuppressWarnings("unchecked")
	public E getElem(int idx){
		return (E) cap[idx];
	}
}