_ A generic set of custom generic method used generic &&

Using generic
1. In generic set
2. In the definition of generic class, generic interfaces, generic method
3. Relationship inheritance generic to
4. Wildcard

Generic test

Package com.aff.Gen; 

Import of java.util.ArrayList;
 Import the java.util.HashMap;
 Import the java.util.Iterator;
 Import java.util.List;
 Import a java.util.Map;
 Import java.util.Set; 

Import org.junit.Test; 

/ * 
 use of generics 
        1. in generic set 
        2. in the definition of generic class, generic interfaces, generic method 
        3. relationship inheritance generic to 
        4. wildcard 
 * / 
public  class {TestGeneric 

    // set without the use of generics 
    @Test
     public  void test1 () { 
        List List = new new the 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.When the generic class object is instantiated, generic type specified later specified, all positions corresponding to the class of generic use, both become instantiated type specified in the generic
         * 2.If we customize a generic class, but did not use when instantiated, the default type is Object class 
         * /
        The Order <Boolean> Order = new new the Order <Boolean> ();
         // order.getT (); 
        order.setT ( to true ); 
        System.out.println (order.getT ()); 

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

        Suborder O = new new Suborder (); 
        List <Integer> = List1 o.list; 
        System.out.println (List1); 

        // call to the pan by objects when type process, the method of the type specified in the generic 
        Integer I = order.getE (23 is );
         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);
    }
}

 

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 the orderId; 
    } 

    public T Gett () {
         return T; 
    } 

    public  void SETT (T T) {
         the this .T = T; 
    } 

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

// in succession generic classes or generic interface that may indicate the type of generic 
class Suborder the extends the Order <Integer> { 

}