泛型

JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
好处：
1、将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，更安全。
2，避免了强制转换麻烦。

• 提高了程序的安全性
• 将运行期遇到的问题转移到了编译期
• 省去了类型强转的麻烦
• 泛型类的出现优化了程序设计

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

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

泛型类

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

class Worker {}class Student {}// 泛型前做法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;    }}class GenericDemo3 {    public static void main(String[] args) {        Utils<Worker> u = new Utils<Worker>();        u.setObject(new Worker());        Worker w = u.getObject();// 现在不需要强转了。如该Worker传成了Student，编译时会提示类型转换异常；因Utils<Worker>中限定了传入类型        /*         * Tool t = new Tool();          * t.setObject(new Student());          * Worker w = (Worker)t.getObject();         */        // 编译没问题,运行出错: Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to Worker    }}

泛型方法

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
泛型放修饰符后，返回值类型前。
特殊之处：
静态方法不可以访问类上定义的泛型。（会报错: 无法从静态上下文中引用非静态类型变量 T。对象的类型T，建立对象后才知道T到底是什么类型）如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo<T> {// 泛型类    public void show(T t) {// 用了类里面的泛型        System.out.println("show:" + t);    }    // public <T> void print(T q) // 没问题，为阅读方便不写<T>写<Q>    // Q写成T也没关系，这个方法中的变量与上个方法没关系，都是自定义的    public <Q> void print(Q q) {// 泛型方法        System.out.println("print:" + q);    }    // public static void method(T t) //静态方法不可以访问类上定义的泛型    // 编译失败，错误: 无法从静态上下文中引用非静态 类型变量 T（对象的类型T，建立对象后才知道T到底是什么类型）    public static <W> void method(W t) {        // 泛型放修饰符后，返回值类型前(<W>不能放static前、void后)        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);//编译失败，泛型规定了参数只能是String        d.print(5);        d.print("hehe");        Demo.method("hahahahha");    }}

泛型接口

interface Inter<T> { //泛型接口    void show(T t);}

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

public class GenericDemo5 {    public static void main(String[] args) {        InterImpl<Integer> i = new InterImpl<Integer>();        i.show(4);    }}

泛型限定

?：通配符。也可以理解为占位符。

泛型的限定：
？ extends E：可以接收E类型或者E的子类型。上限。
？ super E：可以接收E类型或者E的父类型。下限

class GenericDemo6 {    public static void main(String[] args) {        ArrayList<Student> al1 = new ArrayList<Student>();        // ArrayList<? extends Person> al = 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(Collection<? extends Person> al) {        Iterator<? extends Person> it = al.iterator();        while (it.hasNext()) {            System.out.println(it.next().getName());        }    }}

public 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);    }}