Java泛型

最新推荐文章于 2024-05-29 23:10:16 发布
最新推荐文章于 2024-05-29 23:10:16 发布
阅读量645 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yangyingchungood/article/details/123069132
版权

Java泛型

泛型简介

Java泛型是J2 SE1.5中引入的一个新特性

泛型可以在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的。

泛型的原理就是 “类型的参数化”，即把类型看做参数。也就是说把所要操作的数据类型看做参数，就像方法的形式参数一样，是运行时传递的值的占位符一样。

简单的说，类型变量扮演的角色就如同一个参数，它提供给编译器用来类型检查的信息。

泛型可以提高代码的扩展性和重用性。


class Cls1 <T>   //定义泛型类
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}

public class Test {
	public static void main(String[] args) {
		Cls1<Integer> cls1 = new Cls1<Integer>(20);  //使用泛型类
		System.out.println(cls1.getData());
		
		Cls1<String> cls2 = new Cls1<String>("木易");
		System.out.println(cls2.getData());
	}
}

泛型类及特点

泛型的类型参数可以是泛类型

class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}
public class Test {
	public static void main(String[] args) {
		Cls1<Cls1<Integer>> cls1 = new Cls1<Cls1<Integer>>(new Cls1<Integer>(20));
		System.out.println(cls1.getData().getData());
	}
}

执行结果：
结果

泛型类可以同时设置多个类型参数

class Cls2 <T,T2>
{
	T a;
	T2 b;
	public Cls2(T a,T2 b){
		this.a = a;
		this.b = b;
	}
	public T getData(){
		return a;
	}
	public T2 getData2(){
		return b;
	}
}

public class Test {
	public static void main(String[] args) {
		Cls2<Integer,String> cls3 = new Cls2<Integer,String>(500,"wang");
	 	System.out.println(cls3.getData());
	 	System.out.println(cls3.getData2());
	 	
	 	System.out.println(cls3.getData()+cls3.getData2());
	 	
	 	Cls2<Integer,Integer> cls4 = new Cls2<Integer,Integer>(500,20);
	 	System.out.println(cls4.getData()+cls4.getData2());
	}
}

执行结果：
结果

泛型类可以继承泛型类


class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}
class Cls2 <T,T2> extends Cls1<T>
{
	T2 b;
	public Cls2(T a,T2 b){
		super(a);
		this.b = b;
	}
	public T2 getData2(){
		return b;
	}
}

public class Test {
	public static void main(String[] args) {
		Cls1<Cls1<Integer>> cls1 = new Cls1<Cls1<Integer>>(new Cls1<Integer>(20));
		System.out.println(cls1.getData().getData());
		
		Cls2<Integer,String> cls = new Cls2<Integer,String>(40,"zhang");
		System.out.println(cls.getData()+" "+cls.getData2());
		
		
	}
}

执行结果：
结果

继承抽象类：

abstract class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
	abstract void printinfo();
}
class Cls2 <T,T2> extends Cls1<T>
{
	T2 b;
	public Cls2(T a,T2 b){
		super(a);
		this.b = b;
	}
	public T2 getData2(){
		return b;
	}
	void printinfo() {
		// TODO Auto-generated method stub
		System.out.println("输出");
	}
}

public class Test {
	public static void main(String[] args) {
		
		Cls2<Integer,String> cls = new Cls2<Integer,String>(40,"zhang");
		System.out.println(cls.getData()+" "+cls.getData2());
		cls.printinfo();
		
		
	}
}

执行结果：
结果

泛型类可以实现泛接口


abstract class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
	abstract void printinfo();
}

interface Cls3<T3>
{
	abstract void printInfoCls3(T3 t);
}

class Cls2 <T,T2,T3> extends Cls1<T> implements Cls3<T3>
{
	T2 b;
	public Cls2(T a,T2 b){
		super(a);
		this.b = b;
	}
	public T2 getData2(){
		return b;
	}
	void printinfo() {
		// TODO Auto-generated method stub
		System.out.println("输出");
	}
	public void printInfoCls3(Object t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
}

public class Test {
	public static void main(String[] args) {
		
		Cls2<Integer,String,String> cls = new Cls2<Integer,String,String>(80,"木易");
		System.out.println(cls.getData()+" "+cls.getData2());
		cls.printinfo();
		cls.printInfoCls3("测试");
		
		
	}
}

执行结果：
结果

限制泛型可用类型

在定义泛型类别时，默认在实例化泛型的时候可以使用任何类型，但是如果想要限制使用泛型类型时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义该类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口。

当没有指定泛类型继承的类型或接口时，默认使用extends Object，所以默认情况下任何类型都可以做为参数传入

限定泛类型只能是String：


abstract class Cls1 <T extends String>   //限定泛类型T只能是String
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
	abstract void printinfo();
}

