Java泛型用法

​ 本质：参数化类型

泛型的擦除：

​ 泛型只在编译阶段有效，编译之后JVM会采取去泛型化的措施.

​ 泛型在运行阶段是没有效果

泛型通配符的介绍

概念

• 泛型的类型擦除

  泛型只在编译阶段有效,泛型类型在逻辑上可看成是多个不同的类型，但是其实质都是同一个数据类型

  编译之后程序会采取去泛型化的措施

• 泛型通配符的介绍

  

• 泛型的具体使用

  泛型跟我们的成员属性一样,需要先声明才能使用.泛型的声明采用 <> 进行声明.

  申明一般约定采用单个大写字母表示.常用的有 K E T V 等等字符

1.无边界通配符

<?> 通用的类型

package com.atxiaodei;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName Demo1
 * @Deacription 无边界通配符
 * @Author 王盟
 * @Date 2021/6/6 18:30
 * @Version 1.0
 **/
public class Demo1 {
    public static void main(String[] args) {
            List<String> list1 = new ArrayList<>();
            list1.add("小得");
            list1.add("卡布达");
            list1.add("诸葛孔暗");
            loop(list1);
        }

        public static void loop(List<?> list){
            for (int i = 0; i < list.size() ; i++) {
                System.out.println(list.get(i));
            }
        }

}

2.上边界通配符

< ? extends Number > 代表从Number往下的子类货孙类对象都可以使用

package com.atxiaodei;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName Demo2
 * @Deacription TODO
 * @Author 卡布达
 * @Date 2021/6/6 18:34
 * @Version 1.0
 **/
public class Demo2 {
    public static void main(String[] args) {
        List<Number> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        loop(list2);
    }

    /**
     *  ?  extends Number
     *  通用的类型必须是Number及其子类
     * @param list
     */
    public static void loop(List<? extends Number> list){
        for (int i = 0; i < list.size() ; i++) {
            System.out.println(list.get(i));
        }
    }
}

3.下边界通配符

<? super Integer> www.meimeitu8.com代表从Integer 到Object所有的对象都可以

package com.atxiaodei;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName Demo3
 * @Deacription TODO
 * @Author 卡布达
 * @Date 2021/6/6 18:38
 * @Version 1.0
 **/
public class Demo3 {
    public static void main(String[] args) {
        List<Number> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        loop(list2);
    }
    /**
     *  ?  super Number
     *  通用类型必须是Integer 到Object类型的对象
     * @param list
     */
    public static void loop(List<? super Number> list){
        for (int i = 0; i < list.size() ; i++) {
            System.out.println(list.get(i));
        }
    }
}

泛型的具体的使用

• 规则
  • 必须先声明再使用
  • 泛型的声明是通过"<>"实现
  • 约定泛型可以使用单个大写字母来表示 K E T V 等

泛型类

public class Demo04 <T> {

    private T t;

    public T getT() {
        return t;
    }

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

    public PersonNew(T t) {
        this.t = t;
    }
}

增加我们代码的灵活度

泛型方法

public class Demo05 <K,V> {

    /**
     * 普通方法 可以使用 类中定义的泛型
     * @param k
     * @param v
     * @return
     */
    public K method1(K k,V v){
        return (K)null;
    }

    /**
     * 普通方法  使用方法中定义的泛型
     * @param t
     * @param v
     * @param <T>
     * @return
     */
    public <T> T method2(T t,V v){
        return (T)null;
    }

    /**
     * 在静态方法中我们没法使用 类中定义的泛型
     * @return
     */
    public static <K> K method3(){
        return null;
    }

泛型接口

public interface CalGeneric <T> {

    T add(T a,T b);

    T sub(T a,T b);

    T mul(T a,T b);

    T div(T a,T b);
}

public class CalIntegerGeneric implements  CalGeneric<Integer> {
    @Override
    public Integer add(Integer a, Integer b) {
        return null;
    }

    @Override
    public Integer sub(Integer a, Integer b) {
        return null;
    }

    @Override
    public Integer mul(Integer a, Integer b) {
        return null;
    }

    @Override
    public Integer div(Integer a, Integer b) {
        return null;
    }
}