泛型在Java中的应用

目录

1、泛型

2、泛型类

3、泛型接口

3.1、实现类中对接口的泛型指定具体包装类 

3.2、实现类中依然使用泛型

4、泛型方法

5、泛型通配

6、泛型方法中的可变参数

7、泛型对象限制

---

 

1、泛型

作用于编译时用于对象类型检查，运行时不起作用。

泛型的声明在一对尖角括号中 <>，泛型名称可以是任意字母。

2、泛型类

用于类中，在类名末尾对泛型进行声明；

在对该类进行实例化时，需要将泛型指定为具体的包装类，此时，在实例化泛型类时，就可以起到编译时检查的作用。

public class TestGeneric<M> {
    private M t;

    public TestGeneric(M t){
        this.t = t;
    }

    public M getT() {
        return t;
    }

    public void setT(M t) {
        this.t = t;
    }

    public static void main(String[] args) {
        TestGeneric<Integer> generic = new TestGeneric<>(12);
        generic.setT(251);
        System.out.println(generic.getT());

    }
}

 

3、泛型接口

用于接口中，在接口名末尾对泛型进行声明；

public interface GenericInterface<T> {
    T getName(T t);
}

当对该接口创建实现类时，有两种方式

3.1、实现类中对接口的泛型指定具体包装类 

class GenericImpl implements GenericInterface<String>{
    @Override
    public String getName(String s) {
        return s;
    }

    public static void main(String[] args) {
        GenericInterface<String> generic = new GenericImpl();
        String sss = generic.getName("sss");

    }


}

3.2、实现类中依然使用泛型

在实现类中依然使用泛型，但需要在实现类名的后边，对泛型进行重新声明

class GenericImpl2<T> implements GenericInterface<T>{
    @Override
    public T getName(T t) {
        return t;
    }

    public static void main(String[] args) {
        GenericInterface<Integer> g2 = new GenericImpl2<>();
        Integer name = g2.getName(12);
        System.out.println(name);
    }
}

 

4、泛型方法

无论是静态方法还是普通方法，在方法声明中，都必须对泛型进行声明；

public class GenericMethod {
    //无返回值
    public <T> void getName(T t){
        System.out.println(t);
    }

    //有返回值
    public <T> T getAge(T t){
        return t;
    }

    //静态方法，泛型需要在方法声明中定义
    public static <T> void getUser(T t){
        System.out.println("static");
    }

    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.getName("张三");
        Integer age = gm.getAge(123);
        System.out.println(age);
        getUser('A');
    }
}

5、泛型通配

当对泛型类型不确定时，也可以使用 <?> 声明为类型可变的泛型，以增加泛型的灵活适配。

public class NormalGeneric {
    //泛型中的通配符
    public void showMsg(TestGeneric<?> generic){
        System.out.println(generic.getT());
    }

    public static void main(String[] args) {
        NormalGeneric normalGeneric = new NormalGeneric();
        TestGeneric<Integer> g1 = new TestGeneric<>(123);
        normalGeneric.showMsg(g1);

        TestGeneric<String> g2 = new TestGeneric<>("abc");
        normalGeneric.showMsg(g2);

    }
}

6、泛型方法中的可变参数

当泛型方法中的参数不固定时，也可以使用可变参数的写法，来定义泛型方法。

public class NormalGeneric {

    //泛型方法中的可变参数
    public <T> void showMsg(T ... args){
        for (T t : args) {
            System.out.println(t);
        }
    }

    public static void main(String[] args) {
        NormalGeneric normalGeneric = new NormalGeneric();

        normalGeneric.showMsg("hello", "world", "java");
        normalGeneric.showMsg(1, 3, 5);
    }
}

7、泛型对象限制

上限限定：使用 泛型通配符 ? + extends 关键字，指明该泛型只能使用约定类型及其子类型；

下限限定：使用 泛型通配符 ? + super 关键字，指明该泛型只能使用约定类型及其父类型。

public class NormalLimit {
    //泛型类型，通配符的上限限定，只能使用约定类型及其子类型
    public void highLimit(TestGeneric<? extends Number> number){
        System.out.println(number);
    }

    //泛型类型，通配符的下限限定，只能使用约定类型及其父类型
    public void lowLimit(TestGeneric<? super Number> number){
        System.out.println(number);
    }

    public static void main(String[] args) {
        NormalLimit n = new NormalLimit();
        TestGeneric<Integer> t = new TestGeneric<>(123);
        TestGeneric<Number> t2 = new TestGeneric<>(123);
        TestGeneric<Object> t3 = new TestGeneric<>("abc");

        n.highLimit(t2);
        n.highLimit(t);
        //n.highLimit(t3); //上限限定，不能使用父类型

        //n.lowLimit(t); //下限限定，不能使用子类型
        n.lowLimit(t2);
        n.lowLimit(t3);
    }
}