第18章--泛型

1.泛型

 混进错误数据出错，出现类型转换异常

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

/*
 * 泛型在集合中的使用
 * 
 * 1.泛型，是jdk5.0新增的
 17  * 
 18  * 2.泛型的核心思想：就是将集中添加的数据限定为具体的类型。
 */
public class GenericTest {
    
    //在集合中使用泛型之前
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(67);
        list.add(87);
        list.add(99);
        list.add(78);
        //1.添加数据时：类型不安全
        list.add("AA");
        
        
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            //2.可能出现类型转换异常
            int score = (int) obj;
            
            System.out.println(score);
        }
        
    }
    /*
     * 集合中使用泛型的例子1
 46      * 
 47      * 在集合中使用泛型
 48      * 1.之所以能在集合接口或类中使用泛型，就是因为集合接口或类在声明时，使用了泛型。
 49      *     比如：public class ArrayList<E>{}，public interface List<E>
 50      *  
 51      * 2.实例化集合类时，就可以指明类的泛型。一旦指明以后，通过集合类的对象调用内部的结构时，凡是使用了
 52      * 类的泛型的地方，都变化为指定的类的泛型的类型。
 53      *  比如：List<Integer> list = new ArrayList<Integer>();导致add(Integer e)、
 54      *  Integer<E> iterator();
 55      *  
 56      * 3.实例化集合类时，如果没有指明类的泛型，则认为此泛型的类型是Object类型。
 57      * 
 58      * 4.泛型参数在具体指明时，只能使用引用数据类型，不能使用基本数据类型
     */
    @Test
    public void test2(){
        List<Integer> list = new ArrayList<Integer>();
        
        list.add(67);
        list.add(87);
        list.add(88);
//        list.add("BB");
        
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int score = iterator.next();
            
            System.out.println(score);
        }
    }
    
    //集合中使用泛型的例子2
    @Test
    public void test3(){
        
        Map<String,Integer> map = new HashMap<String,Integer>();
//        Map<String,Integer> map = new HashMap<>();//jdk7.新增类型推断。 比如：int[] arr = {1,2,3};
        
        map.put("MM", 78);
        map.put("JJ", 89);
        map.put("GG", 66);
        map.put("DD", 54);
//        map.put(12, "AA");
        
        Set<Entry<String, Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "--->" + value);
        }
    }
    
    //使用上泛型以后的自然排序
    @Test
    public void test4(){
        
        TreeSet<Goods> set = new TreeSet<>();
        
        Goods g1 = new Goods("eggs", 10.5);
        Goods g2 = new Goods("banana", 7.5);
        Goods g3 = new Goods("apple", 2.5);
        Goods g4 = new Goods("orange", 4.3);
        
        
        set.add(g1);
        set.add(g2);
        set.add(g3);
        set.add(g4);
        
        for(Goods g : set){
            System.out.println(g);
        }
        
        
    }
    
    //使用上泛型以后的定制排序
    @Test
    public void test5(){
        
        Comparator<Goods> com = new Comparator<Goods>(){

            @Override
            public int compare(Goods o1, Goods o2) {
                
                return o1.getGoodsName().compareTo(o2.getGoodsName());
                
            }
            
        };
        
        
        TreeSet<Goods> set = new TreeSet<>(com);
        
        Goods g1 = new Goods("eggs", 10.5);
        Goods g2 = new Goods("banana", 7.5);
        Goods g3 = new Goods("apple", 2.5);
        Goods g4 = new Goods("orange", 4.3);
        
        
        set.add(g1);
        set.add(g2);
        set.add(g3);
        set.add(g4);
        
        for(Goods g : set){
            System.out.println(g);
        }
        
        
    }
}

 2.自定义泛型类

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

/*
 * 自定义泛型类
 * 
 */
public class Order<T> {

    //在类的内部的属性、方法、构造器等中，就可以使用类的泛型
    
    String orderName;
    int orderId;
    T orderT;
    T[] arr;
    
    public Order(){
//        arr = new T[10];//错误的
        arr = (T[]) new Object[10];
    }
    
    public Order(T orderT){
        this.orderT = orderT;
    }
    
    //如下的两个方法不是泛型方法！
    public String toString(){
        return "Order[orderName:" + orderName + ",orderId:" + orderId + ",orderT:" + orderT + "]"; 
    }
    
    
    public T getOrderT(){
        return orderT;
    }
    
    //静态方法中不能使用类的泛型
//    public static T show(){
//        System.out.println(orderT);
//        return orderT;
//    }
    
    //泛型方法
43     //泛型方法所在的类，不一定是泛型类。换句话说，泛型方法与泛型类没有直接关系
44     //泛型方法，根据需要可以声明为static的
    public static <E>  List<E> copyArrToList(E[] arr){
        
        List<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        
        return list;
        
    }
    
}

import java.util.List;

import org.junit.Test;

public class GenericTest1 {
    
    @Test
    public void test1(){
//        Goods<Integer> goods1 = new Goods<>();
        
        //实例化泛型类时，没有指明类的泛型。则此时认为泛型的类型为Object
        Order order = new Order();
        order.orderT = "AA";
        
        //实例化泛型类时，指明了类的泛型，进而类中凡是使用类的泛型的位置，都变化为具体的类的泛型。
        Order<Integer> order1 = new Order<Integer>();
        order1.orderT = 123;
        Integer t = order1.getOrderT();
        
    }
    
    /*
23      * 除了在实例化泛型类时，指明类的泛型之外。还可以提供泛型类的子类时，指明泛型的类型。比如：SubOrder1
     * 
     * 
     */
    @Test
    public void test2(){
        SubOrder1 sub1 = new SubOrder1();
        sub1.orderT = "AA";
        
        SubOrder2<Integer> sub2 = new SubOrder2<>();
        Integer orderT = sub2.getOrderT();
    }
    
    @Test
    public void test3(){
        Order<String> order = new Order<>();
        
        Integer[] arr = new Integer[]{1,2,3};
        
        List<Integer> list = order.copyArrToList(arr);
        
    }
}

//SubOrder1不是泛型类
public class SubOrder1 extends Order<String>{

}

//SubOrder2仍然是一个泛型类
public class SubOrder2<T> extends Order<T>{

}

3.自定义泛型类的补充说明

 

 

 

 

4.泛型方法

 

5.泛型在继承上的体现

 

 

 

 

6.通配符的使用

 

7.有限制条件的通配符