JAVASE提高 -- Java泛型

已于 2023-06-11 19:28:35 修改
阅读量2.8k 收藏
点赞数 2
文章标签： java
于 2022-03-29 17:49:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51677409/article/details/123827636
版权

1. 泛型类

（1）使用语法
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

（2）Java1.7以后，后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();

注意事项 :

  • 泛型类，如果没有指定具体的数据类型，此时，操作类型是Object
  • 泛型的类型参数只能是类类型，不能是基本数据类型, 如 int , float
  • 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型
package com.hjy.pojo;

import lombok.Data;

@Data
public class MyGeneric<T> {
    private T value;
}


public class Main {
    public static void main(String[] args) {
        MyGeneric<String> myGeneric = new MyGeneric<>();
        MyGeneric<Integer> myGeneric2 = new MyGeneric<>();
        myGeneric.setValue("hello");
        System.out.println("myGeneric = " + myGeneric);
        System.out.println(myGeneric.getClass() == myGeneric2.getClass()); // true
    }
}

2. 泛型类派生子类

存在两种请求

  1. 子类也是泛型类，子类和父类的泛型类型要一致
    class ChildGeneric<T> extends Generic<T>
  2. 子类不是泛型类，父类要明确泛型的数据类型
    class ChildGeneric extends Generic<String>
//父类
public class Parent<E> {
    private E value;
    public E getValue() {
        return value;
    }
    public void setValue(E value) {
        this.value = value;
    }
}

/**
 * 泛型类派生子类，子类也是泛型类，那么子类的泛型标识要和父类一致。
 * @param <T>
 */
public class ChildFirst<T> extends Parent<T> {
    @Override
    public T getValue() {
        return super.getValue();
    }
}

/**
 * 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
 */
public class ChildSecond extends Parent<Integer> {
    @Override
    public Integer getValue() {
        return super.getValue();
    }
    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }
}

3. 泛型接口

泛型接口的定义语法：

interface 接口名称 <泛型标识，泛型标识，…> {
	泛型标识 方法名(); 
	.....
}

使用和泛型类的派生对象一样, 也分两种情况

  • 实现类也是泛型类，实现类和接口的泛型类型要一致
/**
 * 泛型接口
 * @param <T>
 */
public interface Generator<T> {
    T getKey();
}
package com.hjy.pojo;

import lombok.Data;
/**
 * 泛型接口的实现类，是一个泛型类，
 * 那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
 * @param <T>
 * @param <E>
 */
@Data
public class Pair<T,E> implements Generator<T>{
    private T key;
    private E value;

    @Override
    public T getKey() {
        return key;
    }
}
  • 实现类不是泛型类，接口要明确数据类型
/**
 * 实现泛型接口的类，不是泛型类，需要明确实现泛型接口的数据类型。
 */
public class Apple implements Generator<String> {
    @Override
    public String getKey() {
        return "hello generic";
    }
}

4. 泛型方法

泛型方法是在调用方法的时候指明泛型的具体类型。

语法: 修饰符 <T，E, ...> 返回值类型 方法名(形参列表) { 方法体... }

  • public与返回值中间非常重要，可以理解为声明此方法为泛型方法
  • 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法
  • < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
  • 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
  • 泛型方法声明的泛型标志和类独立, 但是如果没有发生重叠, 泛型方法是可以使用类定义的泛型标志的
  • 泛型方法是可以声明为静态方法的, 如果static方法要使用泛型能力，就必须使其成为泛型方法
package com.hjy.pojo;

import lombok.Data;

import java.util.List;
import java.util.Random;

@Data
public class MyGeneric<T> {
    private T value;

    // 使用类的泛型标志
    public <R> T hello1(R r) {
        return value;
    }

    // 自定义的泛型标志覆盖类的泛型标志
    public <T> T hello2(List<T> list) {
        Random random = new Random();
        int i = random.nextInt(list.size());
        return list.get(i);
    }
    // 声明静态方法
    public static <T> T hello3(T t) {
        return t;
    }
}


package com.hjy;

import com.hjy.pojo.Children;
import com.hjy.pojo.MyGeneric;
import com.hjy.pojo.Pair;

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

public class Main {
    public static void main(String[] args) {
        MyGeneric<String> g = new MyGeneric<>();
        g.setValue("hello");
        System.out.println(g.hello1(1));

        List<String> list = new ArrayList<>();
        list.add("笔记本");
        list.add("手机");
        list.add("哈哈");
        System.out.println(g.hello2(list));

        System.out.println(MyGeneric.hello3("he"));
    }
}

