JAVA学习笔记36——泛型2：泛型继承、擦除+泛型接口+泛型无多态、通配符

最近在看JAVA教学的视频，觉得老师讲的很好，同时借用源代码还有笔记来撰写本系列博客，记录自己的学习内容，同时也供看到的人学习。

关于泛型的知识点除了简介之外，本篇以及下一篇一共介绍6点，本篇介绍前3点：

NO.1：泛型的继承、擦除，先来看一下相关概念：

/**
*泛型的擦除
*1、继承||实现声明 不指定类型
*2、使用时 不指定类型 
*统一Object 对待 
*1、编译器警告 消除使用Object
*2、不完全等同于Object ,编译不会类型检查
 * @author Administrator
 *
 * @param <T>
 */
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){
	}
}

泛型继承有四种可行的情况以及一种不可行情况，具体体现在下述代码中：

/**
 * 父类为泛型类
 * 1、属性
 * 2、方法
 * ******要么同时擦除，要么子类大于等于父类的类型********
 * 不能子类擦除，父类泛型
 * 1、属性类型由什么决定：
 *  父类中，随父类而定
 *  子类中，随子类而定
 * 2、方法重写由什么决定:
 *  随父类而定
 * @param <T>
 */
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) {
	}
}
/**
 *错误情况:子类擦除（子类不能擦除），父类使用泛型
class Child5 extends Father<T,T1>{
	String name;	
	@Override
	public void test(T t) {
	}
*/

NO.2：泛型的接口：

看一个示例代码：

/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 * @param <T>
 */
public interface Comparable<T> {
	void compare(T t);
}
//声明子类指定具体类型
class Comp implements Comparable<Integer>{
	public void compare(Integer t) {
	}
}
//擦除
class Comp1 implements Comparable{
	public void compare(Object t) {
		// TODO Auto-generated method stub
	}
}
//父类擦除，子类泛型
class Comp2<T> implements Comparable{
	@Override
	public void compare(Object t) {
	}
}
//子类泛型>=父类泛型
class Comp3<T> implements Comparable<T>{
	@Override
	public void compare(T t) {
	}
}
//父类泛型，子类擦除 错误

NO.3：泛型无多态、通配符：

我们先来看一个正常的多态的例子：

public class Fruit {
}
class Apple extends Fruit{
}

/**
 * 多态的两种形式
 * @author Administrator
 */
public class FruitApp {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Fruit f =new Apple();
		test(new Apple());
	}
	//形参使用多态
	public static void test(Fruit f){	
	}
	//返回类型使用多态
	public static Fruit  test2(){
		return new Apple();
	}
}

那么既然泛型下面不允许使用多态，那么如果我们想实现多态的功能该怎么办呢？那就是使用通配符：

示例代码：

/**
 * 通配符
 * ?类型不定，使用时确定类型
 * ?使用:声明类型|声明方法上，不能声明类或使用时
 * ? extends : <= 上限  指定类型 子类或自身
 * ? super :>=下限   指定类型 为自身或父类
 * @author Administrator
 *
 */
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){
		
	}
	// <=
	public static void test2(Student<? extends Fruit> stu){
		
	}
	//>=
	public static void test4(Student<? super Fruit> stu){
		
	}
}