Java泛型详解

1.概述

泛型就是参数化类型。

作用：在编译的时候检查类型安全,所有的强制转换都是自动和隐式的，提高代码的重用率。

2.泛型的使用

2.1接口中声明泛型

/**
 *接口中，泛型只能使用在方法中，不能使用在全局变量上
 */
public interface Compare<T>{
    void compare(T t);
}

2.2 类中声明泛型　

/**
 *     T  Type 表示类型。
 *     K V 分别代表键值中的Key Value。
 *     E 代表Element
 *      使用时确定类型
 *  注意：
 *  1、泛型只能使用引用类型，不能基本类型
 *  2、泛型声明时字母不能使用 静态属性|静态方法上
 */
public class Student<T1,T2> {
    private T1 username;
    private T2 password;

    /**
     *泛型方法 <> 返回类型前面, 只能访问对象的信息，不能修改信息
     * @param <T>
     */
    public static  <T> void test(){
        System.out.println("测试@@@@");
    }

    public T1 getUsername() {
        return username;
    }

    public void setUsername(T1 username) {
        this.username = username;
    }

    public T2 getPassword() {
        return password;
    }

    public void setPassword(T2 password) {
        this.password = password;
    }
}

　　

2.3.类继承实现

/**
 * 父类为泛型类
 * 要么同时擦除，要么子类大于等于父类的类型,
 * 不能子类擦除，父类泛型
 * 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) {
		
	}	
}
/**
 * 子类为泛型类 ,类型在使用时确定
 */
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) {
		
	}	
}

2.4 接口的实现　

/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 */
public interface Comparable<T> {
	void compare(T t);
}
//声明子类指定具体类型
class Comp implements Comparable<Integer>{

	@Override
	public void compare(Integer t) {
	
	}
	
}
//擦除
class Comp1 implements Comparable{

	@Override
	public void compare(Object t) {
	
	}
	 
}
//父类擦除，子类泛型
class Comp2<T> implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	 
}
//子类泛型>=父类泛型
class Comp3<T> implements Comparable<T>{

	@Override
	public void compare(T t) {
		// TODO Auto-generated method stub
		
	}
	 
} 

2.5.通配符　

/**
 * 通配符
 * ?类型不定，使用时确定类型
 * ?使用:声明类型|声明方法上，不能声明类或使用时
 * ? extends : <= 上限  指定类型 子类或自身
 * ? super :>=下限   指定类型 为自身或父类
 */
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>()); //子类
		test4(new Student<Fruit>());  //自身或父类 

		
	}
	
	public static void test(Student<?> stu){
		
	}
	// <=
	public static void test2(Student<? extends Fruit> stu){
		
	}

	//>=
	public static void test4(Student<? super Fruit> stu){
		
	}
	
}　

每天进步一丢丢

完成。