5. 类型通配符

在java中，数组是可以协变的，比如dog extends Animal，那么Animal[] 与dog[]是兼容的。而集合是不能协变的，也就是说List<Animal>不是List<dog>的父类，这时候就可以用到通配符了。

  • 类型通配符一般是使用"?"代替具体的类型实参。
  • 所以，类型通配符是类型实参，而不是类型形参
public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        h1(list); //报错
        h2(list); // 正常
    }

    public static void h1(List<Number> list) {

    }

    public static void h2(List<Integer> list) {

    }
}

如上, Number 是 Integer 类的父类, h1(list) 按道理来说不会报错, 可以指定泛型就是认死理 ,不是指定的类型就报错, 这个时候我们就可以使用 ? 类型通配符来操作

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        h1(list); //报错
        h2(list); // 正常
    }

    public static void h1(List<?> list) {

    }

    public static void h2(List<?> list) {
        for (Object o : list) {
            
        }
    }
}

现在就不报错了, 可是单纯的使用通配符会让其类型默认为 Object, 我们有什么办法解决呢 ?

类型通配符的上限

  • 语法：
    类/接口<? extends 实参类型>

要求该泛型的类型，只能是实参类型，或实参类型的子类类型,多用于函数参数

class Animal {

}

class Cat extends Animal{

}

class MiniCat extends Cat{

}

public class Main {
    public static void main(String[] args) {
        List<Animal> list1 = new ArrayList<>();
        List<Cat> list2 = new ArrayList<>();
        List<MiniCat> list3 = new ArrayList<>();
        show(list1); // 报错
        show(list2); // 正常
        show(list3); //正常
    }
    
    public static void show(List<? extends Cat> list) {
		// 报错, 因为这时候它只知道你是 Cat 的子类, 但是不知道你是 Cat 具体的哪个子类
        // list.add(new Cat());
    }

}

类型通配符的下限

  • 语法：
    类/接口<? super 实参类型>

要求该泛型的类型，只能是实参类型，或实参类型的父类类型。多用于函数参数

class Animal {

}

class Cat extends Animal{

}

class MiniCat extends Cat{

}

public class Main {
    public static void main(String[] args) {
        List<Animal> list1 = new ArrayList<>();
        List<Cat> list2 = new ArrayList<>();
        List<MiniCat> list3 = new ArrayList<>();
        show(list1); // 正常
        show(list2); // 正常
        show(list3); //报错
    }

    public static void show(List<? super Cat> list) {
		// 正常, 因为这时候它知道你是 Cat 的父类, 符合编译
         list.add(new Cat());
    }

}

总结

我们要记住这么几个使用原则, 有人将其称为PECS(即"Producer Extends, Consumer Super", 网上翻译为"生产者使用extends, 消费者使用super", 我觉得还是不翻译的好). 也有的地方写作"in out"原则, 总的来说就是:

  • in或者producer就是你要读取出数据以供随后使用(想象一下List的get), 这时使用extends关键字, 固定上边界的通配符. 你可以将该对象当做一个只读对象;
  • out或者consumer就是你要将已有的数据写入对象(想象一下List的add), 这时使用super关键字, 固定下边界的通配符. 你可以将该对象当做一个只能写入的对象;
  • 当你希望in或producer的数据能够使用Object类中的方法访问时, 使用无边界通配符;
  • 当你需要一个既能读又能写的对象时, 就不要使用通配符了.

普通的泛型标志使用类型通配符的上限和下限

我们可以使用 extends 和 super 来缩小 泛型的范围

先看下面这个样例

@Data
public class MyGeneric<T> {
    private T value;

    public void he() {
        value.he();
    }

}

class Animal {
    public void he() {
        System.out.println("heh");
    }
}


public class Main {
    public static void main(String[] args) {
        MyGeneric<Animal> generic = new MyGeneric<>();
        generic.setValue(new Animal());
        generic.he();
    }

}

这样使用的话, 就会报错, 可是我想让他可以正常使用, 怎么办呢 ?

我们可以指定其上限为 Animal ,这样它即可以泛化 Animal 的子类, 也可以使用 Animal 中定义的方法

package com.hjy.pojo;


class Animal {
    public void he() {
        System.out.println("heh");
    }
}

package com.hjy.pojo;

import lombok.Data;


@Data
public class MyGeneric<T extends Animal> {
    private T value;

