Java

为什么要使用泛型：

/**
 * 功能：泛型的使用，解释为什么使用泛型
 */
package generic;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericTest01
{
    public static void main(String[] args)
    {
        genericDemo();
        // genericDemo2();
    }
    
    // 没有使用泛型
    public static void genericDemo()
    {
        ArrayList al = new ArrayList();
        al.add("qwe");
        // 上面添加的字符串，下面添加的是int，迭代时肯定会报类型转换异常
        al.add(4);
        
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            // 需要强制类型转换
            // 此处在运行时会报类型转换异常：ClassCastException
            // 在编译时不会报异常
            String s = (String)it.next();  // 1
            System.out.println(s + ":" + s.length());
        }
        
        /**
         * 当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object类型，
         * 但其运行时类型任然为其本身类型；
         * 因此，//1 处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现"java.lang.ClassCastException"异常；
         */
    }
    
    // JDK1.5之后使用泛型
    // 解决安全问题
    public static void genericDemo2()
    {
        // 指定只添加String类型数据
        ArrayList<String> al = new ArrayList<String>();
        al.add("qwe");
        // 编译时下面这条语句就报错了
        // al.add(4);
        
        // 迭代器也通过泛型指定类型
        // 后续就不需要强制类型转换了
        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s + ":" + s.length());
        }
    }
}

什么是泛型：

自定义泛型类：

/**
 * 自定义泛型类
 */
package generic;

// 用于测试效果
public class GenericTest02
{
    public static void main(String[] args)
    {
        Tool tool = new Tool();
        tool.setObject(new Teacher());
        // 没用泛型之前，编译器提示必需要进行强制类型转换
        Teacher teacher = (Teacher) tool.getObject();
        System.out.println(teacher);
        
        Util<Doctor> util = new Util<Doctor>();
        util.setObject(new Doctor());
        // 使用泛型之后，不需要进行强转
        Doctor doctor = util.getObject();
        System.out.println(doctor);
    }
}

// 没有使用泛型
class Tool
{
    private Object object;

    public Object getObject()
    {
        return object;
    }

    public void setObject(Object object)
    {
        this.object = object;
    }
}

// 使用泛型，自定义泛型类
class Util<Q>
{
    private Q object;
    
    public void setObject(Q q)
    {
        this.object = q;
    }
    public Q getObject()
    {
        return object;
    }
}

class Doctor
{

}

class Teacher
{

}

方法上定义泛型：

/**
 * 方法上定义泛型
 */
package generic;

// 用于测试效果
public class GenericTest03
{
    public static void main(String[] args)
    {
        Utils ut = new Utils();
        // 可以打印字符串
        ut.show("qwe");
        // 可以打印int类型
        ut.show(12);
    }
}

// 方法上定义泛型
class Utils
{
    // 语法格式必须如下所示
    public <T> void show(T t)
    {
        System.out.println("show:" + t);
    }
    
    // 下面两种书写方式都是错的
    // public void show(T t)
    // public <T> void show(String str)
    
    public <Q> void print(Q q)
    {
        System.out.println("print:" + q);
    }
    
    // 泛型字母可以任意定义，不用区分大小写
    public <Y> void print2(Y y)
    {
        System.out.println("print:" + y);
    }
}

类和方法上都定义泛型：

/**
 * 类和方法上都定义泛型
 */
package generic;

// 用于测试效果
public class GenericTest04
{
    public static void main(String[] args)
    {
        Tools<String> tl = new Tools<String>();
        // 只能打印String类型
        tl.show("qwer");
        // 打印其他类型报错
        // tl.show(123);
        
        // 可以打印String类型
        tl.print("qwe");
        // 也可以打印其他类型
        tl.print(123);
        
        // 可以打印String类型
        tl.print2("qwer");
        // 也可以打印其他类型
        tl.print2(123);
        
        Tools.display("qwe");
        Tools.display(123);
    }
}

// 类和方法上都定义泛型
class Tools<T>
{
    // 这个方法的类型是跟着对象（类型T）走的，Q不起作用
    public <Q> void show(T t)
    {
        System.out.println("show:" + t);
    }
    