interface Cls3<T3>
{
	abstract void printInfoCls3(T3 t);
}

class Cls2 <T extends String,T2,T3> extends Cls1<T> implements Cls3<T3>
{
	T2 b;
	public Cls2(T a,T2 b){
		super(a);
		this.b = b;
	}
	public T2 getData2(){
		return b;
	}
	void printinfo() {
		// TODO Auto-generated method stub
		System.out.println("输出");
	}
	public void printInfoCls3(Object t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
}

public class Test {
	public static void main(String[] args) {
		
		Cls2<String,String,String> cls = new Cls2<String,String,String>("muyi","木易");
		System.out.println(cls.getData()+" "+cls.getData2());
		cls.printinfo();
		cls.printInfoCls3("测试");
		
		
	}
}

执行结果：
结果

限定泛类型只能继承类：


class Animal
{
	
}

class Dog extends Animal
{
	
}

abstract class Cls1 <T extends Animal>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
	abstract void printinfo();
}

interface Cls3<T3>
{
	abstract void printInfoCls3(T3 t);
}

class Cls2 <T extends Animal,T2,T3> extends Cls1<T> implements Cls3<T3>
{
	T2 b;
	public Cls2(T a,T2 b){
		super(a);
		this.b = b;
	}
	public T2 getData2(){
		return b;
	}
	void printinfo() {
		// TODO Auto-generated method stub
		System.out.println("输出");
	}
	public void printInfoCls3(Object t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
}

public class Test {
	public static void main(String[] args) {
		
		Cls2<Dog,String,String> cls = new Cls2<Dog,String,String>(new Dog(),"木易");
		System.out.println(cls.getData()+" "+cls.getData2());
		cls.printinfo();
		cls.printInfoCls3("测试");
	}
}

限定泛类型只能继承某个接口：


interface Move
{
	abstract void test();
}

abstract class Cls1 <T extends Move>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
	abstract void printinfo();
}

interface Cls3<T3>
{
	abstract void printInfoCls3(T3 t);
}

class Cls2 <T extends Move,T2,T3> extends Cls1<T> implements Cls3<T3>
{
	T2 b;
	public Cls2(T a,T2 b){
		super(a);
		this.b = b;
	}
	public T2 getData2(){
		return b;
	}
	void printinfo() {
		// TODO Auto-generated method stub
		System.out.println("输出");
	}
	public void printInfoCls3(Object t) {
		// TODO Auto-generated method stub
		System.out.println(t);
		a.test();
	}
}

public class Test {
	public static void main(String[] args) {
		Move a = new Move() {
			public void test() {
				// TODO Auto-generated method stub
				System.out.println("test");
			}
		};
		
		Cls2<Move,String,String> cls = new Cls2<Move,String,String>(a,"木易");
		a.test();
		cls.printInfoCls3("测试");
		
	}
}

执行结果：
结果

泛型通配声明

同一泛类型，如果实例化时给定的实际类型不同，则这些实例的类型是不兼容的，不能相互赋值。

Generic < Boolean > f1 = new Generic < Boolean >();
Generic < Integer> f2 = new Generic < Integer >();

f1 = f2  //会发生编译错误

Generic < Object> f = f1;  //f1和f类型并不兼容，发生编译错误
f = f2;                //f2和f类型同样不兼容，也会发生编译错误

泛类型实例之间的不兼容性会带来使用的不便。所以可以使用泛型通配符（?）声明泛型类的变量就可以解决这个问题。

泛型统配的方式

  • “ ? ”任意一个类型
Generic < Boolean > f1 = new Generic < Boolean >();
Generic < ? > f = f1;

class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}
public class Test {
	public static void main(String[] args) {
		Cls1<Integer> c1 = new Cls1<Integer>(20);
		Cls1<Double> c2 = new Cls1<Double>(10.3);
		Cls1<?> c3;
		c3 = c1;
		c3 = c2;
	}
}
  • 和限制泛类型的上限相似，同样可以使用extends关键字限定通配类型的上限
