jdk——泛型介绍

最新推荐文章于 2023-06-04 10:52:14 发布
最新推荐文章于 2023-06-04 10:52:14 发布
阅读量277 收藏
点赞数
分类专栏： java 文章标签： java 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuandeyirenxins/article/details/120203220
版权
本文深入探讨了Java中的泛型，包括泛型类、接口和方法的创建，以及泛型通配符的使用。通过实例展示了泛型如何确保类型安全、避免强制转换并提高代码重用性。同时，解释了泛型的类型擦除现象和可能的堆污染问题，以及桥接方法的概念。
摘要由CSDN通过智能技术生成

本质是参数化类型

可以用在类，接口，方法的创建中

  • 类——泛型类.note

public class GenericCla<T,P> {
    public T method1(T t){
        return t;
    }

    public P method2(P p){
        return p;
    }

    public <P> P method3(){
        return null;
    }
}

  • 接口——泛型接口.note

// 定义接口
public interface CalGenneric <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 DoubleCalc<Double> implements CalGenneric<Double>{
    @Override
    public Double add(Double a, Double b) {
        return null;
    }

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

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

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

  • 方法——泛型方法.note

public class GenericMethod<K,V> {
    /**
     * 1、实体方法使用类上定义的泛型
     * @param k
     * @param v
     * @return
     */
    public K method1(K k,V v){
        return null;
    }

    public <T> T method02(){ //2、方法上定义泛型
        return null;
    }


    /**
     * 静态方法中不能直接使用类上定义的泛型
     * 静态方法中可以使用方法上定义的泛型
     * @return
     */
//    public static V method03(){
//        return null;
//    }

    /**
     * class new的时候才加载，所以静态方法中不能直接使用类上定义的泛型   
     * static 声明优先于类加载，所有需要先声明
     */
    public static <P> P method04(){
        return null;
    }
}

先声明，再使用

泛型通配符

无界通配符 ？

上界通配符 ？ extends Number

下界通配符 ？ supper Inteher

import java.util.ArrayList;

/**
 * 泛型通配符：边界的问题
 * 三种边界
 * 无界：？<?>
 * 上界： <? extends E>
 * 下界： <? super E>
 *
 *  编译检查 保证类型的安全
 *  避免强制转换的硬编码
 *  增加调用代码的重用性
 */
public class BoderDemo {

    /**
     * 无界通配符的使用
     */
    public void border01(ArrayList<?> arrayList){
        for (int i=0;i<arrayList.size();i++){
            System.out.println(arrayList.get(0));
        }
    }

    /**
     * 上界通配符的使用
     * <? extends Object> 无界通配符
     */
    public void border02(ArrayList<? extends Number> arrayList){
        for (int i=0;i<arrayList.size();i++){
            System.out.println(arrayList.get(0));
        }
    }

    /**
     * 下界通配符的使用
     */
    public void border03(ArrayList<? super Number> arrayList){
        for (int i=0;i<arrayList.size();i++){
            System.out.println(arrayList.get(0));
        }
    }

    public static void main(String[] args) {
        BoderDemo boderDemo = new BoderDemo();
        ArrayList<String> strList = new ArrayList<>();
        ArrayList<Object> objList = new ArrayList<>();
        ArrayList<Number> numberArrayList = new ArrayList<>();
        ArrayList<Double> doubleArrayList = new ArrayList<>();
        ArrayList<Integer> intArrayList = new ArrayList<>();

        //无界
        boderDemo.border01(strList);
        boderDemo.border01(numberArrayList);
        boderDemo.border01(intArrayList);

        //上界
        boderDemo.border02(numberArrayList);
        boderDemo.border02(doubleArrayList);
//        boderDemo.border02(strList); //泛型编译检查
        //下界
        boderDemo.border03(objList);
    }
}

作用 

编译检查 保证类型的安全

避免强制转换的硬编码

增加调用代码的重用性

编译检查

