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()); //可以用多态理解
}