泛型的使用
泛型是jdk5.0新增的特性，
在集合中使用泛型的總結：
- 集合介面或集合類在jdk5.0時都修改為帶泛型的結構，
- 在實體化集合類時，可以指明具體的泛型型別，
- 指明完以后，在集合類或介面中凡是定義類或介面時，內部結構(比如：方法、構造器、屬性等)使用到類的泛型的位置，都指定為實體化時的泛型型別，比如：add(E e) ----> 實體化以后：add(Integer e)
注意點：泛型的型別必須是類，不能是基本資料型別，需要用到基本資料型別的位置，拿包裝類替換，
如果實體化時，沒有指明泛型的型別，默認型別為java.lang.Object型別，
在集合中使用泛型之前的情況
@Test
public void test1(){
ArrayList list = new ArrayList();
//需求：存放學生成績
list.add(78);
list.add(76);
list.add(89);
list.add(88);
//問題一：型別不安全
// list.add("Tom");
for (Object score : list) {
//問題二：強轉時，可能出現ClassCastException
int stuScore = (int) score;
System.out.println(stuScore);
}
}
ArrayList集合使用泛型
@Test
public void test2(){
ArrayList<Integer> list = new ArrayList<>();
list.add(78);
list.add(76);
list.add(89);
list.add(88);
//編譯時，就會進行型別檢查，保證資料的安全
// list.add("Tom");
//方式一：
// for (Integer score : list) {
// //避免了強轉操作
// int stuScore = score;
// System.out.println(stuScore);
// }
//方式二：
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer stuScore = iterator.next();
System.out.println(stuScore);
}
}
HashMap集合使用泛型
@Test
public void test3(){
// HashMap<String, Integer> map = new HashMap<String, Integer>();
//jdk7新特性：型別推斷
HashMap<String, Integer> map = new HashMap<>();
map.put("Tom",87);
map.put("Jerry",87);
map.put("Jack",67);
//泛型的嵌套
Set<Map.Entry<String, Integer>> entry = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
while (iterator.hasNext()){
Map.Entry<String, Integer> e = iterator.next();
String key = e.getKey();
Integer value = https://www.cnblogs.com/koito/archive/2021/06/27/e.getValue();
System.out.println(key +"----" + value);
}
}
自定義泛型結構的注意點
泛型結構包含泛型類、泛型介面以及泛型方法，
關于自定義泛型類、泛型介面的一些注意點：
- 如果子類在繼承帶泛型的父類時，指明了泛型型別，則實體化子類物件時，不再需要指明泛型，
- 泛型類可能有多個引數，此時應將多個引數一起放在尖括號內，比如:<E1,E2,E3>
- 泛型類的構造器如下:public GenericClass(){},而右邊則是錯誤的:public GenericClass
(){} - 實體化后，操作原來泛型位置的結構必須與指定的泛型型別一致，
- 泛型不同的參考不能相互賦值，
- 泛型如果不指定，將被擦除，泛型對應的型別均按照Object處理，但不等價于Object，建議:泛型要使用一路都用，要不用，一路都不要用，
- 如果泛型結構是一個介面或抽象類，則不可創建泛型類的物件，
- jdk1.7新增泛型的簡化操作（型別推斷）：ArrayList
flist = new ArrayList<>(); - 泛型的指定中不能使用基本資料型別，可以使用包裝類替換，
- 靜態方法中不能使用類的泛型，
- 例外類不能宣告為泛型類，
- 不能使用new E[]，但是可以:E[] elements = (E[])new Object[capacity];
自定義泛型類
自定義泛型類
//自定義泛型類
public class Order<T> {
String orderName;
int orderId;
//類的內部結構就可以使用類的泛型
T orderT;
public Order(){}
public Order(String orderName,int orderId,T orderT) {
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
}
//如下的三個方法都不是泛型方法
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
//靜態方法中不能使用類的泛型，
// public static void show(T orderT){
// System.out.println(orderT);
// }
}
測驗自定義的泛型類
@Test
public void test1(){
//如果定義了泛型類，實體化沒有指明類的泛型，則認為此泛型型別為Object型別
//要求：如果定義了類是帶泛型的，建議在實體化時要指明類的泛型，
Order order = new Order();
order.setOrderT(123);
order.setOrderT("ABC");
//建議：實體化時指明類的泛型
Order<String> order1 = new Order<>("orderAA",1001,"order:AA");
order1.setOrderT("AA:hello");
}
自定義泛型方法
泛型方法：在方法中出現了泛型的結構，泛型引數與類的泛型引數沒有任何關系，
泛型方法所屬的類是不是泛型類都沒有關系，
泛型方法，可以宣告為靜態的，原因：泛型引數是在呼叫方法時確定的，并發在實體化類時確定的，
public <E> ArrayList<E> copyFromArrayToList(E[] arr) {
ArrayList<E> list = new ArrayList<>();
for (E e : arr) {
list.add(e);
}
return list;
}
測驗自定義的泛型方法
@Test
public void test2(){
Order<String> order = new Order<>();
Integer[] arr = {1,2,3,4};
//泛型方法在呼叫時，指明泛型引數的型別，
ArrayList<Integer> list = order.copyFromArrayToList(arr);
System.out.println(list);
}
泛型在繼承方面的體現
雖然A是B的父類，但是G<A>和G<B>二者不具備子父類關系，二者是并列關系，
測驗代碼
@Test
public void test1() {
Object obj = null;
String str = null;
obj = str;
Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2;
//編譯不通過
// Date date = new Date();
// str = date;
ArrayList<Object> list1 = null;
ArrayList<String> list2 = null;
//此時的list1和list2的型別不具有子父類關系
//編譯不通過
// list1 = list2;
//使用反證法證明：假設list1 = list2;成立，則呼叫list1.add(123);會導致混入非String的資料，出錯，
}
補充：類A是類B的父類，A<G> 是 B<G>的父類，
@Test
public void test2(){
AbstractList<String> list1 = null;
ArrayList<String> list2 = null;
list1 = list2;
}
通配符的使用
為解決上述問題，Java引入了通配符：?
類A是類B的父類，G<A>和G<B>是沒有關系的，二者共同的父類是：G<?>
注意：不能對ArrayList<?>其內部添加資料（除開null，但向其中添加null也意義不大），
ArrayList<?>允許讀取資料，讀取的資料型別為Object，
@Test
public void test3(){
ArrayList<Object> list1 = null;
ArrayList<String> list2 = null;
ArrayList<?> list = null;
list = list1;
list = list2;
// 編譯通過
// print(list1);
// print(list2);
ArrayList<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list = list3;
//添加(寫入)：對于ArrayList<?>就不能向其內部添加資料，
//除了添加null之外，
// list.add("CC");
list.add(null);
//獲取(讀取)：允許讀取資料，讀取的資料型別為Object，
Object o = list.get(0);
System.out.println(o);
}
public void print(ArrayList<?> list) {
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.hasNext();
System.out.println(obj);
}
}
有限制條件的通配符的使用
? extends A: G<? extends A> 可以作為G<A>和G<B>的父類，其中B是A的子類
? super A: G<? super A> 可以作為G<A>和G<B>的父類 ，其中B是A的父類
@Test
public void test4() {
ArrayList<? extends Person> list1 = null;
ArrayList<? super Person> list2 = null;
ArrayList<Student> list3 = new ArrayList<>();
ArrayList<Person> list4 = new ArrayList<>();
ArrayList<Object> list5 = new ArrayList<>();
list1 = list3;
list1 = list4;
// list1 = list5;
// list2 = list3;
list2 = list4;
list2 = list5;
//讀取資料
list1 = list3;
Person p = list1.get(0);
//編譯不通過
// Student s = list1.get(0);
list2 = list4;
Object obj = list2.get(0);
//編譯不通過
// Person obj = list2.get(0);
//寫入資料：
//編譯不通過
// list1.add(new Student());
//編譯通過
list2.add(new Person());
list2.add(new Student());
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/288566.html
標籤：其他
上一篇：OSG編譯安裝-MSVC