Java面向对象编程-泛型

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量612 收藏 2
点赞数
分类专栏： Java面向对象编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50743381/article/details/124620420
版权

泛型

1、泛型问题的引出

泛型从JDK1.5之后追加到Java语言里面的，其主要的是为了解决ClassCastException的问题，在进行对象的向下转型时永远都存在有安全隐患，而Java希望通过泛型慢慢解决掉此类问题

泛型问题的引出
现在假设说定义一个描述x与y坐标的处理类，并且在这个类之中允许开发者保存有三类数据

  • 整型数据：x=10、y=20

  • 浮点型数据：x=10.1、y=20.9

  • 字符串型数据：x=东经120度、北纬30度

于是在设计Point类的时候就需要去考虑具体的x和y属性的类型，这个类型要求保存以上三种数据，很明显，最普通的做法就是利用Object类来进行定义，因为存在有以下转型关系：

  • 整型数据：基本数据类型 →包装为Integer类对象 → 自动向上转型为Object类
  • 浮点型数据：基本数据类型 →包装为Integer类对象 → 自动向上转型为Object类
  • 字符型数据：String类型 → 自动向上转型为Object类
    定义Point类：
class Point{
	private Object x ;
	private Object y ;
	public void setX(Object x){
		this.x = x;
	}
	public void setY(Object y){
		this.y = y ;
	}
	public Object getX(){
		return x;
	}
	public Object getY(){
		return y;
	}
}

下面进行内容的设置
进行正确的内容操作：

public class JavaDemo {
	public static void main(String[] args) {
		//第一步：根据需求进行内容的设置
		Point point = new Point();
		point.setX(10);	//自动装箱
		point.setY(20);	//自动装箱
		//第二步：从里面获取数据
		int x = (Integer)point.getX();
		int y = (Integer)point.getY();
		System.out.println("X坐标：" + x + "\nY坐标：" + y);
	}
}

本程序之所以可以解决当前的设计问题，主要的原因在于，Object可以接受所有的数据类型，但正因为如此，所以本代码也会出现严重的安全隐患

public class JavaDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Point point = new Point();
		point.setX(10);
		point.setY(北纬20度);	//这里进行了更改
		int x = (Integer)point.getX();
		int y = (Integer)point.getY();
		System.out.println("X坐标：" + x + "\nY坐标：" + y);
	}
}

此时的程序明显出现了问题，如果在程序编译的时候实际上是不会有任何的错误产生的，而程序执行的时候就会出现ClassCastException异常类型，所以本程序的设计是存在有安全隐患的。
而这个安全隐患存在的一局在于使用了Object类型，因为Object可以涵盖的范围太广了，而对于这样的错误如果可以直接出现在编译的过程之中，那么就可以避免运行时的尴尬

2、泛型的基本定义

如果想要避免项目之中出现ClassCastException最好的做法是可以直接回避掉对象的强制转换，
所以在JDK1.5之后，提供有泛型技术，而泛型的本质在于，
类中的属性或方法的参数与返回值的类型可以由对象实例化的时候动态决定

那么此时就需要在类定义的时候明确的定义占位符（泛型标记）

class Point <T>{
	private T x ;
	private T y ;
	public void setX(T x){
		this.x = x;
	}
	public void setY(T y){
		this.y = y ;
	}
	public Object getX(){
		return x;
	}
	public Object getY(){
		return y;
	}
}

此时Point类中的x和y属性的数据类型并不确定，而是由外部来决定

提示：关于默认的泛型类型

  • 由于泛型是属于JDK1.5之后的产物，但是在这之前已经有不少内容的程序类或者是接口广泛的应用到项目的开发之中，

但是有了泛型之后，原始的程序类依然可以使用，所以如果不设置泛型类型时，自动将使用Object作为类型，以保证程序的正常执行，但是在编译的过程之中会出现警告信息

