java——泛型

　　泛型的出现是为了解决程序在编译时期没有问题，在运行时期出现问题的情况，在jdk1.5之前一直存在这上面说的问题，举个例子来说明下这个问题，看下面这段代码
　　

import java.util.*;
class Demo
{
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList();
        list.add("html");
        list.add("java");
        list.add("mysql");
        list.add(66);

        Iterator ite = list.iterator();
        while(ite.hasNext())
        {
            Object obj = ite.next();
            //向下转型，语法没问题
            String str = (String)obj;
            System.out.println(str);
        }
    }

　　上面这段代码在编译时期不会出现错误，然而在运行时期却出现了问题，java.lang.ClassCastException，因为在ArrayList中添加的四个对象，66是不能转成string的，语法并没有问题，所以编译通过，再来看如何使用泛型来使这种问题在编译时期被发现
　　

/*
泛型：通过<数据类型>接收一种引用数据类型，当在编译程序时会使用该类型检查集合中存储的对象是否是该类型的，如果不是，编译不通过，从而把运行时期的问题转移到编译时期，提高了程序的安全性

*泛型擦除：泛型是用在编译时期的，编译完之后的class文件中是不存在泛型的
*/
import java.util.*;
class Demo
{
    public static void main(String[] args)
    {
        //尖括号中必须是引用数据类型
        ArrayList<String> list = new ArrayList<String>();
        list.add("html");
        list.add("java");
        list.add("mysql");
        //list.add(66);//提示编译错误

        Iterator<String> ite = list.iterator();
        while(ite.hasNext())
        {
            //上面在迭代器中加入泛型<String>
            //下面不需要进行强制转换了
            String str = ite.next();
            //Object obj = ite.next();
            //String str = (String)obj;
            System.out.println(str);
        }
    }
}

　　泛型分为三大类，类声明泛型，方法声明泛型和接口声明泛型

一、类声明泛型

//定义泛型类----在类上定义泛型
//使用泛型前
class Student
{

}
class Worker
{

}
class Tool
{
    private Object obj;

    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
class Tools<E>
{
    private E obj;

    public void setObject(E obj)
    {
        this.obj = obj;
    }
    public E getObject()
    {
        return obj;
    }
}
class Demo
{
    public static void main(String[] args)
    {
        /*
        Tool tool = new Tool();
        tool.setObject(new Student());
        Object obj = tool.getObject();
        Worker worker = (Worker)obj;//编译通过，执行异常
        */

        Tools<Student> tools = new Tools<Student>();
        tools.setObject(new Student());
        Student stu = tools.getObject();
    }
}

二、方法声明泛型
　　

//在方法上定义泛型
class Test<T>
{
    //当类上的泛型确定了，该方法上的参数的类型才能确定
    public void show(T a)
    {
        System.out.println(a);
    }
    //当希望参数的类型是任意类型时，该方法自己使用泛型
    public <T> void fun(T t)//public <E> void fun(E t)
    {
        System.out.println(t);
    }
    //静态进内存的时候没有对象，所以只能自己使用泛型
    public static <W> void test(W t)
    {
        System.out.println(t);
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Test<String> test = new Test<>();

        test.show("77");

        test.fun("hello");
        test.fun(88);

        Test.test(3);
    }
}

三、接口声明泛型

//在接口上定义泛型
interface test1<E>
{
    public abstract void show(E e);
    public abstract void fun(String ss);
}
//情况1
class Test1 implements test1<Integer>
{
    public void show(Integer e)
    {

    }

    public void fun(String e)
    {

    }
}
//情况2
class Test2<E> implements test1<E>//当类上的泛型确定了，接口上的泛型才能确定
{
    public void show(E e)
    {

    }

    public void fun(String e)
    {

    }
}
class Demo
{
    public static void main(String[] args)
    {
        //后面的尖括号可以省略数据类型
        Test2<String> test = new Test2<>();
        test.show("hello");
    }
}