java（泛型）

 

1.例子

/**
 * 泛型的使用
 * 在集合中使用泛型
 * 注意点：
 * 1.泛型的类型必须是类，不能是基本数据类型，需要用到基本数据类型的位置，需要使用其包装类
 * 2.如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型
 */
public class GenericTest {

    @Test
    public void test1() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(11);
        list.add(22);
        list.add(33);
        for(Integer s : list) {
            int scope = s;
            System.out.println(scope);
        }
    }

    @Test
    public void test2() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(11);
        list.add(22);
        list.add(33);
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            int scope = iterator.next();
            System.out.println(scope);
        }
    }

    @Test
    public void test3() {
        Map<String,Integer> map = new HashMap<String, Integer>();
        map.put("jack",22);
        map.put("lilei",33);
        map.put("zhangsan",44);
        //泛型的嵌套
        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();
            int value = e.getValue();
            System.out.println(key+" ---- " +value);
        }
    }
}

 

2. Order例子

public class Order<T> {
    String orderName;
    int orderId;
    T orderT;

    public Order() {
       // T[] t = new T[10]; 编译不通过
      //  T[] t = (T[])new Object[10]; 编译通过

    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    /**
     * 泛型方法: 在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，
     * 换句话说，泛型方法所属的类是不是泛型类都没有关系
     * 泛型方法，也可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定
     * @param arrays
     * @param <E>
     * @return
     */
    public <E> List<E> getList(E[] arrays) {
        List<E> list = new ArrayList<E>();
        for(E e : arrays) {
            list.add(e);
        }
        return list;
    }

    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 getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

public class SubOrder extends Order<Integer>{ } public class SubOrder1<T> extends Order<T> { }

public class GenericTest1 {

    @Test
    public void test1() {
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //如果定义了类是带泛型的，建议在实例化时要指明类的泛型
        Order order = new Order();
        order.setOrderT("ss");
        order.setOrderT(11);
    }

    @Test
    public void test2() {
        Order<String> order = new Order<String>();
        order.setOrderT("11");
        //order.setOrderT(2); 编译不通过，报错
    }

    @Test
    public void test3() {
        //SubOrder是个普通类，由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型
        SubOrder subOrder = new SubOrder();
        subOrder.setOrderT(11);

        SubOrder1<String> subOrder1 = new SubOrder1<String>();
        subOrder1.setOrderT("ss");
    }

    @Test
    public void test4() {
        Order<String> order = new Order<String>();
        Integer[] integers = new Integer[]{1,2,3,4};
        String[] strings = new String[]{"zhangsan","lisi","wangwu"};
        List<Integer> list = order.getList(integers);
        List<String> list1 = order.getList(strings);
        System.out.println(list);
        System.out.println(list1);

    }

}

 

3.

 

 

 

 

 

 

 

 

 

 

 

 4.通配符的使用

public class GenericTest2 {

    @Test
    public void test1() {

        List<String> list1 = new ArrayList<String>();
        list1.add("st");
        list1.add("tt");
        List<Integer> list2 = new ArrayList<Integer>();
        list2.add(11);
        list2.add(22);
        List<?> list = null;
        list = list1;
        list = list2;
        print(list1);
        print(list2);

    }

    public void print(List<?> list) {

        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object o = iterator.next();
            System.out.println(o);

        }

    }
}

 

5.有限制条件的通配符

 

 

/**
 * ? extends Person 表示 <= Person 的范围
 * ? super Person 表示 >= Person  的范围
 */
@Test
public void test2() {
    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;
    List<Student> list3 = new ArrayList<Student>();
    List<Person> list4 = new ArrayList<Person>();
    List<Object> list5 = new ArrayList<Object>();

    list1 = list3;
    list1 = list4;
   // list1 =list5; 这个编译不通过

    list2 = list4;
    list2 = list5;
    // list2 = list3; 这个编译不通过

    Person person = list1.get(0);
   // Student student = list1.get(0); 编译不通过，有可能是student的父类但又比Person小

    Object o = list2.get(0);
   // Person person1 = list2.get(0); 编译不通过，有可能是Person的父类

    //写入数据
   // list1.add(new Student()); 编译不通过
   // list1.add(new Person()); 编译不通过

    list2.add(new Student()); //可以用多态理解
    list2.add(new Person());  //可以用多态理解  
}