泛型定义完成后可以在实例化对象的时候进行泛型类型的设置，一旦设置之后，里面的x与y的类型就直接与当前的对象绑定了

 class Point <T>{
	private T x ;
	private T y ;
	public void setX(T x){
		this.x = x;
	}
	public void setY(T y){
		this.y = y ;
	}
	public T getX(){
		return this.x;
	}
	public T getY(){
		return this.y;
	}
}
public class JavaDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Point<Integer> point = new Point<Integer>();
		point.setX(10);
		point.setY(20);
		int x = point.getX();
		int y = point.getY();
		System.out.println("X坐标：" + x + "\nY坐标：" + y);
	}
}

现在的程序代码之中，由于Point类里面设置的泛型类型为Integer，这样所有的对应此泛型的属性、变量、方法返回值就将全部替换为Integer（只局限于此对象之中），这样在进行处理的时候如果发现设置的内容有错误，则会在程序编译的时候错误提示，同时也避免了对象的向下转型处理（可以避免安全隐患）

泛型的使用注意点：

  • 泛型之中只允许设置引用类型，如果现在要操作基本类型必须使用包装类
  • 从JDK1.7之后，泛型对象实例化可以简化为 Point point = new Point<>();
    使用泛型可以解决大部分类对象的强制转换处理，这样的程序才是一个合理的设计

3、泛型方法

在之前的程序类里面实际上已经可以发现在泛型类之中如果将泛型标记写在了方法上，那么这样的方法就被称为泛型方法，但是需要注意的是，泛型方法不一定要出现在泛型类之中

public class JavaDemo {
	public static void main(String[] args) {
		Integer num [] = fun(1,2,3);
		for(int temp : num){
			System.out.print(temp + "、");
		}
	}
	public static <T> T [] fun(T ... args){
		return args ;
	}
}

在后期进行项目开发的时候，这种泛型方法很常见，与之前的工厂设计为例
如果此时一个项目有上千个接口，到时候满眼望去都是绝望的身影
利用泛型改进工厂设计模式：

4、泛型接口

泛型除了可以在类上定义之外也可以直接在接口之中进行使用
定义一个泛型接口：

interface IMessage<T>{
	public String echo(T t);
}
class MessageImpl<S> implements IMessage<S>{
	public String echo (S t){
		return "【ECHO:】" + t ;
	}
}
public class JavaDemo {
	public static void main(String[] args) {
		IMessage <String> msg = new MessageImpl<>();
		System.out.println(msg.echo("www.shenmenglin.xyz")) ;
	}
}

实现方式二：在子类是父类接口的时候直接定义出具体泛型类型

interface IMessage<T>{
	public String echo(T t);
}
class MessageImpl implements IMessage<String>{
	public String echo (String t){
		return "【ECHO:】" + t ;
	}
}
public class JavaDemo {
	public static void main(String[] args) {
		IMessage <String> msg = new MessageImpl();
		System.out.println(msg.echo("www.shenmenglin.xyz")) ;
	}
}

如果从概念和实现上来讲并不复杂，但是在日后会遇见大量出现有泛型的接口，这个时候一定要清楚两种实现原则

5、泛型通配符

虽然泛型帮助开发者解决了一系列的对象的强制转换所带来的的安全隐患，但是从另一方面讲，泛型也带来了新的问题：引用传递处理

class Message<Type>{
	private Type content;
	public Message(){}
	public Message(Type content){
		this.content = content;
	}
	public void setContent(Type content){
		this.content = content;
	}
	public Type getContent(){
		return content;
	}
}
public class JavaDemo {
	public static void main(String[] args) {
		Message<String> msg = new Message<>();
		msg.setContent("www.shenmenglin");
		fun(msg);
	}
	public static void fun(Message<String> temp){
		System.out.println(temp.getContent());
	}

}

这个时候问题出现了，而问题的关键就在于fun()方法上，如果真的使用泛型，不可能知识一种类型，也就是说fun()方法应该可以接收任意种泛型类型的Message对象。
但是这个时候它只能接收Message类型，因此需要一种可以接收所有的泛型类型，并且不能够谢盖里面的数据（允许获取），那么就需要通过通配符？来解决这个问题
使用通配符：