  • 没有进行泛型约束的类
import java.io.File;

public class ArryListNoGeneric {
    private Object[] elements= new Object[4];
    private int size;

    public Object get(int i){
        if (size>i) return elements[i];
        throw new IndexOutOfBoundsException();
    }

    public void add(Object c){
        elements[size++]=c;
    }

    public static void main(String[] args) {
        ArryListNoGeneric list = new ArryListNoGeneric();
        list.add(1);
        list.add("a");
        list.add(new File("d:/nxjy"));
        System.out.println(list.size);
        String str =  (String) list.get(2);

    }
}
  • 有泛型约束的类

import java.io.File;

public class ArryListHasGeneric<E> {
    private Object[] elements= new Object[4];
    private int size;

    public Object get(int i){
        if (size>i) return elements[i];
        throw new IndexOutOfBoundsException();
    }

    public void add(E c){
        elements[size++]=c;
    }

    public static void main(String[] args) {
        ArryListHasGeneric<String> list = new ArryListHasGeneric<String>();
//        list.add(1);  // 类型检查
        list.add("a");
//        list.add(new File("d:/nxjy"));   // 类型检查
        System.out.println(list.size);
        String str =  (String) list.get(2);
    }
}

避免强制转型类型

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

/**
 * 1、保证类型安全，编译阶段类型检查
 * 2、避免类型转换硬编码
 * 3、调用代码重用性
 */
public class ArryListDemo {

    public void hasGen(){
        List<Integer> list = new ArrayList<>(); //1.7
        list.add(123);
        list.add(124);
        System.out.println("---------------");
        System.out.println(list.get(0).compareTo(list.get(1)));


    }

    public void noGen(){
        List list = new ArrayList();
        list.add(123);
        list.add(124);
        System.out.println("---------------");
        System.out.println(((Integer) list.get(0)).compareTo((Integer)list.get(1)));

    }
}

增加调用代码的重用性

import org.junit.Test;

import static org.junit.Assert.assertTrue;

public class Reuse<T extends Comparable>{

    public Integer compaerTo(T t1,T t2){
        return t1.compareTo(t2);
    }

    @Test
    public void testComara(){
        Reuse<Integer> reuse = new Reuse<>();
        System.out.println(reuse.compaerTo(123,234)==0);
        /**
         * 相当于一个三目运算符，如果结果为false，打印提示语
         */
        assertTrue("正常对比",reuse.compaerTo(123,234)==0);

        Reuse<String> stringReuse = new Reuse<>();
        Integer integer = stringReuse.compaerTo("!23", "234");
        System.out.println(integer);
    }
}

泛型的类型擦除

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

编译之后编译器会才去泛型化的措施。

  1. java中的泛型是假泛型
  2. 编译之后没有泛型 
  3. import org.junit.Test;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;


/**
 * 泛型并不影响数据的基本类型
 * 伪泛型，Java编译期间会将泛型擦除
 */
public class GenType {

    @Test
    public void m01(){
        List list = new ArrayList();
        List<String> strList = new ArrayList<String>();

        System.out.println(list.getClass());
        System.out.println(strList.getClass());
        System.out.println(list.getClass()==strList.getClass()); //true?false?
    }

    @Test
    public void method02() throws Exception {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
//        list.add(1);  //约束类型
        System.out.println(list.size());
        System.out.println("-------------------------");

        /**
         * 泛型擦除
         * 改变定于的泛型，诠释java的泛型是伪泛型，编译之后class会进行泛型的擦除
         * 通俗来讲，就是泛型只在编译阶段起作用，生成class文件之后就不起作用
         */
        Class<? extends List> clazz = list.getClass();
        Method m = clazz.getDeclaredMethod("add", Object.class);
        m.invoke(list,new Object());
        System.out.println(list.size());
    }
}

堆污染

当一个可变泛型参数指向一个无泛型参数时，堆污染就有可能发生

  • 案例1