    public void he() {
        value.he();
    }

}


public class Main {
    public static void main(String[] args) {
        MyGeneric<Animal> generic = new MyGeneric<>();
        generic.setValue(new Animal());
        generic.he();
    }

}

当然, 我们也可以使用 下限

@Data
public class MyGeneric<T> {
    private T value;
	// 锁定了参数一定是 T 的 父类或者它自己
    public void he(Comparator<? super T> comparator) {
        value.he();
    }

}

6. 类型擦除

泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为–类型擦除。

类型擦除有四种情况, 下面我们以反射为例为大家解释

无限制类型擦除

在这里插入图片描述

package com.hjy;

import java.lang.reflect.Field;

class TheGeneric<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

public class Main {
    public static void main(String[] args) {
        TheGeneric<String> generic = new TheGeneric<>();
        // 获取字节码
        Class<? extends TheGeneric> aClass = generic.getClass();
        Field[] fields = aClass.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + ":" + field.getType().getSimpleName());
        }
    }


}

结果:

value:Object

有限制类型擦除

在这里插入图片描述

package com.hjy;

import java.lang.reflect.Field;

class TheGeneric<T extends String> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

public class Main {
    public static void main(String[] args) {
        TheGeneric<String> generic = new TheGeneric<>();
        // 获取字节码
        Class<? extends TheGeneric> aClass = generic.getClass();
        Field[] fields = aClass.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + ":" + field.getType().getSimpleName());
        }
    }


}


value:String

擦除方法中类型定义的参数

在这里插入图片描述

package com.hjy;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

class TheGeneric<T extends String> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public <T extends Number> T hehe(T t) {
        return t;
    }
}

public class Main {
    public static void main(String[] args) {
        TheGeneric<String> generic = new TheGeneric<>();
        // 获取字节码
        Class<? extends TheGeneric> aClass = generic.getClass();
        Method[] methods = aClass.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() + ":"+ method.getReturnType().getSimpleName());
        }
    }


}


hehe:Number
getValue:String
setValue:void

桥接方法

在这里插入图片描述

package com.hjy;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

interface Info<T> {
    T info(T var);
}

class TheGeneric implements Info<Integer> {


    @Override
    public Integer info(Integer var) {
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        TheGeneric generic = new TheGeneric();
        // 获取字节码
        Class<? extends TheGeneric> aClass = generic.getClass();
        Method[] methods = aClass.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() + ":"+ method.getReturnType().getSimpleName());
        }
    }


}


info:Integer
info:Object

7. 泛型与数组

  • 可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
ArrayList<String>[] listArr = new ArrayList<5>(); //会报错

但是我们可以先创建出不带泛型的对象, 再将这个赋值给带泛型的对象

ArrayList[] list = new ArrayList[5];
ArrayList<String>[] listArr = list;
// 或者
ArrayList<String>[] listArr = new ArrayList[5];
  • 可以通过java.lang.reflect.Array的newInstance(Class,int)创建T[]数组
public class Fruit<T> {
    private T[] array;

