Java泛型介绍
泛型：实现了参数化类型，使代码可以应用于多种类型。
泛型的引出：
先看以下代码：
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("aa");
al.add("bbb");
al.add("cccc");
al.add(1);
for(Iterator it = al.iterator(); it.hasNext();){
Object obj = it.next();
String str = (String)obj;
System.out.println(str.length());
}
}
代码编译通过，但是在运行后报出以下异常：
产生该异常的原因，在List中即添加了字符串又添加了Integer，而从List中取出的对象都是object，当对对象应用持有的方法的时候，需要向下转行，只要使用向下转型就有可能发生异常。
使用泛型对集合中持有的对象进行限定：
public static void main(String[] args) {
/**
* 泛型
*/
ArrayList<String> als = new ArrayList<String>();
als.add("aa");
als.add("bbb");
als.add("cccc");
Iterator<String> its = als.iterator();
while(its.hasNext()){
String next = its.next();
System.out.println(next);
}
}
泛型的好处：
- 把运行时期的问题，提前到编译器。
- 泛型技术属于编译时期的技术。
- 简化程序运行时期的负担。
- JDK7对泛型进行升级，此次升级仅仅是为了简化操作。
____________________________________________________________________________________________
泛型的应用
类上的泛型：
在定义类的时候，在类上写的泛型。这个类就是泛型类。
在创建对象的时候，来明确具体的泛型所指的数据类型。
class Demo<Q> {
public void run(Q q){
System.out.println(q);
}
}
类上泛型的应用：
假设现在有一个需求，有一系列类，每个类中都有对属性设置值和取值的方法，如果不使用泛型,代码如下：
class Demo2 {
int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
}
class Demo3 {
String s;
public String getS() {
return s;
}
public void setS(String s) {
this.s = s;
}
}
class Demo4 {
Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
public class Test{
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>public static void main(String[] args) {
<span style="white-space:pre"> </span>Demo<Integer> demo = new Demo<Integer>();
<span style="white-space:pre"> </span>demo.run(11);
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>Demo4 demo4 = new Demo4();
<span style="white-space:pre"> </span>demo4.setObj(new Run());
<span style="white-space:pre"> </span>Object str1 = demo4.getObj();
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>
}
可以看出，即使使用Object来代替具体属性，如果需要对对象应用其持有的方法，还是需要向下转型，还是可能抛出异常。
如果使用泛型，就不一样了：
class Demo5<T> {
T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
public class Test{
public static void main(String[] args) {
Demo5<Integer> demo5 = new Demo5<Integer>();
demo5.setT(22);
System.out.println(demo5.getT());
Demo5<String> demo55 = new Demo5<String>();
demo55.setT("aaaa");
System.out.println(demo55.getT());
Demo5<Run> demo555 = new Demo5<Run>();
demo555.setT(new Run());
demo555.getT().start();
}
}
Run类：
public class Run {
public void start(){
System.out.println("-----start------");
}
}
输出：
————————————————————————————————————————————————————————
方法上的泛型：
现在有多个不同集合，需要对集合中的信息进行打印输出：
public class Test {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("aa");
al.add("bb");
al.add("cc");
printCollection(al);
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(22);
al2.add(24);
al2.add(25);
printCollection(al2);
LinkedList<String> ll = new LinkedList<String>();
ll.add("Java");
ll.add("C++");
ll.add("Python");
printCollection(ll);
}
public static void printCollection(Collection<?> list){
for(Iterator<?> it = list.iterator(); it.hasNext();) {
System.out.println(it.next());
}
System.out.println("------------------");
}
}
输出：
泛型的通配符：
在使用泛型的时候，如果不知道具体的类型，可以使用问号作为通配符来接收任意的类型。
通配符的弊端：
一旦使用了通配符，那么这时候接收到的任意类型都会被当作Object类型处理。
泛型的上限：
Collection<? extends Person>所接收的访问为Person及其子类。
public class Test2 {
public static void main(String[] args) {
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("zhangsan", 22 , "nan"));
al.add(new Person("lisi", 23, "nv"));
al.add(new Person("wangwu", 25, "nan"));
printCollection(al);
LinkedList<Student> ll = new LinkedList<Student>();
ll.add(new Student("张三明", 23, "男"));
ll.add(new Student("李小白", 34, "男"));
printCollection(ll);
TreeSet<String> ts = new TreeSet<String>();
ts.add("aa");
ts.add("bb");
ts.add("cc");
//printCollection(ts);
}
public static void printCollection(Collection<? extends Person> c) {
for(Iterator<? extends Person> it = c.iterator(); it.hasNext();) {
System.out.println(it.next());
}
System.out.println("----------------------------------");
}
}
Person类和Student类
public class Person {
private String name;
private int age;
private String sex;
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;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
public Person(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public Person() {
}
}
public class Student extends Person{
public Student() {
super();
}
public Student(String name, int age, String sex) {
super(name, age, sex);
};
}输出：
——————————————————————————————————————————————————————
接口上的泛型
interface Inter<W> {
public void run(W w);
}
class InterImpl implements Inter<String> {
@Override
public void run(String w) {
System.out.println(w);
}
}
class InterImpl2<T> implements Inter<T> {
@Override
public void run(T t) {
System.out.println(t);
}
}
public class Test3 {
public static void main(String[] args) {
InterImpl ii = new InterImpl();
ii.run("aaaa");
InterImpl2<String> ii2 = new InterImpl2<String>();
ii2.run("bbbbb");
}
}<strong>
</strong>输出：
接口上的泛型，有两种使用方法：
- 在实现接口的时候指定具体类型。
- 如果在实现接口的时候，还不知道具体类型，那么可以在创建类的时候指定具体类型。
泛型的细节：
- 在描述好泛型之后，尖括号中是什么类型，那么在使用的时候，只能使用这个类型：
List<Object> list = new ArrayList<Object>()，说明这个集合中只能存放Object类型，而不能存放其他对象。
- 在描述泛型的时候，前后的数据类型必须一致：
List<String> list = new ArrayList<Integer>();错误。