Generic < Dog> f1 = new Generic < Dog >();
Generic < ? extends Animal > f = f1;

class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}
public class Test {
	public static void main(String[] args) {
		Cls1<Integer> c1 = new Cls1<Integer>(20);
		Cls1<? extends Integer> c3;
		c3 = c1;
	}
}

类

class Animal
{	
}
class Dog extends Animal
{
}
class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}
public class Test {
	public static void main(String[] args) {
		Cls1<Dog> c1 = new Cls1<Dog>(new Dog());
		Cls1<? extends Animal> c3;
		c3 = c1;
	}
}
  • 可以使用super关键字将通配符匹配类型限定为某个类型
Generic < Animal > f1 = new Generic < Animal >();
Generic < ? super Dog > f = f1;

class Animal
{	
}
class Dog extends Animal
{
}
class Cls1 <T>
{
	T a;
	public Cls1(T a){
		this.a = a;
	}
	public T getData(){
		return a;
	}
}
public class Test {
	public static void main(String[] args) {
		Cls1<Dog> c1 = new Cls1<Dog>(new Dog());
		Cls1<? super Dog> c3;
		c3 = c1;
	}
}

泛型方法

不仅类可以声明泛型，类中的方法也可以声明仅用于自身的泛型，这种方法叫做泛型方法。

定义：

访问修饰符 < 泛型列表 > 返回类型 方法名 ( 参数列表 ) {
	实现代码
}

在泛型列表中声明的泛型，可用于该方法的返回类型声明、参数类型声明和方法代码中的局部变量的类型声明。

类中其它方法不能使用当前方法声明的泛型

注意：是否拥有泛方法，与其所在的类是否泛型没有关系。要定义泛方法，只需将泛型参数列表置于返回值前。

泛型方法使用场景

添加类型约束只作用于一个方法的多个参数之间、而不涉及到类中的其它方法时。

施加类型约束的方法为静态方法，只能将其定义为泛方法，因为静态方法不能使用其所在类的类型参数

基础泛应用：


class A<T>
{
	public void printInfo(T t){
		System.out.println(t);
	}
}

class B
{
	//泛型方法
	public <T> void printInfo(T t){
		System.out.println(t);
	}
	//泛型方法的重载
	public <T,T2> void printInfo(T t,T2 t2){
		System.out.println(t);
		System.out.println(t2);
	}
	//方法的重载
	public void print1(int a){
		System.out.println(a);
	}
	public void print1(char a){
		System.out.println(a);
	}
	public void print1(String a){
		System.out.println(a);
	}
}

public class Test {
	public static void main(String[] args) {
		A<String> a = new A<String>();
		a.printInfo("木易");
		
		B b = new B();
		b.printInfo("yang");
		b.printInfo(123);
		b.printInfo(5.8);
		b.printInfo('b');
		
		b.printInfo("小黄", 180);
		
		b.print1('r');
		b.print1(20);
		b.print1("天哭");

	}
}

执行结果：
结果

限制约束泛型方法：


class Animal
{
	public void eat(){
		System.out.println("动物吃");
	}
}

class Dog extends Animal
{
	public void eat(){
		System.out.println("狗啃骨头");
	}
}

