对范型深刻又通俗易懂的理解

来源

在美团实习的时候，看到了业务代码中出现了很多的范型，本着不懂就总结的想法，于是有了这个跨度好几天才写出来的总结。下面是参考的文章链接：

• https://cloud.tencent.com/developer/article/1479350
• http://php-note.com/article/1300.html
• https://blog.csdn.net/jingzi123456789/article/details/80606694

0、范型的好处

• 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。Java语言引入泛型的好处是安全简单。
• 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
• 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

class Fruit{
    String name = "苹果";
    public Fruit(){

    }
}

class Apple extends  Fruit{
    String name = "苹果";
    int kilogram = 1;
    public Apple(){

    }
    public Apple(String name){
        this.name = name;
    }

    public void Info(){
        System.out.println(String.format("%s的重量是%dkg。", name, kilogram));
    }
}

class AppleFake extends Fruit{
    String name = "假苹果";
    int kilogram = 1;
    public AppleFake(){

    }
    public AppleFake(String name){
        this.name = name;
    }

    public void Info(){
        System.out.println(String.format("假%s的重量是%dkg。", name, kilogram));
    }
}

/**
 * Box类定义为一个泛型类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
class Box<T> {
    private T object;

    public void set(T object) { this.object = object; }
    public T get() { return object; }
}

public class Paradigm_ {
    public static void main(String[] args) {
        // 创建一个Box对象，带泛型参数，获取对象的时候就不需要强制转换
        Box<Apple> box = new Box<Apple>();
        box.set(new Apple("红富士苹果"));
        Apple apple = box.get();
        apple.Info();

        /*
        Box<Apple> box = new Box<Apple>();
        // 报错： // 'set(org.example.Apple)' in 'org.example.Box' cannot be applied to '(org.example.AppleFake)'
        box.set(new AppleFake("红富士苹果"));
        */
        //创建一个Box对象，不带泛型参数，发现获取对象的时候需要强制转换
        Box box2 = new Box();
        box2.set(new Apple("洛川苹果"));
        Apple apple2 = (Apple) box2.get();
        apple2.Info();
    }
}
// 红富士苹果的重量是1kg。
// 洛川苹果的重量是1kg。

上述步骤可以简单地理解为：

• 将Box类定义为一个泛型类
• 创建一个Box对象，不带泛型参数，发现获取对象的时候需要强制转换
• 创建一个Box对象，带泛型参数，获取对象的时候就不需要强制转换

总结下泛型的好处就是

• 省去了强制转换，在编译时候检查类型安全，可以用在类，方法，接口上

泛型的作用：

• 1、用泛型：
  List< T > list=new ArrayList< T >();
  T t=list.get(0);

• 2、不用泛型：
  List list = new ArrayList();
  T t = (T)list.get(0);

---

1、范型通配符

1.1 JAVA泛型通配符? T K V E

看java源代码的时候，如果碰到泛型的话，? T K V E这些是经常出现的：

• ？ 表示不确定的java类型（是Object类的子类都可以，换言之，任何类都可以，因为Object是所有类的根基类）
• T 表示java类型（是固定的一种泛型，固定的泛型指类型是固定的，比如：Interge、String）

若一个方法能知道返回的是哪种类型，用T行了。如果完全不知道的就用 ？，用T得到的对象就不需要类型转换了，而用？就必需用强转

• K V 分别代表java键值中的Key Value
• E 代表Element， (在集合中使用，因为集合中存放的是元素)
• Object是所有类的基类，是具体的一个类，使用的时候可能需要类型强制转换(转换为具体的子类)

Object和T不同点在于，Object是一个实打实的类，并没有泛指谁，而T可以泛指Object，比方public void printList(List< T > list){}方法中可以传入List< Object > list类型参数，也可以传入List< String > list类型参数，但是public void printList(List< Object > list){}就只可以传入List< Object > list类型参数，因为Object类型并没有泛指谁，是一个确定的类型

举例说明：

• Set< T > 表示 集合里 是 T类的实例
• List< E > 表示 集合里 是 E类的实例
• List< ? > 表示 集合里的对象类型不确定，未指定
• List 同 List<?> 是一样的。

1.2 ?和T区别

• ？和T都表示不确定的类型 ，但如果是T的话，函数里面可以对T进行操作，比方 T car = getCar()，而不能用？ car = getCar()

import java.util.Arrays;
import java.util.List;

public class TestDifferenceBetweenObjectAndT {
    public static void printList1(List<Object> list) {
        for (Object elem : list)
            System.out.println(elem + " ");
        System.out.println();
    }

