泛型

對於泛型類（含集合類）：

自定義泛型類：

class Person<T>{//使用T型別定義變數 
	private T info;//使用T型別定義一般方法 

	public T getInfo(){
		return info; 
	} 

	public void setInfo(T info){
		this.info = info;
	}

	//使用T型別定義構造器
	public Person(){}

	public Person(T info){
		this.info = info;
	}
	//static的方法中不能宣告泛型
	//public static void show(T t){
	//}
	//不能在try-catch中使用泛型定義
	//try{}
	//catch(T t){}
} 
 

對於泛型方法：

public class DAO {
	public <E>  E get(int id, E e){
		E result = null;
		return result;
	}
} 

泛型和繼承的關係：

萬用字元：

有限制的萬用字元：

泛型應用：

此資訊屬性的型別就可以通過泛型進行宣告，然後只要設計相應的資訊類即可。

練習題

package com.atguigu.javae.generic;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.Vector;

import org.junit.Test;

/**
 * 自定義泛型類, 類名<X>
 * 泛型和物件相關, 型別的資訊最終會在建立物件時確定!
 */
class Person<X> { // X代表某型別, 既然是型別,宣告變數,作為返回值...
// 當在建立物件時未指定X的具體型別, 它的型別就是Object
	//private static int X x;
	
	private X info;
	
	public Person() {
	}
	
	public Person(X info) {
		this.info = info;
	}
	
	public void setInfo(X info) {
		try {
			this.info = info;
		//} catch (X e) { // catch 中只能捕捉Throwable及其子類 ,不可以使用型別不一定的X型別
		} catch (Throwable e) { // catch 中只能捕捉Throwable及其子類 
			e.printStackTrace();
		}
	}
	
	public X getInfo() {
		return info;
	}
	
	@Override
	public String toString() {
		return "某人, 資訊[" + info + "]";
	}
	
	/*
	public static void test(X t) { // 靜態環境中不允許使用和物件相關的泛型
		System.out.println(t);
	}*/
	
	// 泛型方法, 在返回值前面加<型別>, 一定要在形參中帶上型別資訊
	public static <Y> Y testY(Y y) { // 如果泛型方法中的泛型型別名和類中的一樣, 則會遮蔽類中的泛型
		return null;
	}
	
	
}

class Student extends Person<String> { // 在Student子類中,info屬性就是固定的String型別
}

public class GenericTest {
	
	// 寫一個方法引數是(Collection<? extends Comparable> coll)
	// 在方法中返回這個集合中的最小值
	// 寫一個測試方法, 建立List集合,儲存一些字串, 再建立Set集合, 儲存一些char, 分別使用這兩個集合呼叫以上方法,列印輸出結果
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public Comparable getMin(Collection<? extends Comparable> coll) {
		if (coll.size() == 0) {
			return null;
		}
		Iterator<? extends Comparable> iterator = coll.iterator();
		Comparable min = iterator.next();
		while (iterator.hasNext()) {
			Comparable comp = iterator.next();
			if (comp.compareTo(min) < 0) {
				min = comp;
			}
		}
		return min;
	}
	
	@Test
	public void test7() {
		List<String> list = new LinkedList<String>();
		list.add("xxx");
		list.add("bbb");
		list.add("aaa");
		list.add("ddd");
		System.out.println(getMin(list));
		
		Collection<Character> set = new HashSet<Character>();
		set.add('我');
		set.add('好');
		set.add('a');
		set.add(' ');
		System.out.println(getMin(set));
	}
	
	public double sumList(List<? extends Number> list) {
		// list就可以指向以Number及其子類為泛型的集合, 但是引用不能新增元素, 但是可以獲取元素,並且Number
		Iterator<? extends Number> iterator = list.iterator();
		double sum = 0;
		while (iterator.hasNext()) {
			Number number = iterator.next();
			sum += number.doubleValue();
		}
		return sum;
	}
	
	public double getMax(Collection<? extends Number> coll) {
		Iterator<? extends Number> iterator = coll.iterator();
		if (!iterator.hasNext()) {
			throw new RuntimeException("集合為空,沒法找最大值");
		}
		Number maxNumber = iterator.next();
		while (iterator.hasNext()) {
			Number tmpNumber = iterator.next();
			if (tmpNumber.doubleValue() > maxNumber.doubleValue()) {
				maxNumber = tmpNumber;
			}
		}
		return maxNumber.doubleValue();
	}
	
	// 寫一個方法引數是(Collection<? extends Number> coll)
	// 在方法中返回這個集合中的最大值
	// 寫一個測試方法, 建立List集合,儲存一些整數, 再建立Set集合, 儲存一些float, 分別使用這兩個集合呼叫以上方法,列印輸出結果
	

	@Test
	public void test6() {
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		list1.add(100);
		list1.add(20);
		list1.add(30);
		list1.add(1000);
		list1.add(7);
		
		System.out.println(getMax(list1));
		
		Set<Float> set = new HashSet<Float>();
		set.add(234.23f);
		set.add(1234.23f);
		set.add(3234.23f);
		set.add(2334.23f);
		set.add(234.23f);
		
		System.out.println(getMax(set));
	}
	@Test
	public void test5() {
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		list1.add(100);
		list1.add(20);
		list1.add(30);
		list1.add(10);
		list1.add(7);
		
		List<Double> list2 = new Vector<Double>();
		list2.add(3.1);
		list2.add(2.1);
		list2.add(4.1);
		list2.add(5.1);
		list2.add(1.1);
		
		double sum = sumList(list1);
		System.out.println(sum);
		
		sum = sumList(list2);
		System.out.println(sum);
		/*
		List<? extends Number> list2 = list; // list2就可以指向以Number及其子類為泛型的集合, 但是引用不能新增元素, 但是可以獲取元素,並且Number
		Iterator<? extends Number> iterator = list2.iterator();
		while (iterator.hasNext()) {
			Number number = iterator.next();
			sum += number.intValue();
		}
		System.out.println(sum);
		
		list2 = list3;
		*/
	}
	@Test
	public void test4() {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(100);
		list.add(20);
		list.add(30);
		list.add(10);
		list.add(7);
		
		List<?> list2 = list;// 只讀訪問
		Object object = list2.get(1);
		System.out.println(object);
	}
	
	@SuppressWarnings("unused")
	@Test
	public void test3() {
		// 使用?萬用字元 通常用於只讀訪問
		Person<?> person = new Person<>();
		//person.setInfo("abc");
		person.setInfo(null);
		Object object = person.getInfo();
	}
	
	@SuppressWarnings({ "static-access", "rawtypes", "unchecked", "unused" })
	@Test
	public void test2() {
		//Person<Object> person = new Person<String>("張三");
		Person<Integer> person = new Person<Integer>(30);
		String string = person.testY("abc");
		System.out.println(string);
		
		ArrayList list = new ArrayList();
		list.add(100);
		list.add(200);
		list.add(50);
		list.add(10);
		
		Integer[] tmp = new Integer[0];
		//Integer[] arr = list.toArray(tmp);
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Test
	public void test1() {
		Person person = new Person(true);
		Object valaueObject = person.getInfo();
		System.out.println(valaueObject);
		
		Person<String> person2 = new Person<String>("張三");
		String name = person2.getInfo();
		System.out.println(name);
		
		Person<Integer> person3 = new Person<Integer>(30);
		Integer integer = person3.getInfo();
		System.out.println(integer);
	}
}