黑马程序员_Java_泛型

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
一、泛型概述
1、 泛型：
JDK1.5 版本以后出现的新特性，用于解决安全问题。是一个类型安全机制。泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响，对参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。泛型可以定义在类上、方法上、接口上、集合（对象）上。
2、 格式：
通过<>来定义要操作的引用数据类型。
例如：ArrayList al = new ArrayList;//定义存入集合的元素为String类型。
3、 优点：
(1)将运行时期出现的问题ClassCastException（类型转换异常），转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
(2)避免了强制转换麻烦。
代码示例：

import java.util.ArrayList;
import java.util.Iterator;
public class GeneriDemo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("java01");
        al.add("javaa02");
        al.add("javafdf03");
        al.add("javaad04");
//      al.add(6);//将运行时期出现的问题ClassCastException（类型转换异常），转移到了编译时期
        Iterator<String> it = al.iterator();
        while (it.hasNext()) {
            String s = it.next();//避免强制转换
            sop(s + ":" + s.length());
        }
    }

    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

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

三、泛型类
简单理解，类上带泛型。定义在类名后。泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
当类中要操作的引用数据类型不确定的时候。 早期定义Object来完成扩展，现在定义泛型来完成扩展。
代码示例：

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

public class GenericDemo3 {

    public static void main(String[] args) {
        /*
        //早期定义Object来完成扩展
        Tool t=new Tool();
        t.setgetObject(new Worker());
        Worker w=(Worker) t.getObject();
        */
        //现在定义泛型来完成扩展
        Utils<Worker> u=new Utils<Worker>();

        u.setObject(new Worker());
        Worker w=u.getObject();
    }
}

class Worker{

}

//现在定义泛型来完成扩展
class Utils<QQ>{
    private QQ q;
    public void setObject(QQ q){
        this.q=q;
    }
    public QQ getObject(){
        return q;
    }
}

//早期定义Object来完成扩展
class Tool{
    private Object obj;

    public Object getObject() {
        return obj;
    }

    public void setgetObject(Object obj) {
        this.obj = obj;
    }

}

四、泛型方法
定义在修饰符（包括static）后，返回值类型前。
为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
静态方法泛型:
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
代码示例：

class Demo1<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 w){
        System.out.println("method..."+w);
    }
}

五、泛型接口
定义在接口名后。实现也在接口名后。
代码示例：

public class GenericDemo5 {

    public static void main(String[] args){
        InterImpl i =new InterImpl();
        i.show("gaga");
    }
}

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

/*
 class InterImpl implements Inter<String>{//直接指定类型

    public void show(String t){
        System.out.println("show..."+t);
    }
}

*/

class InterImpl<T> implements Inter<T>{

    public void show(T t){
        System.out.println("show..."+t);
    }
}

六、泛型限定：
类型不明确时使用，不能使用类型特有方法，不可以使用length（）方法。此时可使用泛型限定，使用类特有方法。
泛型的通配符为 ？，也可以理解为占位符。
？ extends E: 可以接收E 类型或者E 的子类型。上限限定。
？ super E: 可以接收E 类型或者E 的父类型。下限限定。
泛型上限的代码示例：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo6 {

    public static void main(String[] args) {

        ArrayList<Person1> al=new ArrayList<Person1>();
        al.add(new Person1("abc"));
        al.add(new Person1("abc1"));
        al.add(new Person1("abc2"));
        printColl(al);

        ArrayList<Student1> al1=new ArrayList<Student1>();
        al1.add(new Student1("abc--"));
        al1.add(new Student1("abc1--"));
        al1.add(new Student1("abc2--"));
        printColl(al1);

    }
    public static void printColl(ArrayList<? extends Person1> al){//Person1的子类，可使用getName()方法
        Iterator<? extends Person1> it=al.iterator();

        while(it.hasNext()){
            System.out.println(it.next().getName());
        }
    }
    /*
    //无法使用Person特有方法getName();
    public static void printColl(ArrayList<?> al){
        Iterator<?> it=al.iterator();

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    */

    public static  void sop(Object obj){
        System.out.println(obj);
    }

}

class Person1{
    private String name;

    Person1(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

class Student1 extends Person1{

    Student1(String name) {
        super(name);
    }

}

泛型上限的代码示例：

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo7 {

    public static void main(String[] args) {
        TreeSet<Student2> ts=new TreeSet<Student2>(new Comp());
        ts.add(new Student2("abc1"));
        ts.add(new Student2("abc2"));
        ts.add(new Student2("abc3"));

        Iterator<Student2> it=ts.iterator();

        while(it.hasNext()){
            System.out.println(it.next().getName());
        }
    }

}
//比较器泛型TreeSet(Comparator<? super E> comparator)，使用父类型的比较器，<span style="font-family: Arial, Helvetica, sans-serif;">Comparator<? super E> comparator只要是E的父类型比较器，E也可以使用</span>

class Comp implements Comparator<Person2>{

    public int compare(Person2 s1, Person2 s2) {
        return s1.getName().compareTo(s2.getName());
    }

}
class Person2{
    private String name;

    Person2(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

class Student2 extends Person2{

    Student2(String name) {
        super(name);
    }

}