    public static <T> void printList2(List<T> list) {
        for (T elem : list)
            System.out.println(elem + " ");
        System.out.println();
    }

    public static  void printList3(List<?> list) {
        for (int i = 0;i<list.size();i++)
            System.out.println(list.get(i) + " ");
        System.out.println();
    }

    public static void main(String[] args) {
    	 // 注意test3的类型是Objet，所以该列表可以存放不同类型的元素
        List<Integer> test1 = Arrays.asList(1, 2, 3);
        List<String>  test2 = Arrays.asList("one", "two", "three");
        List<Object> test3 = Arrays.asList(1, "two", 1.23);
        printList1(test3);
        printList2(test3);
        printList3(test3);
    }
}

1 
two 
1.23 

1 
two 
1.23 

1 
two 
1.23 

1.3 方法中为什么需要 T 修饰呢

泛型的声明，必须在方法的修饰符（public,static,final,abstract等）之后，返回值声明之前：

public static <T> T request2Bean(HttpServletRequest request, Class<T> clazz) {
}

其中第一个 <T> 是与传入的参数 Class<T> 相对应的，相当于返回值的一个泛型，后面的 T 是返回值类型，代表方法必须返回 T 类型的（由传入的 Class<T> 决定）

1.4 通配符只是个约定的大写字母

Q：定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符T，E，K，V等等，这些通配符又都是什么意思呢？

A：这些全都属于java泛型的通配符，刚开始我看到这么多通配符，一下晕了，这几个其实没什么区别，只不过是一个约定好的代码，也就是说，使用大写字母A,B,C,D......X,Y,Z定义的就都是泛型，把T换成A也一样，这里T只是名字上的意义而已

public class Test<T> {    
  public List<T> list = new ArrayList<T>();   
  public static void main(String[] args) {
        Test<String> test = new Test<String>();
        test.list.add("hello");
        System.out.println(test.list);
    }
}

和

public class Test<A> {    
  public List<A> list = new ArrayList<A>();   
  public static void main(String[] args) {
        Test<String> test = new Test<String>();
        test.list.add("hello");
        System.out.println(test.list);
    }
}

将T换成了A，在执行效果上是没有任何区别的，只不过我们约定好了T代表type，所以还是按照约定规范来比较好，增加了代码的可读性。或者参考下面👇3.1中的class Paradigm_A< A >{ }、Paradigm_T< T >{ }

1.5 同时使用多个范型参数，如K，V

如果要定义多个泛型参数，比如说两个泛型参数，很典型的一个栗子是Map的key、value泛型，我们也可以定义一个这样的

interface Mymap<K, V> {
    public K getKey();
    public V getValue();
}

class MymapImpl<K, V> implements Mymap<K, V> {

    private K key;
    private V value;

    public MymapImpl(K key, V value) {
        this.key = key;
        this.value = value;
    }
    @Override
    public K getKey(){
        return key;
    }
    @Override
    public V getValue(){
        return value;
    }
}

public class Paradigm_ {
    public static void main(String[] args) {     
        /**
         * 如果要定义多个泛型参数，比如说两个泛型参数，很典型的一个栗子是Map的key,value泛型，我们也可以定义一个这样的
         */
        //可以传入任意类型创建实例，不用转化类型
        Mymap<String, Integer> mp1= new MymapImpl<String, Integer>("Even", 8);
        Mymap<String, String>  mp2= new MymapImpl<String, String>("hello", "world");
        Mymap<Integer, Integer> mp3= new MymapImpl<Integer, Integer>(888, 8);
        System.out.println("key:"+mp1.getKey()+", value:"+mp1.getValue());
        System.out.println("key:"+mp2.getKey()+", value:"+mp2.getValue());
        System.out.println("key:"+mp3.getKey()+", value:"+mp3.getValue());
        /**
         * 如果要定义超过两个，三个或三个以上的泛型参数可以使用T1, T2, ..., Tn，像这样子
         * public class Test<T1,T2,T3> {
         *    public void print(T1 t1,T2 t2,T3 t3){
         *         System.out.println(t1.getClass());
         *         System.out.println(t2.getClass());
         *         System.out.println(t3.getClass());
         *     }
         * }
         */
    }
}

---

2、普通的非泛型类 Class

2.1 Class类介绍

注意：class是java的关键字, 在声明java类时使用

• T是一种具体的类，例如String,List,Map…等等，这些都是属于具体的类。Class是什么呢，Class也是一个类，但Class是存放上面String,List,Map......类信息的一个类，有点抽象，我们一步一步来看 。

