Java泛型

最新推荐文章于 2023-03-20 12:00:00 发布
最新推荐文章于 2023-03-20 12:00:00 发布
阅读量171 收藏
点赞数 1
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45979569/article/details/103798682
版权

什么是泛型？

泛型就是参数化类型，它的作用就是把变量或者属性或者方法的参数或者方法的返回值等的类型看做是一个参数。这样就可以写出来通用的代码，让代码更加简洁。在使用的时候，传入真正的类型。这个过程类似于方法的形参和实参。

为什么要用泛型？

原因一：优化代码，让代码更简洁更通用。

例如：拿打印数组来说，可以定义一个工具类ArrayTool，ArrayTool提供打印数组的方法。

public class ArrayTool {
	
	public void printArray(int[] arr) {
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
	public void printArray(Integer[] arr) {
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
	public void printArray(Double[] arr) {
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
	public void printArray(Person[] arr) {
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

上述代码里，ArrayTool提供了若干个打印数组的方法（使用的技术是方法重载）。但是仔细观察，你会发现这些方法除了参数的类型不同之外，没有什么区别（核心逻辑是一模一样的）。

如果这些方法的参数类型能是一个变量，代码是不是就简洁了。Java的泛型就提供了这么一个功能，允许类型参数化。

优化方案如下：

public class ArrayTool<T> {
	public void printArray(T[] arr) {
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

在上述代码里，T用来代指某种数据类型，它就像方法的形参一样，在使用的时候传入真实的类型。

public class Test {

	public static void main(String[] args) {
		ArrayTool<Integer> tool1 = new ArrayTool<>();
		Integer[] arr = {1,3,4,5};
		tool1.printArray(arr);
		
		ArrayTool<Double> tool2 = new ArrayTool<>();
		Double[] arr2 = {1.2, 3.8, 7.7};
		tool2.printArray(arr2);

		Person[] arr3 = {
			new Person("zhangsan", 22),
			new Person("李四", 25)
		};
		ArrayTool<Person> tool3 = new ArrayTool<>();
		tool3.printArray(arr3);
		
	}

}
原因二：编写代码期间预报错误，防止运行期间出错，减少运行期间的类型转换。

不使用泛型的时候，List中可以存放任意对象类型。会出现以下问题：

  1. 报了一堆警告
  2. 有可能取元素的时候，记错类型，进而产生转换类型的异常。
  3. 取元素需要类型转换（因为默认Object类型）。
List list = new ArrayList();
list.add(10);
list.add("hello");
list.add("world");
list.add(new Random());
System.out.println(list);

for(int i = 0; i < list.size(); i++) {
	if(i == 1) {//假如记错了，记成了下标为1的是整数。
		Integer num = (Integer)list.get(i);
		num *= 5;
	}
}

使用泛型以后，在创建List的时候就指定了元素的类型。因此可以避免你误存其他类型（存放其他类型，会报编译错误）。另外因为已经指定了元素的类型，所以在取的元素的时候，无需类型转换。

List<String> list2 = new ArrayList<>();
list2.add("string");
list2.add("aaa");
list2.add("bbb");
for(int i = 0; i < list2.size(); i++) {
	String str = list2.get(i);
	System.out.println(str);
}

泛型如何使用？

在Java中，泛型有3种用法：泛型类，泛型方法，泛型接口。

泛型类

所谓的泛型类，就是对类进行泛型的设定。对类设定泛型，这个泛型将作用于类的属性，类的方法，类的方法的返回值，类中的局部变量。

泛型类的语法格式：

在类名的后面加上<类型占位符>

public class Generic<T> {
	private String name;
	private T aa;	//属性可以是泛型类型
	
	public void method(String str) {
		System.out.println(str);
	}
	
	public void method2(T t) {
		System.out.println(t);
	}
	
	public T method3() {
		return aa;
	}

	public Generic(String name, T aa) {
		super();
		this.name = name;
		this.aa = aa;
	}
	
	public void method4() {
		T a = aa;
		System.out.println(a);
	}
	
}

泛型类的使用，是在用的时候指定类型。

public class Test {

	public static void main(String[] args) {
		Generic<Integer> g1 = new Generic<>("张三", 100);
		g1.method2(200);
		System.out.println(g1.method3());
		g1.method4();
		
		
		Generic<String> g2 = new Generic<String>("lisi", "hello");
		g2.method2("world");
		System.out.println(g2.method3());
		g2.method4();
	}

}
泛型类的注意事项

  1. 指定的类型不能是基本数据类型。（int short long byte float double boolean char）,必须是类类型。如果真的想放基本数据类型，使用基本数据类型的包装类(Integer Short Long Byte Float Double Boolean Character)。

    平时我们往集合框架里存放100，3.5等。实际上内部做了隐式的包装。

    例如：list.add(100) 实际上100是Integer类型。系统自动把int转换为了Integer。

  2. 静态方法不能使用泛型。使用的时候会报语法错误。

    如果真想让静态方法使用泛型，使用泛型方法而泛型类。

  3. 如果泛型没有指定具体类型，默认是Object类型。

泛型方法

使用场景有2个：

  1. 当你不想定义泛型类，但是又想让某个方法能够接受泛型的参数。
  2. 静态方法想要使用泛型的特征。
泛型方法的语法格式

在方法的返回值前面加上<类型占位符>

public class Generic {
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public <T> void method1(T t) {
		System.out.println(t);
	}
	
	public <T> T method2(T t) {
		return t;
	}
}

在使用的时候，可以指定具体类型，具体做法：对象.<真实类型>方法名(参数)

如果不指定真实类型，系统会根据你传递的参数去推断类型。

public class Test {

	public static void main(String[] args) {
		Generic g = new Generic();
		g.<Integer>method1(100);
		String num = g.<String>method2("hello");
		System.out.println(num);
		
		g.method1(new Random());
		Integer num2 = g.method2(100);
		System.out.println(num2);
	}

}

泛型方法可以作用于静态方法：

public class Generic {
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public <T> void method1(T t) {
		System.out.println(t);
	}
	
	public <T> T method2(T t) {
		return t;
	}
	
	public static <T> void method3(T t) {
		System.out.println(t);
	}
}

静态泛型方法的使用：

public class Test {

	public static void main(String[] args) {	
		Generic.method3("快七夕了");
		Generic.method3(100);
		Generic.<Double>method3(200.0);
	}

}

注意事项：

  1. 泛型类中的方法（使用了泛型参数或者泛型返回值的方法） 不叫泛型方法！它只是使用了泛型的方法，但不是泛型方法。
  2. 满足泛型方法定义的方法，才叫泛型方法。
  3. 泛型类中的类型占位符 和 泛型方法中的类型占位符 是相互独立的。哪怕命名一样，其实也是2个占位符。
一个类可以有几个类型占位符？即泛型类可以有几个类型占位符

泛型类可以根据自己的需要添加若干个占位符。

一个方法可以有几个类型占位符？即泛型方法可以有几个类型占位符

泛型方法可以根据自己的需要添加若干个占位符。

泛型接口

与泛型类类似，在接口名后面添加<类型占位符>，这样的接口叫泛型接口。

一旦一个接口定义为泛型，它内部声明的方法可以使用泛型作为参数类型或者返回值类型。

public interface GenericInterface<T> {
	public abstract void method1(T t);
	public abstract T method2();
}

接口定义为泛型之后，实现类可以明确泛型类型，也可以不明确泛型类型。

实现类 明确 泛型接口的类型

接口中并没有给出类型的具体值，实现类在实现接口的时候，可以指定类型是什么类型。

public class GenericInterfaceImpl implements GenericInterface<String>{
	@Override
	public void method1(String t) {
		System.out.println(t.length());
	}

	@Override
	public String method2() {
		return "你好，周杰棍";
	}
}

public class GenericInterfaceImpl2 implements GenericInterface<Double> {

	@Override
	public void method1(Double t) {
		System.out.println(t);
		
	}

	@Override
	public Double method2() {
		return 3.14;
	}

}

public interface MyComparable<T> {
	public int compareTo(T t);
}

public class Person implements MyComparable<Person>{
	private String name;
	private String sex;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Person t) {
		
		return age - t.getAge();
	}
	
}

public class Rectangle implements MyComparable<Rectangle> {
	private double width;
	private double height;
	public double getWidth() {
		return width;
	}
	public void setWidth(double width) {
		this.width = width;
	}
	public double getHeight() {
		return height;
	}
	public void setHeight(double height) {
		this.height = height;
	}
	public Rectangle(double width, double height) {
		super();
		this.width = width;
		this.height = height;
	}
	public Rectangle() {
		super();
	}
	@Override
	public String toString() {
		return "Rectangle [width=" + width + ", height=" + height + "]";
	}
	@Override
	public int compareTo(Rectangle t) {
		return (int)(width * height - t.getWidth() * t.getHeight());
	}
	
}
实现类 不明确 泛型接口中的类型

如果实现类在实现接口的时候，不明确接口中的类型，那这个实现类也必须声明为泛型类。

public class GenericInterfaceImpl3<T> implements GenericInterface<T> {

	@Override
	public  void method1(T t) {
		System.out.println(t);
		
	}

	@Override
	public T method2() {
		return null;
	}

}

泛型的通配符

类和类之间存在继承关系，可以把子类当成父类看待。

但是泛型类中的泛型实际类型是没有继承关系的。

public class A<T> {
	private T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public A(T t) {
		super();
		this.t = t;
	}

	public A() {
		super();
	}

	@Override
	public String toString() {
		return "A [t=" + t + "]";
	}
	
}

public class Test {

	public static void main(String[] args) {
		A<Integer> a1 = new A<>(100);
		System.out.println(a1);
		A<String> a2 = new A<>("zhangsan");
		System.out.println(a2);
		Object o = new Object();
		A<Object> a3 = new A<>(o);
		System.out.println(a3);
		
//		show(a1);//会报错
		show(a2);
//		show(a3);//会报错

	}
	
	public static void show(A<String> a) {
		System.out.println(a);
	}

}

如果想让泛型的作用域更广，更通用，可以使用通配符“？”，用来指定任意类型。

public class Test {

	public static void main(String[] args) {
		A<Integer> a1 = new A<>(100);
		System.out.println(a1);
		A<String> a2 = new A<>("zhangsan");
		System.out.println(a2);
		Object o = new Object();
		A<Object> a3 = new A<>(o);
		System.out.println(a3);
		
//		show(a1);
		show(a2);
//		show(a3);
		System.out.println("====");
		show2(a1);
		show2(a2);
		show2(a3);
		
	}
	
	public static void show(A<String> a) {
		System.out.println(a);
	}
	
	public static void show2(A<?> a) {
		System.out.println(a);
	}
}

指定泛型的上界。 <？ extends 某类型> 表示某类型，或者某类型的子类。

public class Test {

	public static void main(String[] args) {
		A<Integer> a1 = new A<>(100);
		System.out.println(a1);
		A<String> a2 = new A<>("zhangsan");
		System.out.println(a2);
		Object o = new Object();
		A<Object> a3 = new A<>(o);
		System.out.println(a3);
		
//		show(a1);
		show(a2);
//		show(a3);
		System.out.println("====");
		show2(a1);
		show2(a2);
		show2(a3);
		System.out.println("=====");
		//show3(a1);
		show3(a2);
		//show3(a3);
		
	}
	
	public static void show(A<String> a) {
		System.out.println(a);
	}
	
	public static void show2(A<?> a) {
		System.out.println(a);
	}
	
	public static void show3(A<? extends String> a) {
		System.out.println(a);
	}
}

指定泛型的下届。 <? super 某类型> 代表某类型或者某类型的父类型。

public class Test {

	public static void main(String[] args) {
		A<Integer> a1 = new A<>(100);
		System.out.println(a1);
		A<String> a2 = new A<>("zhangsan");
		System.out.println(a2);
		Object o = new Object();
		A<Object> a3 = new A<>(o);
		System.out.println(a3);
		
//		show(a1);
		show(a2);
//		show(a3);
		System.out.println("====");
		show2(a1);
		show2(a2);
		show2(a3);
		System.out.println("=====");
		//show3(a1);
		show3(a2);
		//show3(a3);
		System.out.println("======");
//		show4(a1);
		show4(a2);
		show4(a3);
		
	}
	
	public static void show(A<String> a) {
		System.out.println(a);
	}
	
	public static void show2(A<?> a) {
		System.out.println(a);
	}
	
	public static void show3(A<? extends String> a) {
		System.out.println(a);
	}
	
	public static void show4(A<? super String> a) {
		System.out.println(a);
	}
}

总结：

泛型的本质是参数化类型，把类或者接口或者方法中的类型看做一个参数。在用的时候指定真正的类型。

泛型类：在类名后加<类型占位符>

​ 在创建对象的时候，指定泛型的真正类型。 类名<真实类型> 变量名 = new 类名<>();

泛型方法：在返回值前面加<类型占位符>

​ 在方法调用的时候，指定泛型的真实类型.

​ 非静态方法： 对象.<真实类型>方法名(实参列表)

​ 静态方法： 类名.<真实类型>方法名(实参列表)

<真实类型>可以省略不写，编译器会根据实参自行推断类型。

泛型接口：在接口名后面加<类型占位符>

​ 在实现类里面使用，public class 类名 implements 接口名<真实类型>

​ 或者 public class 类名<类型占位符> implements 接口名<类型占位符>

当泛型类的对象作为参数的时候，可以根据需要指定上界 (<? extends 某类型>)，下界（<? super 某类型>），通配（< ? >）或者精确类型(< Integer >)。

List<? extends 某类型> 指定类型上界 表示我们传入的类型必须是T类型本身或其子类!

List<? super 某类型> 指定类型下界 表示我们传入的类型必须是T类型本身或其父类!

这是理解和定义, 在实际编程时我们的传入往往与理解相反!

小李小李 我喜欢你
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用泛型方法打印不同字符串的元素（泛型例子学习）
ProveYourself的博客
12-19 1227
使用泛型方法打印不同字符串的元素 package com.example.test; public class Test { // 泛型方法 printArray public E > void printArray( E[] inputArray ) { // 输出数组元素 for ( E element : inputArray
java泛型总结
04-09
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
泛型方法注意事项
qq_45485431的博客
12-28 168
方法上面一旦声明泛型 方法体中就可以使用该泛型 2、静态方法 的泛型声明位置必须在static和返回值类型之间 3、普通方法没有声明泛型，可 以使用类的泛型 4、静态方法没有声明泛型，不可以使用类的泛型，方法中就不 可以 ...
java泛型注意事项_java泛型总结
weixin_42629671的博客
02-27 144
1 说明1)Generics是对java语言类型系统的一种扩展，以支持创建可以按类型进行参数化的类或者方法。2)泛型的优点：1.类型安全(使用泛型时，编译器可以捕获附加类型信息，从而类型错误在编译时被捕获而不是运行时来进行检测)2. 消除强制类型转换，减少了代码出错的可能性，并且使代码更加可读2 泛型类实例不使用泛型，此种情况需要类型转换packagecom.wish.generic;publi...
JAVA基础_自定义泛型
weixin_30300523的博客
09-10 145
泛型的来源在Java中，泛型借鉴了C++的模版函数，从而引入了泛型。C++泛型int add(int x,int y){ return x + y; } float add(float x.float y){ return x + y; } double add(double x,double y){ return x + y; } // 泛型函数对上面的...
java 泛型方法 泛型类
水墨江南
08-02 627
泛型方法: /** * 1..泛型方法 打印各种类型的数组 * */ public static void printArray(E[] inputArray) { // 输出数组元素 for (E element : inputArray) { System.out.printf("%s ", element);// %s 是字符串型的数据 } Sys
Java泛型的简单实例
09-04
Java泛型的简单实例 Java泛型是一种类型系统特性，它允许开发者在编写代码时指定类型参数，从而使代码更加灵活、可重用和类型安全。在本文中，我们将通过一个简单的示例来介绍Java泛型的使用。 泛型的概念 泛型是...
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泛型的用法及T.class的获取过程解析
08-25
Java泛型的用法及T.class的获取过程解析 Java泛型是Java编程语言中的一种重要特性，它允许开发者在编写代码时指定类型参数，从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析...
Java泛型变量如何添加约束
08-19
Java泛型变量如何添加约束 Java泛型变量是一种强大的工具，它允许开发者编写更加灵活和可重用的代码。然而，在使用泛型变量时，需要注意类型安全问题，以免出现运行时错误。为此，Java提供了类型约束机制，允许...
Java 泛型全解析
09-07
Java 泛型是Java编程语言中的一项重要特性，首次引入于JDK 1.5版本。泛型的主要目的是提高代码的类型安全性和效率，同时提供更强的编译时检查。它允许开发者在类、接口和方法中定义参数化的类型，从而实现更灵活且...
java泛型详解
08-31
Java 泛型详解 Java 泛型是 Java 语言中的一种重要机制，它可以帮助开发者编写更加安全、灵活和可重用的代码。在本文中，我们将详细介绍 Java 泛型的相关知识，包括泛型的概念、类型擦除、泛型的应用场景等内容。 ...
Java泛型继承原理与用法详解
08-25
Java泛型是自Java 5版本引入的一种强大的类型系统特性，它允许我们在编程时指定容器（如列表、集合等）所存储的数据类型。这增强了代码的类型安全性，减少了强制类型转换，并提供了更好的编译时错误检测。在Java中，...
Java 泛型
最新发布
笔记
03-20 265
Java泛型是Java语言中一个非常重要的特性。它可以让我们编写更加安全、可读性更好和更易于维护的代码。在实际工作中，我们可以使用Java泛型来实现通用的代码，而不用考虑数据类型的具体实现。希望这篇文章可以帮助你更好地理解Java泛型的作用和用途。
java c 泛型_Java基础加强总结(二)——泛型
weixin_39620279的博客
02-20 103
一、体验泛型JDK1.5之前的集合类中存在的问题——可以往集合中加入任意类型的对象，例如下面代码：1 packagecn.gacl.generic.summary;23 importjava.util.ArrayList;45 public classGenericTest {67 public static voidmain(String[] args) {8 /**9 ...
Java学习路线：day25泛型
杨丙寅
05-14 824
文章目录第12章 泛型为什么要有泛型在集合中使用泛型举例练习自定义泛型结构自定义泛型类举例自定义泛型类泛型接口的注意点自定义泛型方法举例举例泛型类和泛型方法的使用情境泛型在继承上的体现通配符的使用使用通配符后数据的读取和写入要求有限制条件的通配符的使用泛型应用举例泛型嵌套实际案例自定义泛型类练习 第12章 泛型 为什么要有泛型 泛型：标签 举例： 中药店，每个抽屉外面贴着标签 超市购物架上很多瓶子，每个瓶子装的是什么，有标签。 泛型的设计背景 集合容器类在设计阶段/声明阶段不能
Java学习(十五)：Java泛型
qq_36212439的博客
09-13 191
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？ 答案是可以使用 Java 泛型。 使用 Java 泛型的概念，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值