    import java.util.Set;
import java.util.TreeSet;
/**
 * 当一个可变泛型参数执行一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
        Set set = new TreeSet();
        set.add("addd");
        set.add(100);
        System.out.println(set.size());
    }
}
  • 案例2 
    import java.util.Set;
import java.util.TreeSet;
/**
 * 当一个可变泛型参数执行一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
         Set<Object> set = new TreeSet();
        set.add("addd");
        set.add(100);
        System.out.println(set.size());
    }
}
  • 案例3 
    import java.util.Set;
import java.util.TreeSet;

/**
 * 当一个可变泛型参数执行一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
        Set set = new TreeSet();
        set.add("addd");
        varagMethod(set);
    }

    private static void varagMethod(Set<Integer> set) {
        System.out.println(set.size());
    }
}
  • 案例4 
    import java.util.Set;
import java.util.TreeSet;

/**
 * 当一个可变泛型参数执行一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
        Set set = new TreeSet();
        varagMethod(set);
    }

    private static void varagMethod(Set<Integer> set) {
        set.add(new Integer(100));
        System.out.println(set.size());
    }
}
  • 案例5 
    import java.util.Set;
import java.util.TreeSet;

/**
 * 当一个可变泛型参数执行一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
        Set set = new TreeSet();
        set.add("addd");
        varagMethod(set);
    }

    private static void varagMethod(Set<Integer> set) {
        System.out.println(set.size());
    }
}
  • 案例6 
    import java.util.Set;
import java.util.TreeSet;

/**
 * 当一个可变泛型参数执行一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
        Set set = new TreeSet();
        set.add("addd");
        varagMethod(set);
    }

    private static void varagMethod(Set<Integer> set) {
        set.add(new Integer(100));
        System.out.println(set.size());
    }
}

桥接

1.5之后引入泛型后，为了使java的放心方法生成的字节码和1.5之前的字节码相兼容，编译器自动生成的方法叫做桥接

泛型接口

public interface SuperClass<T> {
    T m01(T param);
}

类实现泛型接口

public class SubClass implements SuperClass<String>{
    @Override
    public String m01(String param) {
        return param + "---";
    }
}

测试

public class BridgeMethosTest {
    public static void main(String[] args) {
        SuperClass superClass = new SubClass();
        System.out.println(superClass.m01("qwer"));
        System.out.println(superClass.m01(new Object()));
    }
}

javap命令看桥接的实现

javap -p -v SubClass.class

jdk1.5之后自动桥接适配，多加了一个类型为Object的m01方法。

想要变瘦的胖子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博客《夯实JAVA基本之一——泛型详解(1)》对应源码
11-17
在《夯实JAVA基本之一——泛型详解(1)》的博客中，作者深入浅出地探讨了泛型的基本概念和用法，本文将基于这个博客源码，详细解析泛型的相关知识点。 首先，泛型的主要目标是提高代码的类型安全性。在未引入泛型...
JDK17上手，新特性让你起飞
qq13281010872的博客
12-03 3411
快又强！JDK17上手体验
JDK17新特性 即将成为主流的JDK 深入了解
最新发布
世上哪有什么岁月静好,不过是有人替你负重前行
06-04 1237
对于JDK17比较明显的特性 总结。Switch 语句增强 优化字符串拼接代码 instanceof增强 密封类（限制继承类） ZGC垃圾收集器
Java泛型详解，史上最全图文详解
热门推荐
mikechen的互联网架构
02-15 5万+
泛型在java中有很重要的地位，无论是开源框架还是JDK源码都能看到它。 毫不夸张的说，泛型是通用设计上必不可少的元素，所以真正理解与正确使用泛型，是一门必修课。 一：泛型本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛.
JDK进阶（6）：泛型
Sam Blog
01-30 739
文章目录泛型基础认识泛型泛型类泛型方法静态方法的泛型参数化类型与原始类型的兼容性泛型的通配符通配符 ?通配符的边界：对？进行限制，限定通配符总是包括自己PECS 原则：`Producer Extends, Consumer Super`泛型擦除（泛型的去类型化）泛型反射参考 泛型基础 认识泛型 集合如 ArrayList 在没有泛型的时候，add函数接收一个Object型的参数，取出的也是Obj...
【JDK】-泛型
机智的路易
07-30 269
为什么要用泛型？在上面的集合源码中，如果将E换成Object。我们向里面放元素完全没问题，但是取元素，却需要类型转换！因为元素放入集合后，他的原有类型都被抹除，向上转型为Object。
jdk1.8——Java开发环境（最常用）
10-17
**JDK1.8——Java开发环境（最常用）** JDK（Java Development Kit）是Oracle公司提供的Java编程工具包，用于开发、编译、调试Java应用程序。JDK1.8，也称为Java 8，是Java历史上一个非常重要的版本，它的发布在...
JDK_API_1_6_zh_CN参考文档
02-21
10. **泛型**：Java 1.5引入的泛型，允许在编译时检查类型安全，同时提供了一种方式来消除装箱和拆箱操作。 11. **枚举类型**：Java 1.5引入的枚举，是一种特殊的类，用于定义有限数量的常量。 12. **注解**：`@...
JDK1.5的泛型实现
09-11
Java开发工具包（JDK）1.5引入了一项重大特性——泛型（Generics），它为编程带来了显著的类型安全性和代码复用性提升。泛型是Java语言设计的一次重要演进，使得程序员可以在定义集合类或者方法时指定元素的类型，...
jdk1.7 官方正式版64位——亲测可用.zip
02-17
在这个特定的压缩包"jdk1.7 官方正式版64位——亲测可用.zip"中，我们拥有的是Oracle公司发布的JDK 1.7的64位版本，适用于64位操作系统的计算机。 JDK 1.7，也被称为Java SE 7（Java Standard Edition 7），在2011...
介绍 JDK 5中泛型
11-22
到目前为止，Java 类库中泛型支持存在最多的地方就是集合框架。就像容器类是 C++ 语言中模板的主要动机一样改善集合类的类型安全是 Java 语言中泛型的主要动机。集合类也充当如何使用泛型的模型，因为它们演示了泛型的几乎所有的标准技巧和方言。
Java泛型编程快速入门
cjiac的专栏
04-15 978
JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型. 1、Java泛型 其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样
JDK5 之 泛型
vihem的博客
11-01 158
JDK5 新增的 泛型 特性
JDK源码——泛型原理
庄小焱
11-23 348
摘要 在JDK1.8之后泛型就被引入在JDK源码中，但是很多初学者和初级工程师，甚至中级工程师对这个泛型的了解不够深入，本文将java的泛型的概念和使用做了详尽的介绍。 泛型是什么？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建
jdk8 泛型理解
LZ的博客
09-04 1493
前言
Jdk1.5新特性之泛型（-）
java-wcj的博客
08-08 2185
Jdk1.5新特性之泛型（-）
java高级部分(三)-(泛型,jdk1.8特性,集合(二))
今昔何年的博客
05-07 2429
                                               泛型  数组直接定义了存储的类型,防止出现其他类型的元素,集合能不能也像数组一样,直接规定我们集合的存储类型,针对这种情况  引进一种技术:泛型   &lt;数据类型&gt; --- 引用数据类型  泛型:将明确的集合类型的工作推迟到了创建对象或者调用方法的时候,属于一种参数化类型,可以作为参数传...
Java泛型：泛型类、泛型接口和泛型方法
weixin_34015566的博客
04-03 366
根据《Java编程思想 （第4版）》中的描述，泛型出现的动机在于： 有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。 泛型类 容器类应该算得上最具重用性的类库之一。先来看一个没有泛型的情况下的容器类如何定义： public class Container { private String key; ...
Java JDK新特性：for-each循环解析
"本文档详细介绍了JDK中的一个新特性——for-each循环，也称为增强的for循环，这是从J2SE5开始引入的一种简化集合遍历的语法结构。" 在Java编程语言中，JDK的新特性之一是引入了for-each循环，这种循环方式极大地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值