泛型的使用

泛型的使用
        1. 在集合中使用泛型
        2.在定义泛型类，泛型接口，泛型方法
        3.泛型于继承的关系
        4.通配符

注意：1.不可以在static方法中使用泛型的声明，因为静态方法的加载随着类的加载而加载，

               泛型是在创建实例的时候加载的(晚)。

            2.不能在try-catch中使用类的泛型的声明

               try{

               }catch（T e）{

               }

TestGeneric

package com.aff.Gen;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Test;

/*
 泛型的使用
        1. 在集合中使用泛型
        2.在定义泛型类，泛型接口，泛型方法
        3.泛型于继承的关系
        4.通配符
 */
public class TestGeneric {

    // 集合中没有使用泛型的情况下
    @Test
    public void test1() {
        List list = new ArrayList();
        list.add(23);
        list.add(35);
        list.add(56);
        list.add(new String("aa"));

        for (int i = 0; i < list.size(); i++) {
            int score = (Integer) list.get(i);
            System.out.println(score);
        }
    }

    
    
    
    // 1在集合中使用泛型
    @Test
    public void test2() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(23);
        list.add(35);
        // list.add(new String("aa"));//添加不进去会报错的
        // for (int i = 0; i < list.size(); i++) {
        // System.out.println(list.get(i));
        // }
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    
    
    // 泛型的使用
    @Test
    public void test3() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("aa", 23);
        map.put("bb", 33);
        map.put("cc", 6543);
        map.put("dd", 276);

        Set<Map.Entry<String, Integer>> set = map.entrySet();
        for (Map.Entry<String, Integer> o : set) {
            System.out.println(o.getKey() + "----->" + o.getValue());
        }
    }

    
    
    // 自定义泛型类的使用
    @Test
    public void test4() {
        /*
         * 1.实例化泛型类的对象时，指明泛型的类型 指明以后，对应的类中所有使用泛型的位置，
             都变为实例化中指定的泛型的类型
         * 2.如果我们自定义了泛型类，但是实例化时没有使用，那么默认类型是Object类的
         */
        Order<Boolean> order = new Order<Boolean>();
        // order.getT();
        order.setT(true);
        System.out.println(order.getT());

        order.add();
        List<Boolean> list = order.list;
        System.out.println(list);

        SubOrder o = new SubOrder();
        List<Integer> list1 = o.list;
        System.out.println(list1);

        // 通过对象调用泛型方法时，指明泛型方法的类型
        Integer i = order.getE(23);
        double d = order.getE(3.8);

        Integer[] in = new Integer[] { 1, 12, 3, 3 };
        List<Integer> list2 = new ArrayList<Integer>();
        List<Integer> list3 = order.fromArrayToList(in, list2);
        System.out.println(list3);
    }

    
    
    // 泛型于继承的关系
    //若类A是类B的子类，那么List<A> 就不是List<B>的子接口
    /*
     通配符 ?
               List<A> ,List<B>... 都是List<?>的子类
               ？ extends A  可以存放A及其A的子类
               ？ super A    可以存放A及其A的父类
     */
    @Test
    public void test5() {
        //泛型于继承的关系
        Object obj = null;
        String str =  "AA";
        obj = str;
        
        Object[] obj1 = null;
        String[] str1 = new String[]{"AA","CV","SV"};
        obj1 = str1;
        
        List<Object> list10 = null;
        List<String> list11 = new ArrayList<String>();
        //list10 = list11; //执行不通过，list11不是list10的子接口
        
        // 通配符 ?
        List<?> list =  null;
        List<Object> list1 = new ArrayList<Object>();
        List<Object> list2 = new ArrayList<Object>();
        list = list1;
        list= list2;
        
        show(list1);
        show1(list1);
        show1(list2);
        
        List<?> list20 = list1;
        //读取声明为通配符的集合类的对象
        Iterator<?> iterator = list20.iterator();
        while(iterator.hasNext()){
              system.out.println(iterator.next());
        }
        //不允许向声明为通配符的集合类中写入对象，唯一列外的是null
        list20.add();

        List<? extends Number> list3 = null;
        List<Integer> list4 = null;
        list3  =  list4;
        List<? super Number> list5 = null;//super Number 为Object 所以和list1一致了
        list5 = list1;
    }        
    
    public void show(List<Object> list){
       }
    
    public void show1(List<?> list){
      }
}

Order<T>

package com.aff.Gen;

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

public class Order<T> {
    private String orderName;
    private int orderId;
    private T t;
    List<T> list = new ArrayList<T>();

    public void add() {
        list.add(t);
    }

    // 实现数组到集合的复制
    public <E> List<E> fromArrayToList(E[] e, List<E> list) {
        for (E e1 : e) {// 数组
            list.add(e1);// 数组到集合
        }
        return list;
    }

    // 声明泛型方法
    public <E> E getE(E e) {
        return e;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Order [orderName=" + orderName + ", orderId=" + orderId + ", t=" + t + ", list=" + list + "]";
    }
}

// 在继承泛型类或者泛型接口时，可以指明泛型的类型
class SubOrder extends Order<Integer> {

}