Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本，Java泛型的实现采取了“伪泛型”的策略，即Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。

目录

1.泛型的基本使用

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。引入泛型的意义在于：适用于多种数据类型执行相同的代码（代码复用）。泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

2.泛型类

2.1 简单泛型类

class Point<T>{         // 此处可以随便写标识符号，T是type的简称  
    private T var ;     // var的类型由T指定，即：由外部指定  
    public T getVar(){  // 返回值的类型由外部决定  
        return var ;  
    }  
    public void setVar(T var){  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
}  
public class GenericsDemo06{  
    public static void main(String args[]){  
        Point<String> p = new Point<String>() ;     // 里面的var类型为String类型
        //类型必须为引用类型；不能为基本类型，如：int、double等。但Integer、Double可以。  
        p.setVar("it") ;                            // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
}

2.2 多元泛型

class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey(){  
        return this.key ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
    public void setKey(K key){  
        this.key = key ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
} 
public class GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  
  
    }  
}

3.泛型接口

package com.generics;

/**
 * @Author DragonOne
 * @Date 2021/8/4 15:24
 */

interface info<T> { // 在接口上定义泛型
    public T getvar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}
class myinfo<T> implements info<T>{ // 定义泛型接口的子类
    private T var ; // 定义属性
    @Override
    public T getvar(){
        return this.var;
    }
    public myinfo(T var){ // 通过构造方法设置属性内容
        this.setvar(var);
    }
    public void setvar(T var){
        this.var = var;
    }

}

public class TestGenInterface {

    public static void main(String[] args){
        info<String> st = new myinfo<String>("dragon");// 声明接口对象 ,通过子类实例化对象  
        System.out.println(st.getvar());
    }

}

// dragon

4.泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型。
之所以使用泛型方法。是因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

• 定义泛型方法语句格式：

• 调用泛型方法语法格式：

说明

• 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
• 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
• 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
• 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

定义泛型方法时，必须在返回值前边加一个 <T> ，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

为什么要用变量c来创建对象呢？
既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。

4.1 类中的泛型方法

//==================================================//
package com.generics;

/**
 * @Author DragonOne
 * @Date 2021/8/4 16:39
 */
public class Gener {
    public <T> T tesad(T t){
        return t;
    }
}


//==================================================//
package com.generics;


/**
 * @Author DragonOne
 * @Date 2021/8/4 16:15
 */

public class TestGenMethod {
    public static void main(String[] args){
        Gener gg = new Gener();
        System.out.println(gg.tesad("werewrer"));
    }
}