java泛型

最新推荐文章于 2023-06-10 07:58:57 发布
最新推荐文章于 2023-06-10 07:58:57 发布
阅读量783 收藏 22
点赞数 8
分类专栏： 左手之光 文章标签： Java泛型 泛型 泛型总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuanyuanjiaqi/article/details/99464546
版权

java泛型

泛型概述

  • 泛型的目的: 为了保证类型安全
  • “?” 是泛型的通配符
  • 我们用大写字母T、E、K、V等形式的参数常用于表示泛型形参,用以在实际使用中接受泛型的实参

泛型的应用总结

普通泛型

class Point<T> { // 此处可以随便写标识符号，T是type的简称
    private T var; // var的类型由T指定，即：由外部指定
    public T getVar() { // 返回值的类型由外部决定
        return var;
    }

    public void setVar(T var) { // 设置的类型也由外部决定
        this.var = var;
    }
}

public class GenericsDemo06 {
    public static void main(String[] args) {
        Point<String> p = new Point<String>(); // 里面的var类型为String类型
        p.setVar("it"); // 设置字符串
        System.out.println(p.getVar().length()); // 取得字符串的长度
    }
}
----------------------------------------------------------
class Notepad<K, V> { // 此处指定了两个泛型类型

    private K key; // 此变量的类型由外部决定
    private V value; // 此变量的类型由外部决定

    public K getKey() {
        return this.key;
    }

    public V getValue() {
        return this.value;
    }

    public void setKey(K key) {
        this.key = key;
    }

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

public class GenericsDemo09 {
    public static void main(String[] args) {
        Notepad<String, Integer> t = null; // 定义两个泛型类型的对象
        t = new Notepad<String, Integer>(); // 里面的key为String，value为Integer
        t.setKey("汤姆"); // 设置第一个内容
        t.setValue(20); // 设置第二个内容
        System.out.print("姓名；" + t.getKey()); // 取得信息
        System.out.print("，年龄；" + t.getValue()); // 取得信息
    }
}

通配符

	class Info<T> {
	    private T var; // 定义泛型变量
	    public void setVar(T var) {
	        this.var = var;
	    }
	
	    public T getVar() {
	        return this.var;
	    }
	
	    public String toString() { // 直接打印
	        return this.var.toString();
	    }
	}
	
	
	public class GenericsDemo14 {
	    public static void main(String[] args) {
	        Info<String> i = new Info<String>(); // 使用String为泛型类型
	        i.setVar("it"); // 设置内容
	        fun(i);
	    }
	
	    public static void fun(Info<?> temp) { // 可以接收任意的泛型对象
	        System.out.println("内容：" + temp);
	    }
	}

受限泛型

	class Info<T> {
	    private T var; // 定义泛型变量
	    public void setVar(T var) {
	        this.var = var;
	    }
	
	    public T getVar() {
	        return this.var;
	    }
	
	    public String toString() { // 直接打印
	        return this.var.toString();
	    }
	}
	
	public class GenericsDemo17 {
	    public static void main(String[] args) {
	        Info<Integer> i1 = new Info<Integer>(); // 声明Integer的泛型对象
	        Info<Float> i2 = new Info<Float>(); // 声明Float的泛型对象
	        i1.setVar(30); // 设置整数，自动装箱
	        i2.setVar(30.1f); // 设置小数，自动装箱
	        fun(i1);
	        fun(i2);
	    }
	
	    public static void fun(Info<?extends Number> temp) { // 只能接收Number及其Number的子类
	        System.out.print(temp + "、");
	    }
	}
-------------------------------------------------
class Info<T> {
    private T var; // 定义泛型变量
    public void setVar(T var) {
        this.var = var;
    }

    public T getVar() {
        return this.var;
    }

    public String toString() { // 直接打印
        return this.var.toString();
    }
}

public class GenericsDemo21 {
    public static void main(String[] args) {
        Info<String> i1 = new Info<String>(); // 声明String的泛型对象
        Info<Object> i2 = new Info<Object>(); // 声明Object的泛型对象
        i1.setVar("hello");
        i2.setVar(new Object());
        fun(i1);
        fun(i2);
    }

    public static void fun(Info<?super String> temp) { // 只能接收String或String父类的泛型
        System.out.print(temp + "、");
    }
}

Java泛型无法向上转型

class Info<T> {
    private T var; // 定义泛型变量
    public void setVar(T var) {
        this.var = var;
    }

    public T getVar() {
        return this.var;
    }

    public String toString() { // 直接打印
        return this.var.toString();
    }
}

public class GenericsDemo23 {
    public static void main(String[] args) {
        Info<String> i1 = new Info<String>(); // 泛型类型为String
        Info<Object> i2 = null;
        i2 = i1; // 这句会出错 incompatible types
    }
}

Java泛型接口

interface Info<T> { // 在接口上定义泛型
	public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}
	
class InfoImpl<T> implements Info<T> { // 定义泛型接口的子类
	private T var; // 定义属性

