1. Java 泛型

Java 泛型是 JDK1.5 中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。其主要的形式有泛型类，泛型接口和泛型方法。泛型概念的提出，不仅提高了代码的复用性，而且可以有效防止类型转换异常，提高了代码的安全性。

泛型的语法格式：

<T,…> //T称为类型占位符，表示一种引用类型。

下面我们从泛型的三种形式来学习 Java泛型是如何提高代码复用性和安全性的。

2. 泛型类

泛型类的语法是在类名后面加上 <T> ，泛型在类中可以创建变量，也可以作为方法的参数或者返回值。

在使用泛型的使用只能使用引用类型，并且不同的泛型类型对象之间不能相互赋值。

示例，泛型类：

public class MyGeneric <T>{
    //创建泛型变量，不可以使用 new 来创建，因为 T 是不确定的类型
    T t;
    //泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }

    //泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

测试：

public class TestGeneric {
    public static void main(String[] args) {
        MyGeneric<String> myGeneric=new MyGeneric<String>();
        myGeneric.t="HelloWorld!";
        myGeneric.show("HelloWorld");
        System.out.println(myGeneric.getT());
    }
}

3. 泛型接口

泛型接口的语法是在接口名后面加上 <T>，泛型接口中不可以创建 static 修饰的变量。泛型接口有两使用方式，要么在实现接口时确定泛型类的类型，要么在实现接口时先不确定泛型类类型，而在实例化对象时再确定。

方法一示例：

public interface MyInterface <T>{
     String  name="张三";
     T show(T t);
}

泛型类的实现：

public class MyInterfaceImpl implements MyInterface<String> {
    @Override
    public String show(String s) {
        System.out.println(s);
        return  s;
    }
}

测试：

public class TestGeneric {
    public static void main(String[] args) {
        MyInterfaceImpl myInterfaceImpl=new MyInterfaceImpl();
        myInterfaceImpl.show("HelloWorld");
    }
}

方法二示例，实现泛型接口：

public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T show(T t) {
        System.out.println(t);
        return t;
    }
}

测试：

public class TestGeneric {
    public static void main(String[] args) {
        MyInterfaceImpl2<String> myInterfaceImpl=new MyInterfaceImpl2<String>();
        myInterfaceImpl.show("HelloWorld");
    }
}

4. 泛型方法

泛型方法的语法是在方法返回值的前面加上 <T> 。

示例：

public class MyGenericMethod {
    public <T> T show(T t){
        System.out.println("泛型方法"+t);
        return t;
    }
}

测试：

public class TestGeneric {
    public static void main(String[] args) {
        MyGenericMethod myGenericMethod=new MyGenericMethod();
        myGenericMethod.show("HelloWorld!");
        myGenericMethod.show(200);
    }
}

5. 泛型集合

泛型集合是参数化类型，类型安全的集合。泛型集合强制集合元素的类型必须一致。

使用泛型集合在编译器即可检查，而非运行期抛出异常，并且不同的泛型类型之间不可以相互赋值。

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList<String>();
        arrayList.add("张三");
        arrayList.add("李四");

        for (String s:arrayList) {
            System.out.println(s);
        }

        ArrayList<Student> arrayList1=new ArrayList<Student>();
        Student s1=new Student("张三",18);
        arrayList1.add(s1);
        for (Student student:arrayList1) {
            System.out.println(student);
        }
    }
}

我们查看 ArrayList 在JDK中的源码：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

它是一个泛型类，而我之前使用的时候并没有传递，说明 Java 语法是允许的，这个时候传递的类型是 Object 类，虽然它是所有类的父类，可以存储任意的类型，但是在遍历、获取元素时需要原来的类型就要进行强制转换。

这个时候就会出现一些问题，假如往链表里存储了许多不同类型的数据，在强转的时候就要判断每一个原来的类型，这样就很容易出现错误。

Java编程基础教程系列

【Java基础】Java常用类详解（包装类，字符串，枚举，文件…）

【Java集合】Collection 体系集合详解