16泛型類
A:泛型類:
a:定義格式：
修飾符 class 類名<代表泛型的變量> { }
例如，API中的ArrayList集合：
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
}
b:使用格式：
創(chuàng)建對象時，確定泛型的類型
例如，ArrayList<String> list = new ArrayList<String>();
此時，變量E的值就是String類型
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
}
例如，ArrayList<Integer> list = new ArrayList<Integer>();
此時，變量E的值就是Integer類型
class ArrayList<Integer>{
public boolean add(Integer e){ }
public Integer get(int index){ }
}
17泛型的方法
A:泛型的方法
a:定義格式：修飾符 <代表泛型的變量> 返回值類型 方法名(參數){ }
b:泛型方法的使用:
1:例如，API中的ArrayList集合中的方法：
public <T> T[] toArray(T[] a){ }
//該方法，用來把集合元素存儲到指定數據類型的數組中，返回已存儲集合元素的數組
使用格式：調用方法時，確定泛型的類型
?例如:
ArrayList<String> list = new ArrayList<String>();
String[] arr = new String[100];
String[] result = list.toArray(arr);
此時，變量T的值就是String類型。變量T，可以與定義集合的泛型不同
public <String> String[] toArray(String[] a){ }
?
例如:
ArrayList<String> list = new ArrayList<String>();
Integer[] arr = new Integer[100];
Integer [] result = list.toArray(arr);
此時，變量T的值就是Integer類型。變量T，可以與定義集合的泛型不同
public <Integer> Integer[] toArray(Integer[] a){ }
18泛型的接口
A:泛型的接口:
/*
* 帶有泛型的接口
*
* public interface List <E>{
* abstract boolean add(E e);
* }
*
* 實現類,先實現接口,不理會泛型
* public class ArrayList<E> implements List<E>{
* }
* 調用者 : new ArrayList<String>() 后期創(chuàng)建集合對象的時候,指定數據類型
*
*
* 實現類,實現接口的同時,也指定了數據類型
* public class XXX implements List<String>{
* }
* new XXX()
*/
public class GenericDemo2 {
}
19泛型的好處
A:泛型的好處
?a:將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
?b:避免了類型強轉的麻煩。
演示下列代碼：
public class GenericDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("itcast");
//list.add(5);//當集合明確類型后，存放類型不一致就會編譯報錯
//集合已經明確具體存放的元素類型，那么在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素類型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
System.out.println(str.length()); //當使用Iterator<String>
//控制元素類型后，就不需要強轉了。獲取到的元素直接就是String類型
}
}
}
20泛型的通配符
A:泛型的通配符
/*
* 泛型的通配符
*/
public class GenericDemo {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
HashSet<Integer> set = new HashSet<Integer>();
array.add("123");
array.add("456");
set.add(789);
set.add(890);
iterator(array);
iterator(set);
}
/*
* 定義方法,可以同時迭代2個集合
* 參數: 怎么實現 , 不能寫ArrayList,也不能寫HashSet
* 參數: 或者共同實現的接口
* 泛型的通配,匹配所有的數據類型 ?
*/
public static void iterator(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
//it.next()獲取的對象,什么類型
System.out.println(it.next());
}
}
}
21泛型的限定
A:泛型的限定
/*
* 將的酒店員工,廚師,服務員,經理,分別存儲到3個集合中
* 定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法
*/
import java.util.ArrayList;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
//創(chuàng)建3個集合對象
ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
ArrayList<JingLi> jl = new ArrayList<JingLi>();
//每個集合存儲自己的元素
cs.add(new ChuShi("張三", "后廚001"));
cs.add(new ChuShi("李四", "后廚002"));
fwy.add(new FuWuYuan("翠花", "服務部001"));
fwy.add(new FuWuYuan("酸菜", "服務部002"));
jl.add(new JingLi("小名", "董事會001", 123456789.32));
jl.add(new JingLi("小強", "董事會002", 123456789.33));
// ArrayList<String> arrayString = new ArrayList<String>();
iterator(jl);
iterator(fwy);
iterator(cs);
}
/*
* 定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法 work
* ? 通配符,迭代器it.next()方法取出來的是Object類型,怎么調用work方法
* 強制轉換: it.next()=Object o ==> Employee
* 方法參數: 控制,可以傳遞Employee對象,也可以傳遞Employee的子類的對象
* 泛型的限定 本案例,父類固定Employee,但是子類可以無限?
* ? extends Employee 限制的是父類, 上限限定, 可以傳遞Employee,傳遞他的子類對象
* ? super Employee 限制的是子類, 下限限定, 可以傳遞Employee,傳遞他的父類對象
*/
public static void iterator(ArrayList<? extends Employee> array){
Iterator<? extends Employee> it = array.iterator();
while(it.hasNext()){
//獲取出的next() 數據類型,是什么Employee
Employee e = it.next();
e.work();
}
}
}
