本文共 4247 字，大约阅读时间需要 14 分钟。

1. 为什么要使用泛型

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

我们来看这段代码:

public class test {       public static class ShowUncheckedWarning {           public static void main(String[] args) {               java.util.ArrayList list = new java.util.ArrayList();            list.add("Java Programming");        }    }}

这段代码看起来是没有问题的: 但是编译器会出现警告

我们可以通过添加泛型的方式来消除警告:

public class test {       public static class ShowUncheckedWarning {           public static void main(String[] args) {               java.util.ArrayList
   
     list = new java.util.ArrayList
    
     ();            list.add("Java Programming");        }    }}
    
   

2. 使用泛型的好处

一: 类型错误现在就可以在编译时被捕获了，而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。二: 消除强制类型转换(后面将提到)。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

3. 泛型类

泛型类是指该类使用的参数类型作用于整个类， 即在类的内部任何地方(不包括静态代码区域) 都可把参数类型当做一个真实类型来使用，比如用它做为返回值、 用它定义变量等等。定义泛型类的定义很简单，只需在定义类的时候， 在类名后加入
   
    这样一句代码即可，其中T是一个参数，是可变的。实例如下:
   

package Generic;public class Person
   
     {       private T t;    public Person(T t) {           this.t = t;    }    public String toString() {           return "参数的类型是：" + t.getClass().getCanonicalName();    }}
   

package Generic;public class Teacher
   
     extends Person {       protected V v;    private S s;    public Teacher(Object t) {           super(t);    }    public void set(V v, S s) {           this.v = v;        this.s = s;    }}
   

但当尝试定义一个T类型的构造函数时，发现在子类中已经无法使用类型参数T了，我们的代码使用Object代替T了，为什么可以这样做，我们将在泛型擦除时进行说明。

3.1 子类如何使用父类的参数

package Generic;public class Teacher
   
     extends Person
    
      {       protected T t;    private S s;    public Teacher(T t) {           super(t);    }    public void set(T t, S s) {           this.t = t;        this.s = s;    }}
    
   

把Person改为Person
   
    ，并将子类类型参数改为了
    
     ，这样子类就可以与父类一起共享类型参数了。
    
   

3.2 泛型类的使用

示例:

package Generic;public class Generics {       public static void main(String[] args) {           Person
   
     person = new Person
    
     ("person");        System.out.println(person.toString());    }}
    
   

运行结果:

4. 泛型方法

泛型方法是在方法上面声明类型参数，该类型参数只可作用于声明它的方法上面。泛型方法的定义和泛型类类似，都是通过往<>中加入某个参数，如
   
    来定义，但放的位置有所不同，下面的代码定义了一个泛型方法：
   

package Generic;import java.util.Date;public class Factory {       //    定义泛型方法    public 
   
     T generator(Class
    
      t) throws Exception {           return t.newInstance();    }    //  使用泛型方法    public static void main(String[] args) throws Exception {           Date date = new Factory().generator(Date.class);        System.out.println(date);    }}
    
   

代码讲解：

首先是public后面的
   
    ，
    
     的作用是为该方法声明一个类型参数，声明类型参数后，方法中就可以使用T来作为一种类型使用；接着是
     
      后面的T，这个T的作用是声明方法的返回值类型。该方法的参数为：Class
      
        t ，即T的类型信息。最后通过反射方法newInstance()创建T类的一个实例。
      
     
    
   

运行结果：

代码简洁而优美，灵活且强大。可以使用该方法生成任何继承自Object类的实例。然前提是该类有无参构造方法。在使用该方法时，无需为那些繁琐的转型代码而哭泣，泛型确保了类型的准确性。

5. 泛型接口

泛型接口的定义和规定：

泛型接口的制定方式和泛型类相似：

package Generic;public interface Factory
   
     {       public T create();}
   

泛型接口的意义：

拿工厂的例子来说，不同工厂的生产方式各不一样,装载的零件也不相同，因此实现的方式也各不相同，所以需要在具体的工厂中实现它独有的生产方式。

实例：实践是检验真理的唯一标准！！！

Factory.java

package Generic;public interface Factory
   
     {       public T create();}
   

Car.java

package Generic;public class Car {   }

Computer.java

package Generic;public class Computer {   }

CarFacotry.java

package Generic;public class CarFacotry implements Factory
   
     {       @Override    public Car create() {           System.out.println("装载发动机！");        System.out.println("装载座椅！");        System.out.println("装载轮子！");        return new Car();    }}
   

ComputerFactory.java

package Generic;public class ComputerFactory implements Factory
   
     {       @Override    public Computer create() {           System.out.println("装载主板！");        System.out.println("装载CPU!");        System.out.println("装载内存");        return new Computer();    }}
   

GenericTest.java

package Generic;public class GenericTest {       public static void main(String[] args) {           Factory
   
     carFactory = new CarFacotry();        Factory
    
      computerFactory = new ComputerFactory();        System.out.println("🐟🐟🐟🐟🐟🐟开始生产汽车🐟🐟🐟🐟🐟🐟");        carFactory.create();        System.out.println("🐟🐟🐟🐟🐟🐟开始生产电脑🐟🐟🐟🐟🐟🐟");        computerFactory.create();    }}
    
   

运行结果：