    public Fruit(Class<T> clz, int length){
        //通过Array.newInstance创建泛型数组
        array = (T[])Array.newInstance(clz, length);
    }
}
忆世界
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
POJO对象set数据的泛型方法（通用方法）
jutem的专栏
05-06 1115
最近遇到一个用excel文件批量上传某对象数据的问题
java8源码-javase8-sample:javase8-sample
06-04
#javase8-sample 该项目仅用于学习java8，请随意Fork，更改 #博文地址 所有博客的源代码都能在这里 src/main/java/java8sample Chapter 1: 通往lambda之路_语法篇 Chapter 2: 深入解析默认方法 Chapter 3: 解开...
Java中的泛型
qq_37177642的博客
02-05 110
先来看一段代码 什么是泛型 public static List list = new ArrayList(); public static void main(String[] args) { list.add(1); list.add("2"); System.out.println((Integer)list.get(0)); System.out.println((Integer)list.get(1)); } 这
java 数组 协变类型6_为什么数组是协变的，但是泛型是不变的？
weixin_31874603的博客
02-23 265
原因是每个数组在运行时都知道其元素类型，而泛型集合不知道类型擦除。例如：String[]strings=newString[2];Object[]objects=strings;//valid,String[]isObject[]objects[0]=12;//error,wouldcausejava.lang.ArrayStoreException:jav...
java 数组协变_java 数组是协变
weixin_42511315的博客
02-16 699
简单说不可以，String 是 Object 的子类型，但是 List 不是 List 的子类型，让我们为什么直观上会觉得 List 和 List 存在父子关系呢？那是因为 java 编译器认为 String[] 是 Object[] 的子类型。但是这个设计有些问题，看如下代码Object[] myArray = new String[]{"a", "b", "c"};myArray[1] = 1...
J2SE：泛型的基本使用
少年啦飞啦的博客
10-22 95
泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？说的通俗一些就类似于形参，可以在开始时不去指定具体的类型，而是由泛型来替代，通常用T/E/V/K等大写字母来表示。泛型可以用在类、接口和方法中，分别称为泛型类、泛型接口、泛型方法。 // 以List集合为例，如果不使用泛型，那么可以存储所有类型的数据，这样虽然很爽， // 但是会很...
javase-training:Java SE培训幻灯片
05-07
12. **Java SE 8及后续版本的新特性**：例如Lambda表达式、函数式接口、Stream API、日期时间API等，这些新特性极大地提高了Java的易读性和效率。 在"javase-training-master"这个压缩包中，可能包含了关于以上知识...
java8源码-javase8-sample:javase8-sample.git
06-04
#javase8-sample 该项目仅用于学习java8，请随意Fork，更改 #博文地址 所有博客的源代码都能在这里 src/main/java/java8sample Chapter 1: 通往lambda之路_语法篇 Chapter 2: 深入解析默认方法 Chapter 3: 解开...
JavaSE专题-List集合.doc
06-03
- 集合类支持泛型，这意味着在创建集合实例时可以指定元素类型，从而在编译时提供类型检查，避免了类型转换异常，提高了代码的安全性。 7. **比较器与迭代器** - Comparator接口用于自定义对象间的比较规则，可以...
JAVASE --api
04-19
JavaSE（Java Standard Edition）是Java开发平台的标准版，它为构建桌面应用程序提供了核心功能。API（Application Programming Interface）则是JavaSE的一部分，是一系列预先定义的类和接口，供开发者在编写程序时...
JAVA<T>泛型的应用，太好使了
极客蓝天
10-20 2141
@Override public int insertBatch(List&amp;lt;SCT&amp;gt; list,String filename) { int result=0; try{ if(list.size()&amp;gt;0){ Object obj=list.get(0); if(obj *instanceof* ScCredTmTxnHst){ res...
java带泛型的实体类
热门推荐
feinifi的博客
01-12 2万+
对于带泛型的实体，会有两个问题困扰我们，第一：如何获取泛型的类型，第二：如何实例化带泛型的实体类。 第一个问题可以先看代码：      class A{ private String name; public String getName(){return this.name;} public void setName(String name){this.name = name;}
java 对象 泛型,Java 持有对象以及泛型基础
weixin_29164497的博客
03-13 440
1、泛型 > 泛型一般结合集合类又叫容器类(Colletion)来使用ArrayList nameList=newArrayList();2、泛型的类型可以向上转型publicclass泛型 {//泛型publicstaticvoidmain(String[] args) {ArrayList list=newArrayList();list.add(newTeacher(...
泛型通配符详解
jarniyy的博客
03-28 5252
为什么要用通配符呢? 在java中，数组是可以协变的，比如dog extends Animal，那么Animal[] 与dog[]是兼容的。而集合是不能协变的，也就是说List<Animal>不是List<dog>的父类，这时候就可以用到通配符了。 一、基本概念： 在学习Java泛型的过程中, 通配符是较难理解的一部分. 主要有以下三类: 1. 无边界的通配符(Unb...
java泛型带来的变量声明冗长问题
ldk99_的博客
06-13 375
对于 Java 5.0 中新增的泛型工具，一个常见的抱怨就是，它使代码变得太冗长。原来用一行就够的变量声明不再存在了，与声明参数化类型有关的重复非常讨厌，特别是还没有良好地支持自动补足的 IDE。例如，如果想声明一个Map，它的键是Socket，值是Future<String>，那么老方法就是： Map socketOwner = new HashMap(); 比新方法紧凑...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 554
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 395
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 380
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 318
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Java泛型详解与学习指南
学习JavaSE技术时，需要扎实的基本功，熟悉Java语法，并能熟练查阅官方文档（DOC文档）以获取详细信息。解决问题的能力也很重要，这包括理解和调试代码，以及在遇到困难时能够寻求帮助并进行有效的沟通。编程过程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值