泛型总结

泛型总结

泛型标记

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

定义泛型类

package com.example.test;

/**
 * 定义泛型类
 * @param <T>
 */
public class Generic<T> {

    private T flag;

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

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

}

package com.example.test;

/**
 * 测试泛型类
 */
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);
    }

}

定义泛型接口

package com.example.test;

/**
 * 定义泛型接口
 * @param <T>
 */
public interface Igeneric<T> {

    T getName(T name);

}

package com.example.test;

/**
 * 泛型接口实现类
 */
public class IgenericImpl implements Igeneric<String> {

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

}

package com.example.test;

/**
 * 测试
 */
public class Test {

    public static void main(String[] args) {
        Igeneric<String> igeneric = new IgenericImpl();
        String str = igeneric.getName("example");
        System.out.println(str);
    }

}

定义泛型方法

非静态方法

语法结构

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

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

package com.example.test;

/**
 * 泛型方法
 */
public class MethodGeneric {

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

    public <T> T getName(T name){
        return name;
    }

}

package com.example.test;

/**
 * 测试
 */
public class Test {

    public static void main(String[] args) {
        MethodGeneric methodGeneric = new MethodGeneric();
        methodGeneric.setName("example");
        String str = methodGeneric.getName("example");
        System.out.println(str);

    }

}

静态方法

语法结构

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

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

静态方法中使用泛型时有一种情况需要注意一下:

那就是静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上

package com.example.test;

/**
 * 泛型方法
 */
public class MethodGeneric {

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

    public static <T> T getName(T name) {
        return name;
    }

}

package com.example.test;

/**
 * 测试
 */
public class Test {

    public static void main(String[] args) {
        MethodGeneric.setName("example");
        String str = MethodGeneric.getName("example");
        System.out.println(str);
    }

}

泛型方法可变参数

可变参数的特点：

（1）只能出现在参数列表的最后

（2）调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中一数组的形式访问可变参数

package com.example.test;

/**
 * 泛型方法
 */
public class MethodGeneric {

    /**
     * 泛型方法可变参数
     * 传过来的可以是数组也可以是多个单独的参数
     * 但是这边都会当数组处理
     * @param args
     * @param <T>
     */
    public <T> void method(T... args) {
        for (T t : args) {
            System.out.println(t);
        }
    }

}

package com.example.test;

/**
 * 测试
 */
public class Test {

    public static void main(String[] args) {
        //(1)
        MethodGeneric methodGeneric = new MethodGeneric();
        methodGeneric.method("a","b","c");
        //(2)
        String[] arr = new String[]{"a", "b", "c"};
        methodGeneric.method(arr);
    }

}

无界通配符

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

语法结构

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

public class Generic<T> {

    private T flag;

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

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

}

public class ShowMsg {

    public void showFlag(Generic<?> generic){
        System.out.println(generic.getFlag());
    }

}

@Test
public void test() {
    ShowMsg showMsg = new ShowMsg();
    Generic<Integer> generic = new Generic<>();
    generic.setFlag(20);
    showMsg.showFlag(generic);
}

通配符的上限限定

语法结构 ？只能是Number或者Number的子类

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

public class Generic<T> {

    private T flag;

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

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

}

public class ShowMsg {

    public void showFlag(Generic<? extends Number> generic){
        System.out.println(generic.getFlag());
    }

}

@Test
public void testSix() {
    ShowMsg showMsg = new ShowMsg();
    Generic<Integer> generic = new Generic<>();
    generic.setFlag(20);
    showMsg.showFlag(generic);
}

通配符的下限限定

语法结构 ？只能是Integer或者Integer的父类 不适用于泛型类

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

public class Generic<T> {

    private T flag;

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

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

}

public class ShowMsg {

    public void showFlag(Generic<? super Number> generic){
        System.out.println(generic.getFlag());
    }

}

@Test
public void testSix() {
    ShowMsg showMsg = new ShowMsg();
    Generic<Number> generic = new Generic<>();
    generic.setFlag(50);
    showMsg.showFlag(generic);
}

泛型总结

泛型主要用于编译阶段，编译后生成的字节码 class 文件不包含泛型中的类型信息。 类型参数在编译后会被替换成 Object，运行时虚拟机并不知道泛型。因此，使用泛型时，如下几种情况是错误的：

一：基本类型不能用于泛型

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

二：不能通过类型参数创建对象

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