class Cat extends Animal
{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

class B
{
	//泛型方法
	public <T> void printInfo(T t){
		System.out.println(t);
	}
	//泛型方法的重载
	public <T,T2> void printInfo(T t,T2 t2){
		System.out.println(t);
		System.out.println(t2);
	}
	public <T extends Animal> void printInfo2(T t){
		t.eat();
	}
}

public class Test {
	public static void main(String[] args) {
		B b = new B();
		b.printInfo("yang");
		b.printInfo(123);
		b.printInfo(5.8);
		b.printInfo('b');
		b.printInfo("小黄", 180);
		
		b.printInfo2(new Dog());
		b.printInfo2(new Cat());
		b.printInfo2(new Animal());
	}
}

执行结果：
结果

静态方法应用：

class Animal
{
	public void eat(){
		System.out.println("动物吃");
	}
}
class Dog extends Animal
{
	public void eat(){
		System.out.println("狗啃骨头");
	}
}
class Cat extends Animal
{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}
class B
{
	public static <T extends Animal> void printInfo2(T t){
		t.eat();
	}
}
public class Test {
	public static void main(String[] args) {
		B.printInfo2(new Dog());
		B.printInfo2(new Cat());
		B.printInfo2(new Animal());
	}
}

执行结果：
结果

杨映春
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java泛型总结
04-09
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
Java泛型的简单实例
09-04
Java泛型的简单实例 Java泛型是一种类型系统特性，它允许开发者在编写代码时指定类型参数，从而使代码更加灵活、可重用和类型安全。在本文中，我们将通过一个简单的示例来介绍Java泛型的使用。 泛型的概念 泛型是...
什么是泛型？
m0_49991895的博客
02-06 3万+
泛型：就是指在类定义时不会设置类中的属性或方法参数的具体类型，而是在类使用时（创建对象）再进行类型的定义。会在编译期检查类型是否错误。
java泛型详解
qq_42003527的博客
08-24 1万+
java泛型详解
Java 中的泛型详解
最新发布
XuChaofafa的博客
05-29 1086
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参列表，普通方法的形参列表中，每个形参的数据类型是确定的，而变量是一个参数。在调用普通方法时需要传入对应形参数据类型的变量（实参），若传入的实参与形参定义的数据类型不匹配，则会报错。那参数化类型是什么？以方法的定义为例，在方法定义时，将方法签名中的形参的数据类型也设置为参数（也可称之为类型参数），在调用该方法时再从外部传入一个具体的数据类型和变量。
Java泛型深入理解
void
07-21 9万+
Java泛型，包括Java泛型的实现，泛型擦除以及相关面试题，通配符理解
Java中的泛型介绍
cnds123的专栏
05-12 2826
Java中的Java 泛型（generics）是 JDK 5 中引入的, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
java 高级泛型_java之旅_高级教程_java泛型
weixin_33640562的博客
02-25 127
摘自：http://www.runoob.com/java/java-generics.htmlJAVA泛型java泛型(generics)是JDK5中引入的新特性，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是所操作的数据类型被指定为一个参数。假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组、甚至其他任何类型的数组进行...
Java泛型定义与用法实例详解
08-27
Java泛型定义与用法实例详解 Java泛型是Java语言中的一种重要机制，用于在编译期检查类型安全，避免在运行期引发ClassCastException。泛型的引入使得Java语言更加灵活和强大，本文将详细介绍Java泛型的定义、原理、...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
java 泛型
04-07
Java泛型是Java编程语言中的一个关键特性，它在2004年随着Java SE 5.0的发布而引入。泛型允许程序员在代码中使用类型参数，从而增加了代码的类型安全性和重用性。它能够帮助我们避免在运行时出现ClassCastException...
Java泛型详解 | 最新、全面、详细和深入 | 2万字超全
xwshappy的博客
05-19 3158
深度记录Java后端开发，对Java的泛型特性进行详细的整理并且分享，最新版，本文参考了Java泛型详解，JVM相关内容，以及其他博主的优秀思想和个人实战理解而成，希望对大家有帮助！！！
Java 中泛型的详解
路宇的博客
03-28 2477
泛型介绍： 泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题。 在类声明或者实例化时，只需要指定好需要的具体类型即可。 Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCaseException异常，同时代码更加简洁，健壮。 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，又或者是参数类型。 （这个具体演示代码如下） public class Generic03 { public static voi
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 60万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
Java 泛型详解(超详细的java泛型方法解析)
qq_66912832的博客
06-14 1万+
超详细的java泛型方法解析
什么是泛型
程序员思维的博客
11-12 2592
什么是泛型
泛型详解【十分钟带你了解泛型基础知识点】
weixin_62754939的博客
05-17 639
文章目录 一、泛型介绍 二、泛型的优点 三、泛型使用细节 四、自定义泛型 1.泛型类 2.泛型接口 3.泛型方法 总结 前言 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 一、泛型介绍 (1).泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型的安全性问题 (2).在类声明或实例化时，只要指定好需要的具体的类型即可 二、泛型的优点 (1).
泛型的介绍
qq_46030254的博客
05-11 301
泛型类，在实际工作中一般都是源代码中写好，我们直接用的，就是ArrayList这样的，自己定义泛型类是非常少的。自定义泛型类的格式如下//这里的其实指的就是类型变量，可以是一个，也可以是多个。public class 类名{接下来，我们自己定义一个MyArrayList泛型类，模拟一下自定义泛型类的使用。注意这里重点仅仅只是模拟泛型类的使用，所以方法中的一些逻辑是次要的，也不会写得太严谨。//定义一个泛型类，用来表示一个容器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值