    // 这个方法的类型是跟着Q走的
    public <Q> void print(Q q)
    {
        System.out.println("print:" + q);
    }
    
    @SuppressWarnings("hiding")
    public <T> void print2(T q)
    {
        System.out.println("print2:" + q);
    }
    
    // 泛型定义在返回值的前面，修饰符的后面
    public static <W> void display(W w)
    {
        System.out.println("display:" + w);
    }
}

 接口上定义泛型：

/**
 * 接口上定义泛型
 */
package generic;

// 用于测试效果
public class GenericTest05
{
    public static void main(String[] args)
    {
        InterImpl01 ii = new InterImpl01();
        ii.show("qwe");
        // ii.show(123);  编译时报错
        
        InterImpl02<String> ii2 = new InterImpl02<String>();
        ii2.show("asd");
        // ii2.show(123);  编译时报错
        
        InterImpl02<Integer> ii3 = new InterImpl02<Integer>();
        ii3.show(123);
        // ii3.show("asd");  编译时报错
    }
}

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

// T是具体的数据类型，在实现类后面不需要加上 <String>
class InterImpl01 implements Inter<String>
{
    @Override
    public void show(String t)
    {
        System.out.println("show:" + t);
    }
}

// T如果不是具体的数据类型的话，实现类和接口后面都要加上<T>
class InterImpl02<T> implements Inter<T>
{
    @Override
    public void show(T t)
    {
        System.out.println("show:" + t);
    }
}

泛型的高级特性：

高级特性01：

/**
 * 功能：泛型的高级特性01
 */
package generic.generic05;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericTest01
{
    public static void main(String[] args)
    {
        ArrayList<String> al1 = new ArrayList<String>();
        al1.add("qwe");
        al1.add("asd");
        al1.add("zxc");
        
        ArrayList<Integer> al2 = new ArrayList<Integer>();
        al2.add(123);
        al2.add(456);
        al2.add(789);
        
        // demo(al1);
        // demo(al2);
        
        demo2(al1);
        // demo2(al2);
    }
    
    // 不清楚是什么类型时候，可以用？代替
    public static void demo(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println("al:" + it.next());
            // 以下使用length()是错误的
            // 因为不知道是什么类型，所以不能使用某一具体类型的特有方法
            // System.out.println(it.next().length());
        }
    }
    
    // 也可以换成T，但T代表了某一个具体类型，比如String，不是真让你写一个T在里面，其实是写一个具体类型
    // 操作方面有一点变化
    public static <T> void demo2(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println("al:" + it.next());
            // 使用了某一具体类型之后
            // 可以用这个具体类型来接收迭代出来的元素，并进行其他具体操作
            /*T t = it.next();
            System.out.println("al:" + t);*/
        }
    }
}

高级特性02：

/**
 * 功能：泛型的高级特性02
 */
