泛型是 JDK1.5 以后增加的，它可以帮助我们建立类型安全的集合。

什么是泛型

泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入，可以把“泛型”理解为数据类型的一个占位符(类似：形式参数)

  1. 把类型当作是参数一样传递。、

  2. <数据类型> 只能是引用类型。

两个好处：

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

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

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

泛型主要用于编译阶段，编译后生成的字节码 class 文件不包含泛型中的类型信息，涉及类型转换仍然是普通的强制类型转换。

类型参数在编译后会被替换成Object，运行时虚拟机并不知道泛型

定义泛型

语法结构

普通java类泛型标记

public class 类名<泛型表示符号> {
}

public class GenericDemo1 {
    private static class Generic<T> {  // 定义一个泛型类 ，泛型类型为T，【根据实例化的时候定义详细引用类型
        private T flag; // T泛型类型待定

        public void setFlag(T flag) {
            this.flag = flag;
        }

        public T getFlag() {
            return flag;
        }
    }
    public static void main(String[] args) {
        Generic<String> generic = new Generic<>();  // 实例化泛型类，泛型为String类型，name这个类的所有 T 都将变成String
        generic.setFlag("admin");
        String flag = generic.getFlag();
        System.out.println(flag);

        Generic<Integer> generic1 = new Generic<>();// 实例化泛型类，泛型为String类型，name这个类的所有 T 都将变成integer【int的包装类】
        generic1.setFlag(100);
        Integer flag1 = generic1.getFlag();
        System.out.println(flag1);

    }

}

泛型接口

泛型接口 和 泛型类 的声明方式一致。泛型接口的具体类型需要在实现类中进行声明。

public interface 接口名<泛型表示符号> {
}

public class interfaceimp implements 接口名<泛型具体类型>{
    @Override
    ······
}

public class GenericDemo2 {
    public interface Igeneric<T> {  // 定义一个 接口泛型
        T getName(T name);
    }

    public static class IgenericImpl implements Igeneric<String> {  // 实现接口类，并将泛型定义为String类型
        @Override
        public String getName(String name) {  // 实现接口类，重写里面的getName方法
            return name;
        }
        public int getAge(int a){
            return a;
        }
    }

    public static void main(String[] args) {
        IgenericImpl igeneric = new IgenericImpl();  // 直接实例化接口实现类
        String name = igeneric.getName("张三");
        System.out.println(name);
        Igeneric<String> igeneric1 = new IgenericImpl(); // 接口向上转型为接口Igeneric，调用getName，因为此方法已经被IgennericImp实现，所以可以调用
        String name1 = igeneric1.getName("kkkkk");
//        int age = igeneric1.getAge(14);   // 因为igeneric1 被认为是 Igeneric类型 ，而接口中没有getAge这个方法，所以不能调用
        int age1 = igeneric.getAge(16); // getAge是接口实现类里面的方法，所以可以调用
        System.out.println(name1);

    }

}

泛型方法是指将方法的参数类型定义成泛型，以便在调用时接收不同类型的参数。

类型参数可以有多个，用逗号隔开，如：<E,C,W>。定义时，类型参数一般放到返回值前面。

调用泛型方法时，不需要像泛型类那样告诉编译器是什么类型，编译器可以自动推断出类型来。–》这一点就像解释性语言不用写数据类型一样

泛型方法—非静态方法

public <泛型表示符号> void getName(【形参类型】泛型表示符号 【形参名字】name){  
    
}

public <泛型表示符号> 【返回类型】泛型表示符号 getName(【形参类型】泛型表示符号 【形参名字】name){
}

public class demo3_link {
        public <T> void setName(T name){  // 非静态方法--方法泛型
            System.out.println(name);
        }
        public <T> T getName(T name){
            return name;
        }
}


public class GenericDemo3 {
    public static void main(String[] args) {
        demo3_link methodGeneric = new demo3_link();  // 实例化非静态方法的类
        methodGeneric.setName("whoami");  // 调用非静态方法--泛型 泛型类型编译器自动判断出来 ====>String类型
        methodGeneric.setName(123123);  // ====>int类型
        demo3_link methodGeneric2 = new demo3_link();
        String name = methodGeneric2.getName("whereisme");
        Integer name1 = methodGeneric2.getName(321321);
        System.out.println(name1);
        System.out.println(name);

    }
}

