jzman

//定義泛型類
class 類名<T>{
    
}

/**
 * 定義泛型類
 * @author jzman
 * @param <T>
 */
public class GenercityClass<T1,T2> {
	
	private T1 score;
	private T2 desc;
	
	public GenercityClass() {}
	
	public GenercityClass(T1 score, T2 desc) {
		this.score = score;
		this.desc = desc;
	}
	public T1 getScore() {
		return score;
	}
	public void setScore(T1 score) {
		this.score = score;
	}
	public T2 getDesc() {
		return desc;
	}
	public void setDesc(T2 desc) {
		this.desc = desc;
	}
	
	public static void main(String[] args) {
		//使用時指定具體類型，具體類型只能是引用類型，不能是基本類型，如 int
		GenercityClass<Integer, String> genercity = new GenercityClass<>(90,"A");
		int score = genercity.getScore();
		String desc = genercity.getDesc();
		System.out.println("score="+score+",desc="+desc);
	}
}

GenercityClass<Integer, String> genercityClass = new GenercityClass<>();
//符合指定的具體類型
genercityClass.setScore(80);
//不能將String的值賦值給Integer類型的變量
genercityClass.setScore("A");

//定義泛型接口
interface 接口名<T>{
    方法返回值類型 方法名<T t>;
}

/**
 * 泛型接口：只能在方法中使用指定泛型
 * @author jzman
 */
public interface GenercityInterface<T> {
	//泛型不能在靜態屬性前面使用
//	T a;
	//方法中使用泛型
	void start(T t);
}

//定義泛型方法
修飾符 <T> 返回值類型 方法名{
    
}

package com.manu.genericity;

public class PersonBean {
	private String name;
	private int age;
    //省略 Getter、Setter等方法
    //...
}

/**
 * 泛型方法
 * @author jzman
 */
public class GenercityMethod {
	public static void main(String[] args) {
		PersonBean bean = new PersonBean("tom",10);
		printA("string");
		printA(bean);
		printB(bean);
	}
	//泛型不指定其超類，由於類型無法確定，只能訪問其信息
	public static <T> void printA(T t) {
		System.out.println(t);
	}
	//泛型指定超類，可以修改其泛型表示的實體信息
	public static <T extends PersonBean> void printB(T t) {
		t.setName("haha");
		System.out.println(t);
	}
}

string
PersonBean [name=tom, age=10]
PersonBean [name=haha, age=10]

/**
 * 泛型父類
 * @author jzman
 */
public abstract class GenercityEClass<T> {
	T name;
	public abstract void print(T t);
}

/**
 * 子類為泛型類，類型在使用時確定
 * @author jzman
 * @param <T>
 */
class Child1<T> extends GenercityEClass<T>{
	T t; //子類的屬性由子類決定
	@Override
	public void print(T t) {
		//父類的屬性隨父類決定
		T name = this.name;
	}
}

/**
 * 子類指定具體類型
 * @author jzman
 */
class Child2 extends GenercityEClass<String>{
	Integer t; //子類的屬性由子類決定
	@Override
	public void print(String t) {
		//父類的屬性隨父類決定
		String name = this.name;
	}
}

/**
 * 父類泛型的擦除
 * 子類是泛型類，父類不指定類型，泛型擦除是使用Object來代替
 * @author jzman
 * @param <T>
 */
class Child3<T/*,T1*/> extends GenercityEClass{
	T t;
	String t1; //子類的屬性由子類決定
	@Override
	public void print(Object t) {
		//父類的屬性隨父類決定
		Object obj = this.name;
	}
}

/**
 * 子類和父類同時泛型擦除
 * @author jzman
 */
class Child4 extends GenercityEClass{
	//只能使用具體類型
	String str; //子類的屬性由子類決定
	@Override
	public void print(Object t) {
		//父類的屬性隨父類決定
		Object obj = this.name;
	}
}

/**
 * 父類泛型的擦除
 * 子類是泛型類，父類不指定類型，泛型擦除是使用Object來代替
 * @author jzman
 * @param <T>
 */
class Child3<T/*,T1*/> extends GenercityEClass{
	T t;
	String t1; //子類的屬性由子類決定
	@Override
	public void print(Object t) {
		//父類的屬性隨父類決定
		Object obj = this.name;
	}
}

/**
 * 子類和父類同時泛型擦除
 * @author jzman
 */
class Child4 extends GenercityEClass{
	//只能使用具體類型
	String str; //子類的屬性由子類決定
	@Override
	public void print(Object t) {
		//父類的屬性隨父類決定
		Object obj = this.name;
	}
}
/**
 * 子類擦除，父類使用泛型（錯誤）
 * @author jzman
 *
class Child5 extends GenercityEClass<T>{
	@Override
	public void print(T t) {
		
	}
}
 */

class Child1<T> extends GenercityEClass<T>{
	T t; //子類的屬性由子類決定
	@Override
	public void print(T t) {
		//父類的屬性隨父類決定
		T name = this.name;
	}
	
	public static void main(String[] args) {
		//1.使用時泛型擦除
		Child1 child1 = new Child1();
		Object obj = child1.name;//屬性name為擦除後的類型Object
		//2.使用時指定類型
		Child1<String> child2 = new Child1();
		String name = child2.name;//屬性name為指定的類型 String
	}
}

//限制泛型可用類型
class <T extends AnyClass>{
    
}

/**
 * 泛型可用類型限制
 * @author jzman
 */
public class LimitGenercityClass<T extends List> {
	public static void main(String[] args) {
		// T extends：<上限,T可以是上限的子類或其本身
		LimitGenercityClass<ArrayList<String>> limitClass1 = new LimitGenercityClass<>();
		LimitGenercityClass<LinkedList<String>> limitClass2 = new LimitGenercityClass<>();
		//HashMap沒有實現List接口，故HashMap不能對泛型類實例的類型實例化
//		LimitGenercityClass<HashMap<String,String>> limitClass3 = new LimitGenercityClass<>();	
	}
}

//使用類型通配符
泛型類名稱<? extends AnyClass> a ;

/**
 * 使用通配符
 * ？ extends AnyClass:限制泛型的具體類型只能是AnyClass的子類
 * ？ super AnyClass:限制泛型的具體類型只能是AnyClass的超類
 * @author jzman
 */
public class CommonCharGenercityClass<T> {
	public static void main(String[] args) {
		//1.通配符用在類型聲明上
		CommonCharGenercityClass<? extends List> commA = null;
		//通配符中使用extends關鍵字限制了泛型只能是List的子類
		commA = new CommonCharGenercityClass<ArrayList<String>>();
		commA = new CommonCharGenercityClass<LinkedList<String>>();
//		commA = new CommonCharGenercityClass<HashMap<String>>();
		
		CommonCharGenercityClass<? super List> commB = null;
		//出錯，通配符中使用super關鍵字限制了泛型只能是 List 的超類才可以，比如Object
//		commB = new CommonCharGenercityClass<ArrayList<String>>();
		commB = new CommonCharGenercityClass<Object>();
		
		List<String> listA = new ArrayList<>();
		listA.add("tom");
		
		List<?> listB = listA;
		//使用了通配符時，由於不確定具體類型，只能獲取和刪除數據，不能添加數據，不能被調用
//		listB.add("new");
		listB.remove(0);
		System.out.println(listB);	
	}
	
	//2.通配符用在方法參數上
	public static void test(CommonCharGenercityClass<? extends List> list) {
		//...
	}
}