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

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

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

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

JAVA学习笔记36——泛型2:泛型继承、擦除+泛型接口+泛型无多态、通配符_第1张图片

/**
*泛型的擦除
*1、继承||实现声明 不指定类型
*2、使用时 不指定类型 
*统一Object 对待 
*1、编译器警告 消除使用Object
*2、不完全等同于Object ,编译不会类型检查
 * @author Administrator
 *
 * @param 
 */
public class Student {
	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 stu = new Student(); 
		//stu.setJavaScore("af"); //以Object对待
		
		test(stu1); //stu1 相当于Object 但是不完全等同Object
		//擦除,不会类型检查
		//test(stu);
		test1(stu1);
		test1(stu);
	}
	public static  void test(Student a){
	}
	public static  void test1(Student a){
	}
} 
  

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

/**
 * 父类为泛型类
 * 1、属性
 * 2、方法
 * ******要么同时擦除,要么子类大于等于父类的类型********
 * 不能子类擦除,父类泛型
 * 1、属性类型由什么决定:
 *  父类中,随父类而定
 *  子类中,随子类而定
 * 2、方法重写由什么决定:
 *  随父类而定
 * @param 
 */
public abstract class Father {
	T name;
	public abstract void test(T t);
}
/**
 * 第一种可行情况:子类声明时指定具体类型
 * 属性类型为具体类型
 * 方法同理
 */
class Child1 extends Father{
	String t2;
	@Override
	public void test(String t) {
	}	
}
/**
 *第二种可行情况: 子类为泛型类 ,类型在使用时确定
 */
class Child2 extends Father{
	T1 t2;
	@Override
	public void test(T t) {
	}
}
/**
 * 第三种可行情况:子类为泛型类,父类不指定类型 ,泛型的擦除,使用Object替换
 */
class Child3 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{
	String name;	
	@Override
	public void test(T t) {
	}
*/
NO.2:泛型的接口:

JAVA学习笔记36——泛型2:泛型继承、擦除+泛型接口+泛型无多态、通配符_第2张图片

看一个示例代码:

/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 * @param 
 */
public interface Comparable {
	void compare(T t);
}
//声明子类指定具体类型
class Comp implements Comparable{
	public void compare(Integer t) {
	}
}
//擦除
class Comp1 implements Comparable{
	public void compare(Object t) {
		// TODO Auto-generated method stub
	}
}
//父类擦除,子类泛型
class Comp2 implements Comparable{
	@Override
	public void compare(Object t) {
	}
}
//子类泛型>=父类泛型
class Comp3 implements Comparable{
	@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();
	}
}
那么既然泛型下面不允许使用多态,那么如果我们想实现多态的功能该怎么办呢?那就是使用通配符:

JAVA学习笔记36——泛型2:泛型继承、擦除+泛型接口+泛型无多态、通配符_第3张图片

示例代码:

/**
 * 通配符
 * ?类型不定,使用时确定类型
 * ?使用:声明类型|声明方法上,不能声明类或使用时
 * ? extends : <= 上限  指定类型 子类或自身
 * ? super :>=下限   指定类型 为自身或父类
 * @author Administrator
 *
 */
public class Student {
	T score;
	public static void main(String[] args) {
		Student stu = new Student();
		test(new Student());
		
		test2(new Student());
		//test3(new Student()); //泛型没有多态		
		
		//test4(new Student()); //<
		 stu  = new Student();;
		//test4(stu); //使用时确定类型
		test4(new Student());
		test4(new Student());
		
	}
	public static void test(Student stu){
		
	}
	public static void test3(Student stu){
		
	}
	// <=
	public static void test2(Student stu){
		
	}
	//>=
	public static void test4(Student stu){
		
	}
}
 
  






你可能感兴趣的:(JAVA学习,java,泛型,博客,教学,源代码)