• Class类的实例表示Java应用运行时的类(class and enum) 或 接口(interface and annotation)（每个java类运行时在JVM里表现为一个Class对象，可通过类名.class，类型.getClass()，Class.forName("类名")等方法获取Class对象）。

• 数组同样也被映射为Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。

• 基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 Class 对象。

链接：https://blog.csdn.net/witewater/article/details/53462385

2.2 Class类的获取

如何获取到Class类呢，有三种方式：

• 调用Object类的getClass()方法来得到Class对象，这也是最常见的产生Class对象的方法。例如：

List list = null;
Class clazz = list.getClass();

• 使用Class类的中静态forName()方法获得与字符串对应的Class对象。例如：

Class clazz = Class.forName("com.lyang.demo.fanxing.People");

• 获取Class类型对象的第三个方法非常简单。如果T是一个Java类型，那么X.class就代表了匹配的类对象。

Class clazz = List.class;

---

3、T 与 Class< T >以及Class<?>的理解

3.1 Class< T >和Class< ? >的区别

• 单独的T是一种具体的类，例如String,Interger…等等
• Class< T > 代表这个类型所对应的类，Class< ? > 表示类型不确定的类
  • Class< T >在实例化的时候，T要替换成具体类（形参类型的定义）
    • <? extends T>受限统配，接收T类型或者T的子类型
    • <? super T>受限统配，接收T类型或者T的父类型
  • Class<?>是个通配泛型，?可以代表任何类型，主要用于声明时的限制情况（或形参类型定义）

当类名没有使用< T >修饰时：

• 对于类变量或实例变量：用T声明是无效的，声明的时候应该用？，比如我们可以声明一个 public Class<?> clazz; 但是你不能声明一个 public Class<T> clazz;因为T需要指定类型，所以，当不知道声明什么类型的Class的时候可以定义一个Class<?>。
  在有< T >修饰的方法内，：
• 对于用< T >修饰的方法中的局部变量：可以使用 T 或 ？ 声明局部变量

• ArrayList< T > al=new ArrayList< T >(); 指定集合元素只能是T类型
• ArrayList< ? > al=new ArrayList< ? >(); 集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法

class Paradigm_NoT {
    //
    /**
     * 当类名没有使用<T>修饰时：
     *      - 对于类变量或实例变量：用T声明是无效的，声明的时候应该用？ 1⃣️，或者声明在方法内，如output()所示 2⃣️
     *      - 对于用<T>修饰的方法中的局部变量：可以使用 T 或 ？ 声明局部变量 2⃣️  3⃣️
     */
    // public List<Class<T>> list = new ArrayList<Class<T>>();       // 无效
    //private List<Class<?>> list = new ArrayList<Class<?>>();       // 1⃣️

    // 若是没有void前面的<T> 会报错：Cannot resolve symbol 'T'，这是因为不像class Paradigm_T<T>直接声明在最上面了
    public <T> void output(Class<T> t){
        List<Class<T>> list = new ArrayList<>();                    // 2⃣️
        List<Class<?>> listlist = new ArrayList<>();                    // 3⃣️

        list.add(t);
        listlist.add(t);
        System.out.println(list);
        System.out.println(listlist);
    }

    private List<?> list2;
    // 对于？，不用在void前声明<?>
    public  void output2(List<?> list) {
        this.list2 = list;
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i) + " ");
        }
        System.out.println();
        System.out.println(list2);
    }

    public static void main(String[] args) {
        Paradigm_NoT test = new Paradigm_NoT();
        test.output(Fruit.class);
        test.output(Box.class);

        List<Integer> arr = Arrays.asList(1, 2, 3);
        test.output2(arr);
    }
}
// [class org.example.Fruit]
// [class org.example.Fruit]
// [class org.example.Box]
// [class org.example.Box]
// 1 
// 2 
// 3 
// [1, 2, 3]

class Paradigm_T<T> {
    // 指定集合元素只能是T类型
    public List<T> list = new ArrayList<T>();
    public void output(T t){
        list.add(t);
        System.out.println(list);
    }
    public static void main(String[] args) {
        Paradigm_T<String> test = new Paradigm_T<String>();
        test.list.add("我是Paradigm_T");
        System.out.println(test.list);

        //test.list.add(1);
        /** 报错信息如下： 因为在创建类实例的时候已经指定了T为String类型，再传入Integer类型的时候，肯定报错
         * java: 对于add(int), 找不到合适的方法
         *     方法 java.util.Collection.add(java.lang.String)不适用
         *       (参数不匹配; int无法转换为java.lang.String)
         *     方法 java.util.List.add(java.lang.String)不适用
         *       (参数不匹配; int无法转换为java.lang.String)
         */
    }
}
// [我是Paradigm_T]

