为什么要有泛型(Generic)
public class CollectionTest {
//在集合中使用泛型之前的情况
@Test
public void testCollection(){
ArrayList list = new ArrayList();
//需求:存放学生成绩
list.add(78);
list.add(99);
list.add(100);
list.add(88);
//问题一:类型不安全
list.add("Tom");
//问题二:强转时可能会出现类型转换异常ClassCastException
for (Object score:list){
int stuScore = (Integer) score;
System.out.println(stuScore);
}
}
}
在集合中使用泛型
/**
* 在集合中使用泛型的情况:
* 1.集合接口或集合类在jdk5.0时都修改为带泛型的结构
* 2.在实例化集合类时,可以指明具体的泛型类型
* 3.指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(如方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的类型泛型
* 比如:add(E e) ---->实例化以后:add(Integer e)
* 4.注意点:泛型的类型必须是类,不能是基本数据类型,需要用到基本数据类型的位置,拿包装类替换
* 5.若实例化时没有指明泛型的类型,默认类型为Object类型。
*/
public class GenericTest {
@Test
public void test(){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(69);
list.add(100);
list.add(89);
list.add(79);
//编译时就会进行类型检查,保证数据的安全
//list.add("Tom");
for (Integer score:list){
//避免了强转操作
int stuScore = score;
System.out.println(stuScore);
}
//方式二 迭代器遍历
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
//在集合中使用泛型的情况:以HashMap为例
@Test
public void test1(){
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom",87);
map.put("Jerry",100);
map.put("Jack",99);
//泛型的嵌套
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();
Integer value = e.getValue();
System.out.println(key+"----"+value);
}
}
}
自定义泛型类和接口
public class Order<T> {
String orderName;
int orderId;
//类的内部结构可以使用类的泛型
T orderT;
public Order(){
}
public Order(String orderName,int orderId,T orderT){
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
}
public T getOrderT(){
return this.orderT;
}
public void setOrderT(T orderT){
this.orderT = orderT;
}
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;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
}
public class SubOrder extends Order<Integer>{//SubOrder不是泛型类
}
public class SubOrder1<T> extends Order<T> {//SubOrder1:仍然是一个泛型类
}
public class GenericTest1 {
@Test
public void test1(){
//如果定义了泛型类,实例化没有指明类的泛型,则认为此泛型类型为Object类型
//要求:如果定义了的类是带泛型的,那么建议在实例化时要指明类的泛型
Order order = new Order();
order.setOrderT(123);
order.setOrderT("ABC");
//建议:实例化时指明类的泛型
Order<String> order1 = new Order<String>("orderAA",1001,"Cez");
order1.setOrderT("tt");
}
@Test
public void test2(){
SubOrder sub1 = new SubOrder();
//由于子类在继承带泛型的父类时,指明了泛型类型,则实例化子类对象时,不再需要指明泛型
sub1.setOrderT(123);
SubOrder1<String> sub2 = new SubOrder1<String>();
sub2.setOrderT("order2...");
}
}
自定义泛型方法
**泛型方法:**在方法中出现了泛型的结构,泛型的参数与类的泛型参数没有任何关系。换句话说,泛型方法所属的类是不是泛型类都没有关系。
泛型方法可以声明为静态的,因为泛型参数是在调用方法时确定的,并非在实例化时确定。
public <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for (E e:arr){
list.add(e);
}
return list;
}(声明在上一章节的Order类中)
@Test
public void test3(){
Order<String> order = new Order<>();
Integer[] arr = new Integer[]{1,2,3,4};
//泛型方法在调用时,指明泛型参数的类型
List<Integer> list = order.copyFromArrayToList(arr);
System.out.println(list);
}
泛型在继承方面的体现
public class GenericTest {
//泛型在继承方面的体现
/*
类A是类B的父类,但是G<A>和G<B>二者不具备子父类关系,二者是并列关系。
补充:类A是类B的父类,则A<G>是B<G>的父类
*/
@Test
public void test1(){
Object obj = null;
String str = null;
obj = str; //√ 多态
Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2;//√ 多态
List<Object> list1 = null;
List<String> list2 = null;
//编译不通过
list1 = list2;//× 此时的list1和list2的类型不具有子父类关系
/*
反证法:
假设list1 = list2;
list1.add(123); 导致混入了非String的数据,出错
*/
show(list1);//√
show(list2);//×
}
public void show(List<Object> list){
}
@Test
public void test2(){
List<String> list1 = null;
ArrayList<String> list2 = null;
list1 = list2;
}
}
通配符的使用
- 通配符:?
/*
类A是类B的父类,G<A>和G<B>是没有关系的,二者的共同父类是G<?>
*/
@Test
public void test3(){
List<Object> list1 = null;
List<Object> list2 = null;
List<?> list = null;
list = list1;
list = list2;
print(list1);
print(list2);
}
public void print(List<?> list){
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}
}
使用通配符后数据的读取和写入要求
@Test
public void test3(){
List<?> list = null;
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list3.add("CC");
list = list3;
//添加:对于List<?>就不能向其内部添加数据。
//除了添加null
//list.add("DD");
list.add(null);
//获取:允许读取数据,读取的数据类型为Object
Object o = list.get(0);
System.out.println(o);
}
有限制条件的通配符的使用
/**
* 有限制条件的通配符的使用
* G<? extends A>: 可以作为G<A>和G<B>的父类的,其中B是A的子类
* G<? super A>:可以作为G<A>和G<B>的父类,其中B是A的父类
* @author cez
* @create 2021-01-19-14:17
*/
public class GenericTest {
@Test
public void test1(){
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 = list3;//×
list2 = list4;
list2 = list5;
//读取数据
list1 = list4;
Person p = list1.get(0);
list2 = list4;
Object obj = list2.get(0);
//写入数据
list1.add(new Student()); //×
list2.add(new Person());
list2.add(new Student());
}
}