public class JavaDemo {
	public static void main(String[] args) {
		Message<String> msgA = new Message<>();
		Message<Integer> msgB = new Message<>();
		msgA.setContent("www.shenmenglin");
		msgB.setContent(123235);
		fun(msgA);
		fun(msgB);
	}
	public static void fun(Message<?> temp){
		System.out.println(temp.getContent());
	}
}

此时在fun()方法里面由于采用了Message结合通配符的处理所以可以接受所有类型，并且可以获取数据
在？这个通配符的基础上实际上还提供有两个类小的通配符：

  • ?extends 类：设置泛型上限
  • 例如：定义 ?extends Number ：表示该泛型类型只允许设置Number 或者Number 的子类
  • ?super 类：设置泛型下限
    • 例如：定义 ?super String ：只能够使用String或者String父类
      泛型的上限配置：
class Message<Type extends Number>{
	private Type content;
	public Message(){}
	public Message(Type content){
		this.content = content;
	}
	public void setContent(Type content){
		this.content = content;
	}
	public Type getContent(){
		return content;
	}
}
public class JavaDemo {
	public static void main(String[] args) {
		Message<String> msgA = new Message<>();
		msgB.setContent(1234);
		fun(msgA);
	}
	public static void fun(Message<? extends Number> temp){
		System.out.println(temp.getContent());
	}

}

泛型的下限配置：

class Message<Type >{
	private Type content;
	public Message(){}
	public Message(Type content){
		this.content = content;
	}
	public void setContent(Type content){
		this.content = content;
	}
	public Type getContent(){
		return content;
	}
}
public class JavaDemo {
	public static void main(String[] args) {
		Message<String> msgB = new Message<>();
		msgB.setContent("www.shenmenglin.xyz");
		fun(msgB);
	}
	public static void fun(Message<? super String> temp){
		System.out.println(temp.getContent());
	}
}

对于通配符而言是一个重要的概念，并且要求一定要理解此概念的定义，在日后学习Java一些系统类库的时候会见到大量的通配符使用

