泛型

泛型

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