一 : 泛型的使用场景
-
在集合中使用泛型
若集合中没有使用泛型,任何Object及其子类的对象都可以添加进来,强转为非接收类型时,可能报ClassCastException的异常
泛型写法:
public void test2() {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Iterator<Integer>it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
-
泛型与继承的关系
若类A 是 类B的子类,那么List<A>就不是List<B>的子接口
public void test5() {
Object obj = null;
String str = "雪芙";
obj = str;
Object[] obj1 = null;
String[] str1 = new String[] {"AA","BB","CC"};
obj1 = str1;
//报错
List<Object> list = null;
List<String> list1 = new ArrayList<String>();
List = List1;
//假设 List = List1;满足
//list.add(123)
//list1.get(0);//出现问题,所以假设不满足
}
-
通配符的使用
① List<A>,List<B>...都是List<?>子类
List<?> list = null;
List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();
list = list1;
list = list2;
②? extends A:可以存放A及其子类
List<? extends Number > list3 = null;
List<Integer> list4 = null;
list3 = list4;
③? super A:可以存放A及其父类
List<Object> list1 = new ArrayList<Object>();
List<? super Number > list5 = null;
list5 = list1;
-
通配符的注意事项
可以读取声明为通配符的集合类对象,但却不允许向声明为通配符的集合类中写入对象
List<String> list = new ArrayList<>();
list.add("xf");
list.add("22");
List<?> list1 = list;
可以读取声明为通配符的集合类的对象
Iterator<?> iterator = list1.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
不允许向声明为通配符的集合类中写入对象
错误:
list1.add("dfdf");
list1.add(123);
二 : 自定义泛型类
注意 :
①不可以在静态方法中使用泛型的声明
② 不能再try-catch中使用类的泛型声明
public class Order<T> {
private String orderName;
private int orderId;
private T t;
List<T> list = new ArrayList<>();
public void add() {
list.add(t);
}
//声明泛型方法
public <E>E getE(E e) {
return e;
}
//不可以在静态方法中使用泛型的声明
// public static void show() {
// System.out.println(t);在实例化后
//
// }
//不能再try-catch中使用类的泛型声明
// public void info() {
// try {
//
// } catch (T e) {
//
// }
//
// }
//实现数组到集合的复制
public <E> List<E> fromArrayToList(E[] e,List<E> list) {
for(E e1: e) {
list.add(e1);
}
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 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>{
}
当实例化泛型类对象时,指明泛型类的类型,对应的类中所有泛型的位置,都变为实例化中指定的泛型的类型
Order<Boolean> order = new Order<Boolean>();
order.setT(true);
order.getT();
order.add();
List<Boolean> list = order.list;
System.out.println(list);
如果我们自定义了泛型类,但在实例化时没有使用,那么默认是Object类型
Order order = new Order();
泛型方法,当通过对象调用泛型方法时(Order 中的fromArrayToList)指明泛型方法的类型
Integer[] in = new Integer[] {1,2,3};
List<Integer> list2 = new ArrayList<>();
List<Integer> list3 = order.fromArrayToList(in, list2);
System.out.println(list3);