MyRedScarf
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java面向对象编程——泛型
qq_25036849的博客
12-29 322
目录 一、定义一个Point泛型，如以下程序： 实例化Point类，如以下程序： 关于默认的泛型类型：由于泛型是JDK1.5之后的产物，但是在此之前有不少的内置程序类或者是接口广泛应用在项目开发之中，为保证这些类或接口在追加了泛型之后，原始的类依然可以使用，所以如果没有设置泛型的类型，自动将使用Object作为类型以保证程序的正常执行，但是在编译中会出现警告。 泛型的使用注意点：1.泛型之中只允许设置引用类型，如果现在要操作的基本类型，必须使用包装类；2.从JDK1.7开始，泛型对象实例化可以简化为
Educoder–Java面向对象-泛型程序设计【笔记+参考代码】
12-21
Java中的泛型是面向对象程序设计的一个重要特性，它允许我们在类、接口和方法中使用类型参数，从而创建可重用的组件，这些组件能够处理多种数据类型而无需显式进行类型转换。泛型的主要目标是提高代码的类型安全性和...
小白学java之面向对象编程-编写泛型
u012768297的博客
11-21 168
编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中，例如ArrayList，我们很少需要编写泛型类。 如果我们确实需要编写一个泛型类，那么，应该如何编写它？ 可以按照以下步骤来编写一个泛型类。 首先，按照某种类型，例如：String，来编写类： public class Pair { private String first; private String last; public Pair(String first, String last) { .
Java面对面向程序设计_Java面向对象程序设计--泛型编程
weixin_31910545的博客
02-28 197
1. 为何要进行泛型编程？泛型变成为不同类型集合提供相同的代码！省去了为不同类型而设计不同代码的麻烦！2. 一个简单泛型类的定义:1 public classPairTest12 {3 public static voidmain(String[] args)4 {5 String[] arr = {"This","is","the","end","of","the","w...
Java--泛型(通配符、泛型边界、泛型与继承)
天行健 君子以自强不息，地势坤 君子以厚德载物。
03-24 2602
1. 通配符 有时泛型实例的作用域无法指明具体的参数类型。 通配符类型，表示任何类型，通配符类型的符号是“?”, 因此通配符类型可应用与所有继承自Object的类上。 1.1 通配符的使用 示例: package Generic; import java.util.Date; public class Test<T> { public static void main(String[] args) { Class<?> c1 = Integer.cla
C++语言类型详解：编译式、静态类型、过程化编程、面向对象编程和泛型编程
weixin_42080490的博客
10-03 1645
C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。 那么静态类型、编译式、过程化编程、面向对象编程和泛型编程该怎么理解呢？ 静态类型 VS 动态类型 理解静态与动态之别，我们要从变量赋值这个操作为切入点。静态类型语言中，变量的类型必须先声明，即在创建的那一刻就已经确定好变量的类型，而后的使用中，你只能将这一指定类型的数据赋值给变量。如果强行将其他不相干类型的数据赋值给它，就会引发错误。而动态类型则没有这样的限制，你将什么类型的数据赋值给变量，
Java泛型编程
琅枫的博客
09-01 870
Java泛型应用是java核心基础之一，从java5开始引入泛型概念。如果你曾经使用过java中的collection相关的类，那么就算你已经接触过泛型了。在java的Collection中使用泛型是一件很简单的事情，可泛型还具有许多你想不到的作用。在深入了解泛型之前，首先来了解一下泛型的一些基本概念与原理。 ———————————————— 版权声明：本文为CSDN博主「陈九龙的博客」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 ......
Java 泛型---泛型的介绍和使用以及实例
你微笑时特美的博客
02-28 363
Java 泛型—泛型的介绍和使用以及实例 泛型的介绍 一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。 在面向对象编程语言中，多态算是一种泛型机制。例如使用一个基类作为方法的参数类型，那么该方法的参数类型能够接受该基类导出的子类和自己作为参数。但是final类除外。如果方法的参数是一个接口，而不是类，...
Java学习笔记 -- 泛型
程序员小章的博客
08-17 228
Java泛型 概述 泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定 义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 使用 泛型类 定义一个泛型类： public class ClassName<T>{ private T data; public T getData() { return data; }public void setData(T data) { this.data = data; } } 泛型
孙卫琴java面向对象编程(答案及源码)
07-20
本书采用由浅入深、与实际应用紧密结合的方式，利用大量经典的实例，详细讲解Java面向对象的编程思想、编程语法和设计模式，介绍常见Java类库的用法，总结优化Java编程的各种宝贵经验，深入阐述Java虚拟机执行Java...
Java面向对象编程头歌
05-23
Java面向对象编程头歌是一个专门为Java开发者设计的学习资源，旨在系统化地讲解Java面向对象编程（Object-Oriented Programming, OOP）的核心概念和实用技巧。该资源结合理论知识和实际案例，通过视频教程、示例代码...
Java面向对象编程课件.zip
07-12
Java面向对象编程是Java语言的核心特性之一，它使得程序设计更加灵活、可维护性更强。在本课件中，我们将深入探讨Java中的面向对象编程（OOP）概念，包括类、对象、封装、继承、多态等核心概念。 1. 类与对象： 类...
Java面向对象知识点的思维导图
11-10
这个导图可以帮助学习者系统地理解和掌握Java面向对象编程的核心概念，以及各种相关的语法和用法。 适用人群： 这个资源适用于初学者和有一定Java基础的开发者。初学者可以通过导图了解和学习Java面向对象编程的...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 252
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1010
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 96
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 546
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
访问者模式在面向对象编程与泛型Java中的应用探索
"面向对象编程中的访问者模式及其在树状数据结构遍历中的应用" 在面向对象编程中，访问者模式是一种设计模式，它允许我们添加新的操作到已存在的类而不修改这些类的源代码。这个模式尤其适用于处理树状数据结构，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MyRedScarf

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值