JAVA中泛型的理解

1.什么是泛型：
泛型：JDK1.5版本之后出现的新特性，用于解决安全问题，是一个安全机制；
我们用一个简单例子来展示。

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<>();
        array.add("ashin");
        array.add("monster");
        array.add("stone");
        array.add("masa");
        array.add("ming");
        array.add(5);

        Iterator<String> iterator = array.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
    }       
}

我们运行程序会出现：
Exception in thread “main” java.lang.Error: Unresolved compilation problem:
The method add(int, String) in the type ArrayList is not applicable for the arguments (int)；

这就说明我们将ArrayList的类型指定为String类型了，这样当我们传入int类型的时候就会报错

2.泛型类

public class Demo {
    public static void main(String[] args) {
        Tool tool=new Tool();
        tool.setS(new Student("monster")))
        System.out.println(t.getS().toString());
        }
}
//对Student添加工具类
class Tool{
    private Student s;

    public Student getS() {
        return s;
    }

    public void setS(Student s) {
        this.s = s;
    }


}

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

    @Override
    public String toString() {
        return name;
    }

}

class worker{

}

//这样我们通过Tool类就可以访问我们的Studnet.class了，但是如果我们又要需要一个工具类去操作worker.class那我们又要去从写一个基于worker的工具类了。这时我们不妨用泛型

class tool<T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

这样我们就可以对每一个类为所欲为了，不用再去为每一个类写工具类了。

eg:
    tool<Student> t=new tool();
    t.setT(new Student("ashin"));
    System.out.println(t.getT().toString);

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

3.泛型方法

public class Demo {
    public static void main(String[] args) {
        Text<String> text=new Text();
        text.show("ashin");
        text.shard("monster");
    }
}
class Text<T>{
    public void show(T t){
        System.out.println("show"+t);
    }

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

// 为了让不同的方法可以操作不同的类型，而且类型不确定，那么可以将泛型定义在方法上。

class Text{
    public <T> void show(T t){
    }

    public <T> void shard(T t){
    }
}

4.泛型接口

public class Demo {
    public static void main(String[] args) {
        //定义泛型类型
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(55);
    }
}

//实现类
class Imp<T> implements Inter<T>{
    @Override
    public void show(T t) {
        System.out.println("show:" + t);
    }
}

interface Inter<T> {
    void show(T t);
}

//感谢博客名为刘某人的java之旅，我想现在大家对泛型都有一个很好的理解了吧！