	public InfoImpl(T var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}
		
	public void setVar(T var) {
		this.var = var;
	}
	
	 public T getVar() {
	    return this.var;
	 }
}
	
public class GenericsDemo24 {
	 public static void main(String[] arsg) {
	 	Info<String> i = null; // 声明接口对象
	    i = new InfoImpl<String>("汤姆"); // 通过子类实例化对象
	    System.out.println("内容：" + i.getVar());
	 }
}
-------------------------------------------------------
interface Info<T> { // 在接口上定义泛型
    public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl implements Info<String> { // 定义泛型接口的子类
    private String var; // 定义属性

    public InfoImpl(String var) { // 通过构造方法设置属性内容
        this.setVar(var);
    }

    public void setVar(String var) {
        this.var = var;
    }

    public String getVar() {
        return this.var;
    }
}

public class GenericsDemo25 {
    public static void main(String[] arsg) {
        Info i = null; // 声明接口对象
        i = new InfoImpl("汤姆"); // 通过子类实例化对象
        System.out.println("内容：" + i.getVar());
    }
}

Java泛型方法

class Demo {
    public <T> T fun(T t) { // 可以接收任意类型的数据

        return t; // 直接把参数返回
    }
}

public class GenericsDemo26 {
    public static void main(String[] args) {
        Demo d = new Demo(); // 实例化Demo对象
        String str = d.fun("汤姆"); // 传递字符串
        int i = d.fun(30); // 传递数字，自动装箱
        System.out.println(str); // 输出内容
        System.out.println(i); // 输出内容
    }
}

通过泛型方法返回泛型类型实例

	class Info<T extends Number> { // 指定上限，只能是数字类型
	    private T var; // 此类型由外部决定
	
	    public T getVar() {
	        return this.var;
	    }
	
	    public void setVar(T var) {
	        this.var = var;
	    }
	
	    public String toString() { // 覆写Object类中的toString()方法
	        return this.var.toString();
	    }
	}
	public class GenericsDemo27 {
	    public static void main(String[] args) {
	        Info<Integer> i = fun(30);
	        System.out.println(i.getVar());
	    }
	
	    public static <T extends Number> Info<T> fun(T param) { // 方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
	
	        Info<T> temp = new Info<T>(); // 根据传入的数据类型实例化Info
	        temp.setVar(param); // 将传递的内容设置到Info对象的var属性之中
	
	        return temp; // 返回实例化对象
	    }
	}

使用泛型统一传入的参数类型

class Info<T> { // 指定上限，只能是数字类型
    private T var; // 此类型由外部决定

    public T getVar() {
        return this.var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    public String toString() { // 覆写Object类中的toString()方法
        return this.var.toString();
    }
}

public class GenericsDemo28 {
    public static void main(String[] args) {
        Info<String> i1 = new Info<String>();
        Info<String> i2 = new Info<String>();
        i1.setVar("HELLO"); // 设置内容
        i2.setVar("汤姆"); // 设置内容
        add(i1, i2);
    }

    public static <T> void add(Info<T> i1, Info<T> i2) {
        System.out.println(i1.getVar() + " " + i2.getVar());
    }
}

Java泛型数组

	public class GenericsDemo30 {
	    public static void main(String[] args) {
	        Integer[] i = fun1(1, 2, 3, 4, 5, 6); // 返回泛型数组
	        fun2(i);
	    }
	    public static <T> T[] fun1(T... arg) { // 接收可变参数
	        return arg; // 返回泛型数组
	    }
	
	    public static <T> void fun2(T[] param) { // 输出
	        System.out.print("接收泛型数组：");
	        for (T t : param) {
	            System.out.print(t + "、");
	        }
	    }
	}

Java泛型的嵌套设置

class Info<T, V> { // 接收两个泛型类型
    private T var;
    private V value;

    public Info(T var, V value) {
        this.setVar(var);
        this.setValue(value);
    }

    public void setVar(T var) {
        this.var = var;
    }

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

    public T getVar() {
        return this.var;
    }

    public V getValue() {
        return this.value;
    }
}

class Demo<S> {
    private S info;

    public Demo(S info) {
        this.setInfo(info);
    }

    public void setInfo(S info) {
        this.info = info;
    }