/**
 * 将T换成了A，在执行效果上是没有任何区别的，只不过我们约定好了T代表type，所以还是按照约定规范来比较好，增加了代码的可读性。
 */
class Paradigm_A<A> {
    public List<A> list = new ArrayList<A>();

    public void output(A a){
        list.add(a);
        System.out.println(list);
    }

    public static void main(String[] args) {
        Paradigm_A<String> test = new Paradigm_A<String>();
        test.list.add("我是Paradigm_A");
        System.out.println(test.list);
    }
}
// [我是Paradigm_A]

public class Paradigm_ {
    public static void main(String[] args) {
        /**
         * Q: 我们定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符T，E，K，V等等，这些通配符又都是什么意思呢？
         * A: 这些全都属于java泛型的通配符，这几个其实没什么区别，只不过是一个约定好的代码，也就是说使用大写字母A,B,C,D......X,Y,Z定义的，就都是泛型
         *      - ？ 表示不确定的java类型
         *      - T (type) 表示具体的一个java类型
         *      - K V (key value) 分别代表java键值中的Key Value
         *      - E (element) 代表Element
         */
        System.out.println("----------------------------------------------------------------------------------------------------------------------------------");
        Paradigm_T<String> testT = new Paradigm_T<String>();
        testT.output("Paradigm_T");
        Paradigm_T<String> testA = new Paradigm_T<String>();
        testA.output("Paradigm_A");    
    }
}
// [Paradigm_T]
// [Paradigm_A]

3.2 如何创建一个 Class< T > 或Class< ? > 类型的实例

如何创建一个Class< T > 或Class< ? > 类型的实例，有三种方式：

• 调用方法 类T的对象t的getClass()，返 回 Class<?>
• 调用方法 Class.forName()，返 回 Class<?>
• 类T.class 被定义为具有类型 Class< T >, 所 以 String.class 是Class< String > 类型的

3.3 Class< T >和Class< ? >的使用场景

Q：由上面的👆2.2，Class类是创建出来了，但是Class< T >和Class< ? >适用于什么时候呢
A：使用Class< T >和Class< ? >多发生在反射场景下。 为了说明这个问题，先看看不使用泛型，反射创建一个类是什么样的。

People people = (People) Class.forName("com.lyang.demo.fanxing.People").newInstance()

看到了么，需要强转，如果反射的类型不是People类，就会报java.lang.ClassCastException错误。使用Class< T >泛型后，不用强转了：

public class Test {
    public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        return clazz.newInstance();
    }

    public static void main(String[] args)  throws IllegalAccessException, InstantiationException  {
            Fruit fruit= createInstance(Fruit .class);
            People people= createInstance(People.class);
    }
}

---

4、不太正经的实战

package org.example;


// 本文链接：https://blog.csdn.net/jitianxia68/article/details/73610606

abstract class Animal {
    public String type = "type = animal ";
}

class Dog extends Animal {
    public String name = "name = gou";
}

class Cat extends Animal {
    public String name = "name = mao";
}

/**
 * 这些方法，传的参数声明不同，其返回的声明也必然要随之不同。
 */

public class Paradigm {
    /**
     * Me    : 此方法是一个非泛型类中的泛型方法，参数为Class<T>类型，这表示可以传入任何类，但是Class<T>类型在函数内部被固定为 T类，使用clazz.newInstance()返回的类型也为固定的 T 类型。
     * Author: 此方法是一个非泛型类中的泛型方法，参数为Class<T>类型，可以传入任何类，但是Class<T>将参数在函数内部的类型固定为 T类，使用clazz.newInstance(),返回的类型也为固定的 T 类型。
     * 如: 传入Dog.class, 函数中的 T 固定为Dog.class,函数返回的是Dog类型，不需要强制转换为Dog类型
     * （当然，函数返回类型也可以是Object类型，但是没必要）
     */
    public static <T> T creatNew1(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        //打印具体传入的类型。
        System.out.println(clazz);
        return clazz.newInstance();
    }

