泛型,也许这个词造出来就不是用来让我顾名思义的。所以今天来挖挖泛型的背景和其使用方法。
第一个问题Java在设计时为什么需要泛型?
集合本身来讲是可以存储任何类型的对象;但这又造成一个麻烦,取的时候比较费事。一般情况下,我们都是需要集合只存储一种数据类型。Java为我们提供了一种方式,可以保证一个集合在定义时,就明确里面装什么类型的。这就叫:泛型。
那么问题来了,泛型咋用呢?
定义泛型的语法格式:
集合类类型<引用数据类型> 集合变量名 = new 集合类类型<引用的数据类型>();
格式1:(推荐使用) ArrayList strList = new ArrayList();
这个集合中只能存储String类型,如果想存储其它类型,在编译时就被阻止;
格式2: ArrayList strList = new ArrayList();
使用泛型集合存储自定义对象;
import java.util.List;
import java.util.Vector;
package com.mytest.demo21_使用泛型集合存储自定义对象;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Demo {
public static void main(String[] args) {
List<Student> stuList = new Vector<Student>();
Student stu1 = new Student("邓超",20);
Student stu2 = new Student("李晨",22);
Student stu3 = new Student("AngelaBaby",23);
stuList.add(stu1);
stuList.add(stu2);
stuList.add(stu3);
//遍历取出
for(int i = 0;i < stuList.size() ; i++){
Student stu = stuList.get(i);
System.out.println(stu.getName() + "," + stu.getAge());
}
}
}
例如:集合类,都支持泛型
泛型类:类本身支持泛型的语法
让我们的MyArrayList支持泛型
1.在类名后加:<变量名>
变量名:可以是大写,可以小写,可以多个,用逗号隔开
这个变量名就类似于一个说明:它说明一个类型;在使用是的编译器确定。
public class MyArrayList<T> {
private Object[] objArray = new Object[10];
private int count = 0;
boolean add(T obj){
objArray[count] = obj;
count++;
return true;
}
}
public class Demo {
public static void main(String[] args) {
MyArrayList<String> list = new MyArrayList<String>();
list.add("10");
// list.add(20);
}
}
泛型的通配符:
1.泛型通配符<?>
任意类型,如果没有明确,那么就是Object以及任意的Java类了
2.? extends E
向下限定,E及其子类
一:引用可以指向什么类型的对象:E的子类泛型的集合;
二:不能向集合中添加任何类型的元素,因为不确定是哪个E的子类类型;
三:取出时必须使用E或者E的父类型接收;
3.? super E
向上限定,E及其父类
一:引用可以指向什么类型的对象:任何B及B的父类类型的集合
二:可以添加什么类型的元素?任何的B及B的子类对象都可以;
三:取出来的是什么类型的?任何类型都不可以;
class A{}
class B extends A{}
class C extends B{}
class D extends B{}
public class Demo {
public static void main(String[] args) {
List<?> list1 = new ArrayList();
List<?> list2 = new ArrayList<Object>();
List<?> list3 = new ArrayList<Student>();
List<?> list4 = new ArrayList<String>();
List<?> list5 = new ArrayList<Integer>();
/* 因为List<?>的声明,不确定是什么类型,所以什么类型都不可以添加;
但是这个引用可以指向任何类型的集合;
一般不用来存东西;
一般用于方法的返回值,用于从里面取东西;*/
list5.add("aaa");
list5.add(20);
list5.add(new Student("张三",20));
//2.? extends E:
List<? extends B> list6 = new ArrayList<>();
//一:引用可以指向什么类型的对象:B的子类泛型的集合;
list6 = new ArrayList<B>();
list6 = new ArrayList<C>();
// list6 = new ArrayList<A>();//NO
//二:可以添加什么类型的元素?
//使用? extends E 不能向集合中添加任何类型的元素,因为不确定是哪个B的子类类型;
/*list6.add(new B());//No
list6.add(new C());//No
list6.add(new A());//No
list6.add("aaa");//No
list6.add(20);//No
list6.add(new Object());//No
*/
//三:取出来的是什么类型的?必须使用B或者B的父类型接收
A a = list6.get(0);//OK的,多态
B b = list6.get(0);//OK的,多态
// C c = list6.get(0);//No
//? super E
//一:引用可以指向什么类型的对象:任何B及B的父类类型的集合
List<? super B> list7 = new ArrayList<>();
list7 = new ArrayList<A>();
list7 = new ArrayList<B>();
// list7 = new ArrayList<C>();//No
// list7 = new ArrayList<D>();//No
//二:可以添加什么类型的元素?任何的B及B的子类对象都可以;
// list7.add(new A());//No
list7.add(new B());//OK的,多态
list7.add(new C());//OK的,多态
//三:取出来的是什么类型的?任何类型都不可以
/*A a1 = list7.get(0);//No
B b1 = list7.get(0);//No
C c1 = list7.get(0);//No
D d1 = list7.get(0);//No
*/
}
}
下面我们来扒扒这个泛型在使用过程中可能会出现的一些错误,其中有哪些是理解易出错还是压根就难以理解,就简单举个栗子吧!
兼容性(也就是哪些写法是可以通过编译的):
Collection c = new Vector();//考虑到对以前代码的兼容性,编译器是可以通过的。
参数化类型可以引用一个原始类型的对象,编译时会报告警告。
Collection c = new Vector();//原来的方法接收一个集合参数,新的类型也要能传进去。原始类型可以引用一个参数化类型的对象,编译时会报告警告。
Vector v = new Vector( ); //错误!
如果以后从v中取出的对象当作String用,而v实际指向的对象中可以加入任意的类型对象。
Vector v = new Vector( ); //错误!
如果以后可以向v中加入任意的类型对象,而v实际指向的集合中只能装String类型的对象
编译器不允许创建泛型变量的数组。
Vector vectorList[ ] = new Vector[10]; //错误!
在创建数组实例时,数组的元素不能使用参数化的类型。
经过这些例子的练手,我可以更好地理解出泛型的设计目的了。
总体而言,泛型是对Java语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。当没有使用泛型时,只要是对象,不管是什么类型的对象,都可以存储进同一个集合中。使用泛型集合,可以将一个集合中的元素限定为一个特定类型,集合中只能存储同一个类型的对象,这样更安全;并且当从集合获取一个对象时,编译器也可以知道这个对象的类型,不需要对对象进行强制类型转换,更加方便。