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之旅，我想现在大家对泛型都有一个很好的理解了吧！