泛型（Generics）

泛型本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入。我们可以把“泛型”理解为数据类型的一个占位符（类似：形式参数），即告诉编译器，在调用泛型时必须传入实际类型。

参数化类型，白话说就是：

        把类型当作是参数一样传递

        <数据类型>只能是引用类型

泛型的好处

在不使用泛型的情况下，我们可以使用Object类型来实现任意参数类型，但是在使用时需要我们强制进行转换。

代码可读性更好【不用强制转换】

程序更加安全【只要编译时期没有警告，运行时期就不会出现ClassCastException异常】

类型擦除

编码时采用泛型写的类型参数，编译器会在编译时去掉，这称之为“类型擦除”。

泛型主要用于编译阶段，编译后生成的字节码class文件不包含泛型中的类型信息，涉及类型转换任然是普通的强制类型转换。类型参数在编译后会被替换成Object，运行时虚拟机并不知道泛型。

泛型主要是方便了程序员的编写，以及更好的安全性检测。

泛型类

定义泛型时，一般采用几个标记：E、T、K、V、N、？。他们约定俗称的含义如下：

泛型标记	对应单词	说明
E	Element	在容器中使用，表示容器中的元素
T	Type	表示普通的Java类
K	Key	表示键，例如：Map中的键Key
V	Value	表示值
N	Number	表示数值类型
?		表示不确定的Java类型

泛型类的使用 

语法结构：

public class 类名<泛型标识符>{

}

public class 类名<泛型标识符，泛型标识符>{

}

class Generic<T>{
    private T flag;

    public void setFlag(T flag){
        this.flag = flag;
    }
    public T getFlag（）{
        return this.flag;
    }
}

public class Test{
    public static void main(String[] args){
    //创建对象时，指定泛型具体类型。
        Generic<String> generic = new Generic<>();
        generic.setFlag("admin");
        String flag = generic.getFlag();
        System.out.println(flag);

    //创建对象时，指定泛型具体类型。
        Generic<Integer> generic1 = new Generic<>();
        generic1.setFlag(100);
        Integer flag1 = generic1.getFlag();
        System.out.println(flag1);
        
    }
}

泛型接口的使用

 语法结构：

public interface 接口名<泛型标识符>{

}

public interface 接口名<泛型标识符，泛型标识符>{

}

interface IGeneric<T>{
    T getName(T name);
}
//在实现接口时传递具体数据类型
class IgenericImpl implements IGeneric<String>{
    @Override
    public String getName(String name){
        return name;

    }
}

//在实现接口时任然使用泛型作为数据类型
class IGenericImpl2<T> implements IGeneric<T>{

    @Override
    public T getName(T name){
        return name;
    }
}


public class Test{
    public static void main(String[] args){
        IGeneric<String> igneric = new IGenericImp1();
        String name = igeneric.getName("old");
        System.out.println(name);


        IGeneric<String> igeneric1 = new IGenericImpl2<>();
        String name1 = igeneric1.getName("it")
        System.out.println(name1);

    }
}

 在方法上定义泛型

类上定义的泛型，在方法中也可以使用。但是，我们经常需要仅仅在某一个方法上使用泛型，这时候可以使用泛型方法。

调用泛型方法时，不需要像泛型类那样告诉编译器是什么类型，编译器可以自动推断出类型。

泛型方法的使用

非静态方法

非静态方法可以使用泛型类，也可以将泛型定义在方法上。

语法结构：

//无返回值方法

public <泛型标识符号> void getName(泛型标识符号 name){

}

//有返回值方法

public <泛型标识符号> 泛型标识符号 getName(泛型标识符号 name){

}

class MethodGeneric{
    public <T> void setName(T name){
        System.out.println(name);
    }
    public <T> T getAge(T age){
        return age;
    }
}

public class Test2{
    public static void main(String[] args){
        MethodGeneric methodGeneric = new MethodGeneric();
        methodGeneric.setName("lu");

//泛型中要求包含的是对象类型，基本数据类型不属于对象，使用要使用其对应的封装类，如int类型就要使用Integer类
        Integer age = methodGeneric.getAge(123);
        System.out.println(age);
        
    } 
}

静态方法

静态方法中使用泛型时有一种情况需要注意一下，那就是静态方法无法访问类上定义的泛型，所以必须要将泛型定义在方法上。

语法结构：

//无返回值静态方法

public static <泛型标识符> void setName(泛型标识符号 name){

}

//有返回值静态方法

public static <泛型标识符> 泛型标识符号 getName(泛型标识符号 name){

}  

class MethodGeneric{
    public static <T> void setFlag(T flag){
        System.out.println(flag);
    }
    public static <T> T getFlag(T flag){
        return flag;
    }
}
public class Test4{
    public static void main(String[] args){
        MethodGeneric.setFlag("lu");
//静态方法的调用直接使用类名.方法名();
        Integer flag1 = MethodGeneric.getFlag(123123);
        System.out.println(flag1);
    }
}

泛型方法与可变参数 

在泛型方法中，泛型也可以定义可变参数类型。

语法结构：

public <泛型标识符号> void showMsg(泛型标识符号...args){

}

class MethodGeneric{
    public <T> void method(T...args){
        for(T t:args){
            System.out.println(t);
        }
    }
}
public class Test{
    public static void main(String[] args){
        MethodGeneric methodGeneric = new MethodGeneric();
        String[] arr = new String[]{"a","b","c"};
        Integer[] arr2 = new Integer[]{1,2,3};
        methodGeneric.method(arr);
        methodGeneric.method(arr2);
    }
}