package generic;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericTest07
{
    public static void main(String[] args)
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("qwe"));
        al.add(new Person("asd"));
        al.add(new Person("zxc"));
        
        ArrayList<Worker> al2 = new ArrayList<Worker>();
        al2.add(new Worker("qwe"));
        al2.add(new Worker("asd"));
        al2.add(new Worker("zxc"));
        
        ArrayList<Student> al3 = new ArrayList<Student>();
        al3.add(new Student("qwe"));
        al3.add(new Student("asd"));
        al3.add(new Student("zxc"));
        
        // 正确
        demo(al);
        // 以下两种写法错误，是不允许的，左右不匹配
        // ArrayList<Person> al2 = new ArrayList<Student>();
        // ArrayList<Student> al2 = new ArrayList<Person>();
        // demo(al2);  // 错误，只能打印 ArrayList<Person> 类型数据
        // demo(al3);  // 错误，只能打印 ArrayList<Person> 类型数据
        
        demo2(al);
        demo2(al2);
        demo2(al3);
        
        demo3(al2);
        demo3(al);
        // Student类不是Person类的子类，所以下面写法错误
        // demo3(al3);
        
        demo4(al);
        demo4(al2);
        // Student类不是Worker类的父类，所以下面写法错误
        // demo4(al3);
    }
    
    // 打印出特定类型
    public static void demo(ArrayList<Person> al)
    {
        Iterator<Person> it = al.iterator();
        while(it.hasNext())
        {
            Person p = it.next();
            System.out.println("name:" + p.getName());
        }
    }
    
    // 打印出所有类型
    public static void demo2(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    
    // 打印出指定的范围类型：泛型限定
    // 只打印Person和它的子类
    public static void demo3(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            // 可以调用具体方法
            System.out.println(it.next().getName());
        }
    }
    
    // 打印出指定的范围类型：泛型限定
    // 只打印Worker和它的父类（是Worker类的基类）
    public static void demo4(ArrayList<? super Worker> al)
    {
        Iterator<? super Worker> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

class Person
{
    private String name;
    
    public Person(String name)
    {
        this.name = name;
    }
    
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
}

class Student
{
    private String name;
    
    public Student(String name)
    {
        this.name = name;
    }
    
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
}

class Worker extends Person
{
    public Worker(String name)
    {
        super(name);
    }
}

高级特性03：

/**
 * 未使用高级特性之前
 */
package generic;

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

public class GenericTest08_1
{
    public static void main(String[] args)
    {
        // 使用Studnet类的构造器
        TreeSet<Student1> tr = new TreeSet<Student1>(new StuComparator());
        tr.add(new Student1("stu4"));
        tr.add(new Student1("stu2"));
        tr.add(new Student1("stu3"));
        
        Iterator<Student1> it = tr.iterator();
        while(it.hasNext())
        {
            System.out.println("tr:" + it.next().getName());
        }
        
        // 使用Worker类的构造器
        TreeSet<Worker1> tr2 = new TreeSet<Worker1>(new WorComparator());
        tr2.add(new Worker1("wor1"));
        tr2.add(new Worker1("wor5"));
        tr2.add(new Worker1("wor3"));
        
        Iterator<Worker1> it2 = tr2.iterator();
        while(it2.hasNext())
        {
            System.out.println("tr:" + it2.next().getName());
        }
    }
}

class MyComparator implements Comparator<Person1>
{
    @Override
    public int compare(Person1 o1, Person1 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

// Student类的比较器，分开写很麻烦
class StuComparator implements Comparator<Student1>
{
    @Override
    public int compare(Student1 o1, Student1 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

// Worker类的比较器，分开写很麻烦
class WorComparator implements Comparator<Worker1>
{
    @Override
    public int compare(Worker1 o1, Worker1 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

class Person1
{
    private String name;
    
    public Person1(String name)
    {
        this.name = name;
    }

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

class Student1 extends Person1
{
    // private String name;
    public Student1(String name)
    {
        super(name);
    }
}

class Worker1 extends Person1
{
    public Worker1(String name)
    {
        super(name);
    }
}

/**
 * 使用高级特性之后
 */
package generic;

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

public class GenericTest08_2
{
    public static void main(String[] args)
    {
        // 使用通用的比较器（父类的比较器）
        TreeSet<Student2> tr = new TreeSet<Student2>(new MyComparator2());
        tr.add(new Student2("stu4"));
        tr.add(new Student2("stu2"));
        tr.add(new Student2("stu3"));
        
        Iterator<Student2> it = tr.iterator();
        while(it.hasNext())
        {
            System.out.println("tr:" + it.next().getName());
        }
        
        // 使用通用的比较器（父类的比较器）
        TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new MyComparator2());
        tr2.add(new Worker2("wor1"));
        tr2.add(new Worker2("wor5"));
        tr2.add(new Worker2("wor3"));
        
        Iterator<Worker2> it2 = tr2.iterator();
        while(it2.hasNext())
        {
            System.out.println("tr:" + it2.next().getName());
        }
    }
}

class MyComparator2 implements Comparator<Person2>
{
    @Override
    public int compare(Person2 o1, Person2 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

class Person2
{
    private String name;
    
    public Person2(String name)
    {
        this.name = name;
    }

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

class Student2 extends Person2
{
    // private String name;
    public Student2(String name)
    {
        super(name);
    }
}

class Worker2 extends Person2
{
    public Worker2(String name)
    {
        super(name);
    }
}