泛型方法—静态方法

  静态方法中使用泛型时有一种情况需要注意一下，那就是静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

public static <泛型表示符号> void setName(泛型表示符号name){
    
}
public static <泛型表示符号> 泛型表示符号 getName(泛型表示符号name){

}

public class GenericDemo4 {
    public static class MethodGeneric {
        public static <T> void setName(T name) {
            System.out.println(name);
        }

        public static <T> T getName(T name) {
            return name;
        }
    }
    public static void main(String[] args) {
//      类名.静态方法名的格式来调用静态方法 ，也是自动识别泛型具体类型
        MethodGeneric.setName("张三");
        MethodGeneric.setName(1010122);
//        实例化类，用对象名.方法名调用， 也是自动识别泛型具体类型
        MethodGeneric methodGeneric2 = new MethodGeneric();
        String name = methodGeneric2.getName("new张三");
        Integer name1 = methodGeneric2.getName(123);
        System.out.println(name1);
        System.out.println(name);
    }
}

泛型方法与可变参数

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

• 可变参数的注意事项

  • 这里的变量其实是一个数组

  • 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

public <泛型表示符号> void showMsg(泛型表示符号... agrs){ // ...表示可变
    
}

public class Metherd5_link {

    public <T> void method(T... args) {  // 遍历方法   ... 这三个点为可变
        for (T t : args) {
            System.out.println(t);
        }
    }
}

public class Metherd5 {
    public static void main(String[] args) {
        Metherd5_link methodGeneric = new Metherd5_link();
        String[] arr = new String[]{"a","b","c"};
        Integer[] arr2 = new Integer[]{1,2,3};
        methodGeneric.method(arr); // 遍历abc
        methodGeneric.method(arr2);// 遍历123
    }

}

通配符和上下限定

无界通配符

“?”表示类型通配符，用于代替具体的类型。它只能在“<>”中使用。解决当具体类型不确定的问题

public void showFlag(Generic<?> generic){
}

public class Unbounded_wildcard {

    public static class Generic<T> {   // 定义一个一个泛型类
        private T flag;

        public void setFlag(T flag) {
            this.flag = flag;
        }

        public T getFlag() {
            return this.flag;
        }
    }

    public static class ShowMsg {
        public void showFlag(Generic<?> generic) {  // “?”表示类型通配符，用于代替具体的类型。它只能在“<>”中使用。可以解决当具体类型不确定的问题。
            System.out.println(generic.getFlag());
        }
    }

    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new Generic<>();
        generic.setFlag(202222);  // integer
        showMsg.showFlag(generic);
        Generic<Number> generic1 = new Generic<>();
        generic1.setFlag(50);  // Numer
        showMsg.showFlag(generic1);
        Generic<String> generic2 = new Generic<>();
        generic2.setFlag("this is flag3");  // 字符串类型
        showMsg.showFlag(generic2);
    }
}

通配符的上限限定

上限限定表示通配符的类型是 T 类以及 T 类的子类或者 T 接口以及T 接口的子接口。该方式同样适用于与泛型的上限限定。

public void showFlag(Generic<? extends Number> generic){
}

通配符的下限限定

下限限定表示通配符的类型是 T 类以及 T 类的父类或者 T 接口以及T 接口的父接口。注意：该方法不适用泛型类。

public void showFlag(Generic<? super Integer> generic){
}

泛型总结

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

1. 基本类型不能用于泛型。

  Test<int> t; 这样写法是错误，我们可以使用对应的包装类；Test<Integer> t ;

2. 不能通过类型参数创建对象。
  T elm = new T();  运行时类型参数 T 会被替换成 Object，无法创建T 类型的对象，容易引起误解，所以在 Java 中不支持这种写法。

原文地址：http://www.cnblogs.com/e-link/p/16815580.html