Java泛型

泛型类：

/**
 * 泛型类：类名后面尖括号，里面一般使用T代表type,K、V分别代表key、value,E代表element
 * 使用时确定类型
 * 注意：
 * 1、泛型只能使用引用类型如Integer,不能使用基本数据类型
 * 2、泛型声明时不能使用在静态属性和静态方法上，因为他们定义时必须确定类型，如果使用泛型，编译不通过
 * @author 30869
 *
 */
public class Generic_Test<T1,T2> {
	private T1 javaScore;
	private T2 oracleScore;
	
		
	
	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 test(T1 t){};//不允许
	//public static T1 i;
	public static void main(String[] args) {
		Generic_Test<String, Integer> generic=new Generic_Test<String,Integer>();
		//使用泛型属性：1、检查类型，2、类型转换
		generic.setJavaScore("64789");
		generic.setOracleScore(123456);
		String javaScore=generic.getJavaScore();
		int oracleScore=generic.getOracleScore();//自动拆箱（Integer）
	}
}

泛型方法：

/**
 * 泛型方法：只能访问对象信息，不能修改
 * @author 30869
 *
 */
public class Generic_method {
	
	
	
	public static <T> void test(T t){
		System.out.println(t);
		//t=789;//不能修改
	}
	public static void main(String[] args) {
		test("asd");//t--->String
	}
}

泛型接口：

/**
 * 泛型接口：泛型字母只能用在方法中，不能用于全局常量
 * @author 30869
 *
 */
public interface Generic_interface<T> {
	void generic(T t);
}

泛型通配符：

import java.util.ArrayList;
import java.util.List;

public class Fruit {
	/**
	 * 通配符?上限：extends <= 
	 * 即子类 或自身 * 一般用于限制操作 不能使用在添加数据，一般是使用在读取数据上
	 * 
	 * 通配符?下限：super >= 
	 * 即父类或自身 不能添加父类数据
	 * 
	 * 泛型嵌套 泛型没有多态 泛型没有数组
	 * 
	 * JDK1.7 创建对象时不用指定具体类型
	 *     Object
	 *        | 
	 *      Fruit
	 *       / \ 
	 *   Apple Pear 
	 *     | 
	 * FujiApple
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// extends 为上限
		Test<Fruit> t1 = new Test<Fruit>();
		Test<Apple> t2 = new Test<Apple>();
		Test<Pear> t3 = new Test<Pear>();
		Test<FujiApple> t4 = new Test<FujiApple>();

		// 调用方法
		List<? extends Fruit> list1 = new ArrayList<Fruit>();
		test(list1);
		List<Fruit> list2 = new ArrayList<Fruit>();
		test(list2);
		List<Apple> list3 = new ArrayList<Apple>();
		test(list3);
		List<Pear> list4 = new ArrayList<Pear>();
		test(list4);
		List<FujiApple> list5 = new ArrayList<FujiApple>();
		test(list5);
		// ? extends Apple
		List<? extends Apple> list6 = new ArrayList<FujiApple>();
		test(list6);
	}

	// ? extends Fruite
	public static void test(List<? extends Fruit> list) {

	}

	/**
	 * 泛型类
	 * 
	 * @author 30869
	 *
	 * @param <T>
	 */
	static class Test<T extends Fruit> {

	}
}

class Apple extends Fruit {

}

class Pear extends Fruit {

}

class FujiApple extends Apple {

}

自定义泛型：

/**
 * 自定义泛型，继承
 * 父类，子类的应用
 * @author 30869
 *子类泛型大于等于父类
 *属性类型：
 *子类中 ：随子类定
 *父类中 ：随父类定
 *方法重写：同一随父类定
 *
 *接口同理
 */

//父类使用泛型
public abstract class Custom_generic<T> {
	T name;
	public abstract void test(T t);
}
//类型在使用时确定具体类型
//声明子类属性也只能是该类型
//方法同理
 class child extends Custom_generic<String>{

	@Override
	public void test(String t) {
		this.name="456";//name 同时也是声明父类泛型时的类型String
	}
	
}
 /**
  * 子类为泛型
  * @author 30869
  *
  * @param <T>
  */
//实现类(子类)为泛型类，泛型需一致，不能少
 class child2<T> extends Custom_generic<T>{

	@Override
	public void test(T t) {
		
	}
	 
 }
 /**
  * 子类为泛型，父类类型不指定
  * @author 30869
  *
  * @param <T1>
  * @param <T2>
  */
 class child3<T1,T2> extends Custom_generic{//泛型的擦除，使用Object替换

	@Override
	public void test(Object t) {
		
	}
	 
 }
 /**
  * 子类父类同时擦除，自动Object替换
  * 属性类型可自定义，泛型不可用
  * @author 30869
  *注意：不能子类擦除，父类指定，要么父类擦除，要么同时擦除，要么指定类型
  */
 class child4 extends Custom_generic{
	 String name;
	 //T age;
	@Override
	public void test(Object t) {
		
	}
	 
 }