    public S getInfo() {
        return this.info;
    }
}

public class GenericsDemo31 {
    public static void main(String[] args) {
        Demo<Info<String, Integer>> d = null; // 将Info作为Demo的泛型类型
        Info<String, Integer> i = null; // Info指定两个泛型类型
        i = new Info<String, Integer>("汤姆", 30); // 实例化Info对象
        d = new Demo<Info<String, Integer>>(i); // 在Demo类中设置Info类的对象
        System.out.println("内容一：" + d.getInfo().getVar());
        System.out.println("内容二：" + d.getInfo().getValue());
    }
}
serve the people
关注
  • 8
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java泛型总结
04-09
### Java泛型总结 #### 一、Java泛型概述 Java泛型是在JDK5之后引入的一个特性，它提供了一种类型安全的机制，用于指定集合或其他数据结构中的元素类型。通过使用泛型，程序员可以在编译阶段检测类型错误，避免了...
Java泛型的简单实例
09-04
Java泛型的简单实例 Java泛型是一种类型系统特性，它允许开发者在编写代码时指定类型参数，从而使代码更加灵活、可重用和类型安全。在本文中，我们将通过一个简单的示例来介绍Java泛型的使用。 泛型的概念 泛型是...
java集合
servepeople的博客
08-13 117
java集合集合概述List(有序集合)Set(无序集合,元素不可重复)MapQueue工具类Arrays和Collections 集合概述 集合就是对象的容器 List(有序集合) Vector和ArrayList 不同点 ArrayList: 1.线程不安全 2.速度快 3. 长度增长率为50% Vector: 1.线程安全 2.速度慢 3. 长度增长率为100% 相...
Java并发编程
servepeople的博客
08-13 110
Java并发编程CompletionService分支/合并（fork/join）框架SemaphoreReentrantLockReentrantReadWriteLockBlockingQueueCountDownLatchCyclicBarrierConcurrentHashMap CompletionService ExecutorService的扩展，可以获得线程执行结果 可以将...
java注解
servepeople的博客
08-13 120
java注解注解的作用注解的种类 注解的作用 生成文档 实现替代配置文件功能(比如Spring) 在编译时进行格式检查。如@override 注解的种类 标记注解(无属性) --> @Override 单值注解 --> @注解名(p=“abc”) 多值注解 --> @注解名(p=“abc”,q=“bcd”) ...
Java网络编程
servepeople的博客
08-13 213
Java网络编程TCP和UDP的区别网络编程中的关键类和接口BIO编程NIO编程(应用反应器模式)AIO编程BIO,NIO,AIO的区别 TCP和UDP的区别 UDP 每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接 UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。 UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方 U...
Java泛型
BroRiver
03-26 1218
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
java 泛型
最新发布
Misszhoudandan的博客
06-10 1568
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 61万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
Java 中的泛型（两万字超全详解）
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java泛型详解
梦想不会灭
05-30 846
一、泛型的本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 二、泛型的作用 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率 1、保证类型的安全性 在没有泛型之前，从集合中
Java泛型定义与用法实例详解
08-27
Java泛型定义与用法实例详解 Java泛型是Java语言中的一种重要机制，用于在编译期检查类型安全，避免在运行期引发ClassCastException。泛型的引入使得Java语言更加灵活和强大，本文将详细介绍Java泛型的定义、原理、...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
JTA
servepeople的博客
08-23 2492
概念 java事务API(Java Transaction API,简称JTA)是一个Java企业版的应用程序接口。不过JTA只是提供了一个接口，并没有提供具体的实现。 常见的JTA实现如下 J2EE容器所提供的JTA实现(JBoss) 独立的JTA实现:如JOTM，Atomikos 二阶段提交协议 将各个库视为参与者,而将分布式事物管理器视为协调者 协调者对各参与者发起预提交请求 各参与者...
IM即时通讯需要解决的问题
servepeople的博客
08-26 1276
IM四大难题 消息可靠到达 路由寻址 高并发 状态流转 即时通讯问题列表 点对点通信： 客户端和服务器端如何存储好友列表 客户端和服务器端好友如何状态保存以及流转 好友分组结构在客户端和服务器端如何存储 客户端消息如何本地化，消息的增删改如何与服务器端同步 消息在客户端与服务器端是如何保存以及传递的 消息离线如何做到 消息漫游如何做到 如何处理图片和语音以及视频消息 群组通信： ...
云计算的三种服务模式: IaaS，PaaS和SaaS
servepeople的博客
08-24 1124
任何一个在互联网上提供服务的公司都可以叫做云计算公司。 云计算也是分层的，Saas、Paas、IaaS既是云计算的三种不同的服务模式，也是云计算的三个层次。 Infrastructure（基础设施）-as-a-Service在最下端，Platform（平台）-as-a-Service在中间，Software（软件）-as-a-Service在顶端 IaaS --> Infrastruct...
CRM、OA、ERP、HR、进销存
servepeople的博客
08-26 1043
CRM --> 追踪客户的 CRM是英文Customer Relationship Management （客户关系管理）的简称。这个比较好理解，就是用来管理客户的。一般来说，CRM客户管理系统由客户信息管理、销售过程自动化（SFA）、营销自动化（MA）、客户服务与支持（CSS）管理、客户分析（CA）系统这5大主要功能模块组成。通俗一点说，CRM系统特别是移动CRM系统能帮助你及你的同事很方...
Java泛型深入解析
Java泛型是自JDK 1.5版本引入的一种强大的编程特性，它允许在类、接口和方法中使用类型参数，以增强类型安全性和代码重用性。本教程将深入讲解这一主题，帮助开发者理解和应用泛型。 1. **泛型基础** 泛型的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值