泛型

java基础

泛型概述

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。

泛型格式

泛型格式：通过<>来定义要操作的引用数据类型

泛型的好处

泛型的好处：

1. 将运行时期出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全。
2. 避免了强制转换的麻烦。

在使用java提供的对象时，什么时候写泛型呢？

问：在使用java提供的对象时，什么时候写泛型呢？
答：通常在集合框架中很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
例，

import java.util.*;
class GenericDemo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc01");
        al.add("abc0991");
        al.add("abc014");
        // al.add(4);// al.add(new Integer(4));
        Iterator<String> it = al.iterator();
        while(it.hasNext()) {
            String s = it.next();
            System.out.println(s + ":" + s.length());
        }
    }
}

练习：按照字符串长度排序。
解：

import java.util.*;
class GenericDemo2 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<String>(new LenComparator());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("z");
        ts.add("hahaha");
        Iterator<String> it = ts.iterator();
        while(it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}
class LenComparator implements Comparator<String> {
    public int compare(String o1, String o2) {
        int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
        if(num == 0)
            return o2.compareTo(o1);
        return num;
    }
}

自定义泛型类

现在有两个类，分别为Student和Worker，如下：

class Student {
}

class Worker {
}

然后有一个工具类Tool要操作Student和Worker两个类，怎么办呢？
泛型前做法：

class Tool {
    private Object obj;
    public void setObject(Object obj) {
        this.obj = obj;
    }
    public Object getObject() {
        return obj;
    }
}

现在定义泛型来完成扩展：

class Utils<QQ> {
    private QQ q;
    public void setObject(QQ q) {
        this.q = q;
    }
    public QQ getObject() {
        return q;
    }
}

什么时候定义泛型类？
答：当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。

泛型方法

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
例，

class Demo<T> {
    public void show(T t) {
        System.out.println("show:"+t);
    }
    // 泛型方法
    public <Q> void print(Q q) {
        System.out.println("print:"+q);
    }
    // 静态泛型方法
    public static <W> void method(W t) {
        System.out.println("method:"+t);
    }
}
class GenericDemo4 {
    public static void main(String[] args) {
        Demo<String> d = new Demo<String>();
        d.show("haha");
        // d.show(4); // error
        d.print(5);
        d.print("hehe");
        Demo.method("hahahaha");
    }
}

泛型接口

泛型可定义在接口上。如：

interface Inter<T> {
    void show(T t);
}

泛型接口的第一种实现方式：

class InterImpl implements Inter<String> {
    public void show(String t) {
        System.out.println("show:"+t);
    }
}

调用方式：

InterImpl i = new InterImpl();
i.show("haha");

泛型接口的第二种实现方式：

class InterImpl<T> implements Inter<T> {
    public void show(T t) {
        System.out.println("show :"+t);
    }
}

调用方式：

InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);

泛型的限定

?：通配符，也可以理解为占位符。
泛型的限定：

1. ? extends E：可以接收E类型或者E类型的子类型，上限。
2. ? super E：可以接收E类型或者E的父类型，下限。

泛型的上限

class Person {
    private String name;
    Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class Student extends Person {
    Student(String name) {
        super(name);
    }
}
class GenericDemo {
    public static void main(String[] args) {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc1"));
        al.add(new Person("abc2"));
        al.add(new Person("abc3"));
        printColl(al);
        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("abc--1"));
        al1.add(new Student("abc--2"));
        al1.add(new Student("abc--3"));
        printColl(al1); 
    }
    public static void printColl(ArrayList<? extends Person> al) {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().getName());
        }
    }
}

当然了，只使用通配符?或泛型也是可以的，如下使用通配符?：

public static void printColl(ArrayList<?> al) {
    Iterator<?> it = al.iterator();
    while(it.hasNext()) {
        // toString()方法是Object类中方法，所以可使用，注意由于类型不确定，所以不可使用特有方法
        System.out.println(it.next().toString()); 
    }
}

使用泛型，与使用通配符?还是有区别的，可以接收T类型并操作，如：

public static void printColl(ArrayList<T> al) {
    Iterator<T> it = al.iterator();
    while(it.hasNext()) {
        T t = it.next();
        System.out.println(t.toString());
    }
}

泛型的下限

根据TreeSet(Comparator<? super E> comparator)来讲解泛型的下限。
一个继承体系如下：

class Person {
    private String name;
    Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public String toString() {
        return "person : "+name;
    }
}
class Student extends Person {
    Student(String name) {
        super(name);
    }
}
class Worker extends Person {
    Worker(String name) {
        super(name);
    }
}

若将Student和Worker对象存入TreeSet集合，并按照姓名排序，则不用泛型的限定，须定义两个比较器，如下：

class StuComp implements Comparator<Student> {
    public int compare(Student s1, Student s2) {
        return s1.getName().compareTo(s2.getName());
    }
}
class WorkerComp implements Comparator<Worker> {
    public int compare(Worker s1, Worker s2) {
        return s1.getName().compareTo(s2.getName());
    }
}

调用代码：

class GenericDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new StuComp());
        ts.add(new Student("abc03"));
        ts.add(new Student("abc02"));
        ts.add(new Student("abc06"));
        ts.add(new Student("abc01"));
        Iterator<Student> it = ts.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().getName());
        }
        TreeSet<Worker> ts1 = new TreeSet<Worker>(new WorkerComp());
        ts1.add(new Worker("wabc--03"));
        ts1.add(new Worker("wabc--02"));
        ts1.add(new Worker("wabc--06"));
        ts1.add(new Worker("wabc--01"));
        Iterator<Worker> it1 = ts1.iterator();
        while(it1.hasNext()) {
            System.out.println(it1.next().getName());
        }
    }
}

若使用泛型的下限，则只须定义一个比较器：

class Comp implements Comparator<Person> {
    public int compare(Person p1, Person p2) {
        return p2.getName().compareTo(p1.getName());
    }
}

调用代码：

class GenericDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());
        ts.add(new Student("abc03"));
        ts.add(new Student("abc02"));
        ts.add(new Student("abc06"));
        ts.add(new Student("abc01"));
        Iterator<Student> it = ts.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().getName());
        }
        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
        ts1.add(new Worker("wabc--03"));
        ts1.add(new Worker("wabc--02"));
        ts1.add(new Worker("wabc--06"));
        ts1.add(new Worker("wabc--01"));
        Iterator<Worker> it1 = ts1.iterator();
        while(it1.hasNext()) {
            System.out.println(it1.next().getName());
        }
    }
}