    /**
     * Me    : 此方法参数是Class<? extends Animal>类型，只能传入Animal及其子类的类型，函数返回类型只能声明为Animal或Object类型，
     * Author: Class<? extends T>，受限统配，表示T的一个未知子类。
     * Author: 此方法参数是Class<? extends Animal>，只能传入Animal子类的类型，函数返回类型只能声明为Animal或Object类型
     * 如：传入Cat.class，函数返回一个Animal的子类对象，需将此子类对象强制转换为具体的子类(即Cat类)。
     */
    public static Animal creatNew2(Class<? extends Animal> clazz) throws IllegalAccessException, InstantiationException {
        // 打印具体传入的类型
        System.out.println(clazz);
        return clazz.newInstance();
    }

    /**
     * Me    : 此方法的参数类型是Class，可传入任何类，其返回只能声明为Object类对象。
     * Author: 此方法参数是Class，可传入任何类，其返回只能声明为Object类对象。
     * 如：传入Dog.class, 返回的是Object类型的对象，需强制转换为Dog类型的对象。
     */
    public static Object creatNew3(Class clazz) throws IllegalAccessException, InstantiationException {
        // 打印具体传入的类型
        System.out.println(clazz);
        return clazz.newInstance();
    }

    /**
     * Class<T> 在实例化的时候，T 要替换成具体类。其返回只能声明为 T 对象。
     * Class<?> 它是个通配泛型，? 可以代表任何类型。其返回只能声明为 Object 类对象。
     * 传入参数Class<?> 和 上一个方法传入 Class clazz的区别：Class<?> 中的 ? 是通配符，其实就是表示任意符合泛类定义条件的类，和直接使用 Class 效果基本一致，但是这样写更加规范，在某些类型转换时可以避免不必要的 unchecked 错误。
     * 如：Cat.class, 返回的是Object类型的对象，需强制转换为Cat类型的对象。
     */
    public static Object creatNew4(Class<?> clazz) throws IllegalAccessException, InstantiationException {
        // 打印具体传入的类型
        System.out.println(clazz);
        return clazz.newInstance();
    }

    /**
     * 传入Object类型的对象，返回也声明为Object类型。
     */
    public static Object creatNew5(Object object) {
        // 打印具体传入的类型
        System.out.println(object.getClass());
        return object;
    }

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        System.out.println("1-----------");
        Dog dog1 = creatNew1(Dog.class);
        System.out.println(dog1.name + " is " + dog1.type+ "\n");

        System.out.println("2-----------");
        Animal ani1 = creatNew2(Cat.class);
        Cat cat1 = (Cat) ani1;
        System.out.println(cat1.name + " is " + cat1.type + "\n");

        System.out.println("3-----------");
        Object obj = creatNew3(Dog.class);
        Dog dog2 = (Dog) obj;
        System.out.println(dog1.name + " is " + dog2.type + "\n");

        System.out.println("4-----------");
        Object obj2 = creatNew4(Cat.class);
        Cat cat2 = (Cat) obj2;
        System.out.println(cat2.name + " is " + cat2.type + "\n");

        System.out.println("5-----------");
        Object obj3 = creatNew5(new Cat());
        Cat cat3 = (Cat) obj3;
        System.out.println(cat3.name + " is " + cat3.type + "\n");
    }

}

实验结果：

1-----------
class org.example.Dog
name = gou is type = animal 

2-----------
class org.example.Cat
name = mao is type = animal 

3-----------
class org.example.Dog
name = gou is type = animal 

4-----------
class org.example.Cat
name = mao is type = animal 

5-----------
class org.example.Cat
name = mao is type = animal 

---

5、泛型在方法、类、接口上怎么用

5.1 为什么需要泛型

程序中难免会定义一些参数类型不同，功能相同的方法。例如，返回不同类型数组的中间值

这些方法看起来很合理，实则冗余

5.2 什么是泛型

泛型是Java1.5版本引用的特性，它可以将类型参数化

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型，也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

5.3 泛型的使用位置

5.3.1 方法

• 格式：访问修饰符 <T > T 方法名(T 参数名){}
• 用途：限定方法参数类型
  

5.3.2 类

• 格式：访问修饰符 class 类名 <T> {}
• 用途：限定类和成员参数类型
  

5.3.3 接口

• 格式 : 访问修饰符 interface 接口名 <T>{}
• 用途：限定接口和成员参数类型
  
• 注意：实现泛型接口有以下三种方法

  • 接口和实现类都是泛型类
    

  • 接口类型确定，类是泛型
    

  • 接口类型确定，类不是泛型
    

  • 切记，不存在这一种情况：接口和类泛型不一致
    

5.4 注意事项

• 泛型不支持基本数据类型
  

• 泛型参数无法实例化