泛型在Java中的应用

柔情只为你懂 2024-03-31 16:35 97阅读 0赞

**目录**

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);
        }
    }