java的泛型

一、泛型使用介绍

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法；在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如T、E、K、V、R、P、?、等形式的参数常用于表示泛型形参

1.泛型类

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

• 案例

public class Generic<T> {
    private T val;

    public Generic(T t) {
        this.val = t;
    }
    public T test(T t) {
        return t;
    }
    public T get() {
        return val;
    }
}

• 在实例化泛型类时，必须指定T的具体类型
• 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
• 传入的实参类型需与泛型的类型参数类型相同;

public class Test {
    public static void main(String[] args) {
        Generic<String> stringGeneric = new Generic<String>("11111");
        Generic<Integer> integerGeneric = new Generic<Integer>(11111);
    }
}

2.泛型接口

//定义一个泛型接口
public interface GenericInterface<T> {
    T next();
    T next2(T t);
}

1. 当实现泛型接口的类，未传入泛型实参时

//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
public class GenericService<E> implements  GenericInterface<E> {
    @Override
    public E next() {
        return null;
    }
    @Override
    public E next2(E e) {
        return null;
    }
}

2. 当实现泛型接口的类，传入泛型实参时

/**
 *  传入泛型实参时：
 *  定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口GenericInterface<T>
 *  但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 *  在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * @author: ganyz
 * @datatime: 2021-04-15 16:34
 **/
public class GenericService2 implements  GenericInterface<String> {
    @Override
    public String next() {
        return null;
    }
    @Override
    public String next2(String s) {
        return null;
    }
}

3.泛型方法

• 区分泛型类的方法和泛型方法，看public 和返回值一定有<T>做标识，例如：public <T,K> K showKeyName(Generic<T> container){ return }
• 我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。
• 泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

  /**
     * 泛型方法的基本介绍
     * @param tClass 传入的泛型实参
     * @return T 返回值为T类型
     * 说明：
     *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
     *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
     */
    public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
            IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
    }

1. 普通类的泛型方法
2. 泛型类的泛型方法
3. 可变参数的泛型方法
4. 静态的泛型方法

• 案例

public class MethodClass {
    /**
     * 泛型方法的基本介绍
     * @param tClass 传入的泛型实参
     * @return T 返回值为T类型
     * 说明：
     *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
     *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
     */
    public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
            IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
    }

    public class Test<E> {
        private E e;
        //泛型类的方法
        public E getTest() {
            return e;
        }
        //泛型类的泛型方法
        public <P> P getTest1(P p) {
//            return p;
            return null;
        }
        /**
         * 编译报错，使用泛型E，注意这个E是一种全新的类型，可以与泛型类中声明的E不是同一种类型，所以会报错
        public <E> E getTest2() {
            return e;
        }
         */
        //泛型类的泛型方法，使用泛型E，注意这个E是一种全新的类型，可以与泛型类中声明的E不是同一种类型
        public <E> E getTest3(E e) {
            return e;
        }

        //泛型类的泛型方法，并且是可变参数
        public <T> void test4(T... args) {

        }

    }

    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
     "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

public class MethodClass2<T> {
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
     "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){
    }

    /*编译报错,静态方法要想使用泛型必须声明为泛型方法
     public static void show(T t){

    }
     */
}

4.泛型通配符?

1. 可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

public class MethodClass {
	//这不是一个泛型方法，这是一个普通的方法，只不过使用了泛型通配符?
    public static void genericMethod4(Class<?> tClass)throws InstantiationException ,
            IllegalAccessException{
        Object obj = tClass.newInstance();
    }

	//这不是一个泛型方法，这就是一个普通的方法，只是使用了Class<String>这个泛型类做形参而已
    public static void genericMethod5(Class<String> tClass)throws InstantiationException ,
            IllegalAccessException{
        String str = tClass.newInstance();
    }
}

5.指定泛型上下边界extends，super

1. 泛型类上指定边界
2. 普通方法上的参数是泛型
3. 泛型方法上指定
4. 泛型数组的定义

package com.ganyz.demo.fanxin;

import java.util.ArrayList;
import java.util.List;

/**
 * 参数是泛型类的泛型方法
 * @param <T>
 */
public class ExtendsClass<T> {
    public void test(ExtendsClass<T> ext) {
    }
    //里面的参数是泛型类才可以使用extends
    public void test1(ExtendsClass<? extends Number> ext) {
    }

    public static void main(String[] args) {
        ExtendsClass<Integer> integerExtendsClass = new ExtendsClass<Integer>();
        integerExtendsClass.test1(new ExtendsClass<Integer>());
    }
}

/**
 * 泛型类上声明
 * @param <T>
 */
class ExtendsClass2<T extends List> {
    private T t;
    public void test(T ext) {
    }
    public T setTest(T t) {
        this.t = t;
        return this.t;
    }
    public static void main(String[] args) {
        ExtendsClass2<List> listExtendsClass2 = new ExtendsClass2<List>();
        listExtendsClass2.test(new ArrayList());
        listExtendsClass2.setTest(new ArrayList());
    }
}

/**
 * 泛型方法
 */
class ExtendsClass3 {
    //在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
    //public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
    public <T extends Number> T showKeyName(T t){
        return t;
    }
}