泛型及其使用

于 2024-09-11 22:16:17 发布
阅读量354 收藏 13
点赞数 6
分类专栏： JAVA 文章标签： java 开发语言 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41386300/article/details/142111721
版权

1. 为什么要用泛型

我们来看下面这个场景：
有一个Dog类和Cat类，创建一个ArrayList用来存放dog对象，程序员不小心往里边添加了一个Cat对象，此时不会有问题，但是当我们遍历这个ArrayList时，强行转为Dog类就会发生ClassCastException异常，使用传统方法代码如下：

@SuppressWarnings({"all"})
public class Generic01 {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add(new Dog("旺财", 10));
		arrayList.add(new Dog("发财", 1));
		arrayList.add(new Dog("小黄", 5));
		//假如我们的程序员，不小心，添加了一只猫
		arrayList.add(new Cat("招财猫", 8)); // 这里没问题，ArrayList可以存放Object类型
		//遍历
		for (Object o : arrayList) {
			//向下转型 Object ->Dog
			Dog dog = (Dog) o; // 遍历到cat对象时会抛出异常
			System.out.println(dog.getName() + "-" + dog.getAge());
		}
	}
}
// Dog和Cat类代码省略

使用传统方法会有什么问题？

  1. 不能对加入到集合中的数据类型进行约束（不安全)
  2. 遍历时需要类型转换，若数据量较大则影响效率

2. 泛型快速入门

所以我们引出了泛型，使用泛型来解决，代码如下：

@SuppressWarnings({"all"})
public class Generic02 {
	public static void main(String[] args) {
		//使用泛型
		//老韩解读
		//1. ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是 Dog 类型
		//2. 如果编译器发现添加的类型，不满足要求，就会报错
		//3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object
		//4. public class ArrayList<E> {} E 称为泛型,那么 Dog->E
		ArrayList<Dog> arrayList = new ArrayList<Dog>();
		arrayList.add(new Dog("旺财", 10));
		arrayList.add(new Dog("发财", 1));
		arrayList.add(new Dog("小黄", 5));
		//假如我们的程序员，不小心，添加了一只猫
		//arrayList.add(new Cat("招财猫", 8)); // 添加不了
		System.out.println("===使用泛型====");
		// 直接取出 Dog 类型，不用转换
		for (Dog dog : arrayList) {
			System.out.println(dog.getName() + "-" + dog.getAge());
		}
	}
}
// Dog和Cat类代码省略
2.1 泛型的好处
  1. 编译时检查添加的类型，提高了安全性
  2. 减少了类型转换的次数，提高效率

3. 泛型介绍

泛型（广泛类型），可以是String， Integer，Dog，Cat…
泛型又称参数化类型，解决数据类型安全性问题
在类声明或实例化时只要指定好具体的类型即可
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生类型转换异常
可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者某个参数的类型…
举例：

public class Generic03 {
	public static void main(String[] args) {
		//注意，特别强调： E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
		Person<String> person = new Person<String>("张三");
		person.show(); // 结果是String
		/*
		你可以这样理解，上面的 Person 类就等于是下面这样
		class Person {
			String s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E是什么类型
			public Person(String s) {//E 也可以是参数类型
				this.s = s;
			}
			public String f() {//返回类型使用 E
				return s;
			}
		}
		*/
		Person<Integer> person2 = new Person<Integer>(100);
		person2.show();// 结果是Integer

	}
}

class Person<E> {
	E s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
	public Person(E s) {//E 也可以是参数类型
		this.s = s;
	}
	public E f() {//返回类型使用 E
		return s;
	}
	public void show() {
		System.out.println(s.getClass());//显示 s 的运行类型
	}
}

4. 泛型语法

4.1 泛型声明
interface 接口{}
class 类<K,V> {}
4.2 泛型实例化
要在类名后面指定类型参数值

List<String> list = new ArrayList<String>{};

使用举例

  • 创建 3 个学生对象
  • 放入到 HashSet 中学生对象, 使用.
  • 放入到 HashMap 中，要求 Key 是 String name, Value 就是 学生对象
  • 使用两种方式遍历
import java.util.*;
@SuppressWarnings({"all"})
public class GenericExercise {
	public static void main(String[] args) {
		//使用泛型方式给 HashSet 放入 3 个学生对象
		HashSet<Student> students = new HashSet<Student>();
		students.add(new Student("jack", 18));
		students.add(new Student("tom", 28));
		students.add(new Student("mary", 19));
		//遍历
		for (Student student : students) {
		System.out.println(student);
		}
		//使用泛型方式给 HashMap 放入 3 个学生对象
		//K -> String V->Student
		HashMap<String, Student> hm = new HashMap<String, Student>();
		/*
		public class HashMap<K,V> {}
		*/
		hm.put("milan", new Student("milan", 38));
		hm.put("smith", new Student("smith", 48));
		hm.put("hsp", new Student("hsp", 28));
		//迭代器 EntrySet
		/*
		public Set<Map.Entry<K,V>> entrySet() {
			Set<Map.Entry<K,V>> es;
			return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
		}
		*/
		Set<Map.Entry<String, Student>> entries = hm.entrySet();
		/*
		public final Iterator<Map.Entry<K,V>> iterator() {
			return new EntryIterator();
		}
		*/
		Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
		System.out.println("==============================");
		while (iterator.hasNext()) {
			Map.Entry<String, Student> next = iterator.next();
			System.out.println(next.getKey() + "-" + next.getValue());
		}
	}
}
class Student {
	private String name;
	private int age;
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
	return "Student{" +
	"name='" + name + '\'' +
	", age=" + age +
	'}';
	}
}

5. 泛型使用的注意事项和细节

  1. interface List {} public class HashSet {}
    T,E只能是引用类型，不能是普通类型
List<Integer> list = new ArrayList<Integer>(); //OK
//List<int> list2 = new ArrayList<int>();//错误
  1. 在给泛型指定具体类型后，可以传入该类型或者其子类类型
Pig<A> aPig = new Pig<A>(new A());
aPig.f();
Pig<A> aPig2 = new Pig<A>(new B());
aPig2.f();
  1. 在实际开发中，我们往往简写，编译器会进行类型推断
ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();
  1. 如果是这样写 泛型默认是 Object
ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();

6. 自定义泛型

基本语法

  • class 类名<T,R…> {}

细节：

  • 普通成员可以使用泛型 (属性、方法)
  • 使用泛型的数组，不能初始化
  • 静态方法中不能使用类的泛型
  • 泛型类的类型，是在创建对象时确定的，如果没有指定，则默认为Object类型
public class CustomGeneric_ {
	public static void main(String[] args) {
		//T=Double, R=String, M=Integer
		Tiger<Double,String,Integer> g = new Tiger<>("john");
		g.setT(10.9); //OK
		//g.setT("yy"); //错误，类型不对
		System.out.println(g);
		Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
		g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是 Object 子类
		System.out.println("g2=" + g2);
	}
}
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个. 
class Tiger<T, R, M> {
	String name;
	R r; //属性使用到泛型
	M m;
	T t;
	//使用泛型的数组，不能初始化
	//因为数组在 new 不能确定 T 的类型，就无法在内存开空间
	T[] ts;
	public Tiger(String name) {
		this.name = name;
	}
	public Tiger(R r, M m, T t) {//构造器使用泛型
		this.r = r;
		this.m = m;
		this.t = t;
	}
	public Tiger(String name, R r, M m, T t) {//构造器使用泛型
		this.name = name;
		this.r = r;
		this.m = m;
		this.t = t;
	}
	// 静态方法中不能使用类的泛型
	// 因为静态是和类相关的，在类加载时，对象还没有创建
	// 所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
	// static R r2;
	// public static void m1(M m) {
	//
	// }
	//方法使用泛型
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public R getR() {
		return r;
	}
	public void setR(R r) {//方法使用到泛型
		this.r = r;
	}
	public M getM() {//返回类型可以使用泛型. return m;
	}
	public void setM(M m) {
		this.m = m;
	}
	public T getT() {
		return t;
	}
	public void setT(T t) {
		this.t = t;
	}
	@Override
	public String toString() {
		return "Tiger{" +
		"name='" + name + '\'' +
		", r=" + r +
		", m=" + m +
		", t=" + t +
		", ts=" + Arrays.toString(ts) +
		'}';
	}
}

7. 自定义泛型接口

    1. 接口中，静态成员也不能使用泛型
    1. 泛型接口的类型, 在继承接口或者实现接口时确定
    1. 没有指定类型，默认为 Object
//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}
//当我们去实现 IA 接口时，因为 IA 在继承 IUsu 接口时，指定了 U 为 String R 为 Double
//，在实现 IUsu 接口的方法时，使用 String 替换 U, 是 Double 替换 R
class AA implements IA {
	@Override
	public Double get(String s) {
		return null;
	}
	@Override
	public void hi(Double aDouble) {
	}
	@Override
	public void run(Double r1, Double r2, String u1, String u2) {
	}
}
interface IUsb<U, R> {
	int n = 10;
	//U name; 不能这样使用，静态成员也不能使用泛型
	//普通方法中，可以使用接口泛型
	R get(U u);
	void hi(R r);
	void run(R r1, R r2, U u1, U u2);
	//在 jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
	default R method(U u) {
		return null;
	}
}

8. 自定义泛型方法

基本语法

  • 修饰符<T,R…> 返回类型 方法名 (参数列表) { }

细节

  • 泛型方法，可以定义在普通类中, 也可以定义在泛型类中
  • 当调用泛型方法时，传入参数，编译器，就会确定类型
  • public void hi(T t) {}修饰符后没有<>不是泛型方法，而是使用了泛型
@SuppressWarnings({"all"})
public class CustomMethodGeneric {
	public static void main(String[] args) {
		Car car = new Car();
		car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
		System.out.println("=======");
		car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型
		//测试
		//T->String, R-> ArrayList
		Fish<String, ArrayList> fish = new Fish<>();
		fish.hello(new ArrayList(), 11.3f);
	}
}
//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类
	public void run() {//普通方法
	}
	//说明 泛型方法
	//1. <T,R> 就是泛型
	//2. 是提供给 fly 使用的
	public <T, R> void fly(T t, R r) {//泛型方法
		System.out.println(t.getClass());
		System.out.println(r.getClass());
	}
}
class Fish<T, R> {//泛型类
	public void run() {//普通方法
	}
	public<U,M> void eat(U u, M m) {//泛型方法
	}
	//说明
	//1. 下面 hi 方法不是泛型方法
	//2. 是 hi 方法使用了类声明的 泛型
	public void hi(T t) {
	}
	//泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
	public<K> void hello(R r, K k) {
		System.out.println(r.getClass());//ArrayList
		System.out.println(k.getClass());//Float
	}
}

9. 泛型的继承和通配符

  • 泛型没有继承性
  • List<?> c ，可以接受任意的泛型类型
  • ? extends AA 表示 上限，可以接受 AA 或者 AA 子类
public class GenericExtends {
	public static void main(String[] args) {
	Object o = new String("xx");
	//泛型没有继承性
	//List<Object> list = new ArrayList<String>(); //报错
	
	//举例说明下面三个方法的使用
	List<Object> list1 = new ArrayList<>();
	List<String> list2 = new ArrayList<>();
	List<AA> list3 = new ArrayList<>();
	List<BB> list4 = new ArrayList<>();
	List<CC> list5 = new ArrayList<>();
	//如果是 List<?> c ，可以接受任意的泛型类型
	printCollection1(list1);
	printCollection1(list2);
	printCollection1(list3);
	printCollection1(list4);
	printCollection1(list5);
	//List<? extends AA> c： 表示 上限，可以接受 AA 或者 AA 子类
	// printCollection2(list1);//×
	// printCollection2(list2);//×
	printCollection2(list3);//√
	printCollection2(list4);//√
	printCollection2(list5);//√
	//List<? super AA> c: 支持 AA 类以及 AA 类的父类，不限于直接父类
	printCollection3(list1);//√
	//printCollection3(list2);//×
	printCollection3(list3);//√
	//printCollection3(list4);//×
	//printCollection3(list5);//×
	}
	//说明: List<?> 表示 任意的泛型类型都可以接受
	public static void printCollection1(List<?> c) {
		for (Object object : c) { // 通配符，取出时，就是 Object
			System.out.println(object);
		}
	}
	// ? extends AA 表示 上限，可以接受 AA 或者 AA 子类
	public static void printCollection2(List<? extends AA> c) {
		for (Object object : c) {
			System.out.println(object);
		}
	}
	
	// ? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
	//规定了泛型的下限
	public static void printCollection3(List<? super AA> c) {
		for (Object object : c) {
			System.out.println(object);
		}
	}
}
class AA {
}
class BB extends AA {
}
class CC extends BB {
}
qq_41386300
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java11-泛型及其使用
weixin_33705053的博客
05-12 152
1.概述 　　　　就本质而言 “泛型”的意思就是参数化类型。参数化类型很重要，因为使用该特性创建的类、接口以及方法可以以参数的形式指定操作的数据类型。 　　　　泛型通俗的说就是方法的返回值或参数是不确定的，可以随创建该类对象时改变而改变。 　　　　泛型提供了以前缺失的类安全性，并且还可以简化处理过程（例如避免进行强制类型转换等），提高了代码的可重用性。 2.一段简单的代码理解泛型 　　　...
java11_java11-泛型及其使用
weixin_30533109的博客
02-21 355
1.概述就本质而言 “泛型”的意思就是参数化类型。参数化类型很重要，因为使用该特性创建的类、接口以及方法可以以参数的形式指定操作的数据类型。泛型通俗的说就是方法的返回值或参数是不确定的，可以随创建该类对象时改变而改变。泛型提供了以前缺失的类安全性，并且还可以简化处理过程(例如避免进行强制类型转换等)，提高了代码的可重用性。2.一段简单的代码理解泛型对于下面这段代码我们定义了一个泛型类，类中有一个私...
Java泛型及其使用
qingfoo的专栏
05-14 541
转自（http://www.cxybl.com/html/bcyy/java/201111037710.html） 1.为什么要用泛型    JDK 1.5之前，对象保存到集合中就会失去其特性，取出时要手动进行人工强制类型转化，集合元素中的数据类型可以不统一， 例：List集合    list=new ArrayList();    list.add("aa");    list.add
泛型及其使用、Stream的方法（Java小白进阶day17）
hyj_123的博客
08-06 941
泛型 java泛型设计原则：保证编译时不出错，运行时就不会出现ClassCastException 1、泛型类 在类上定义的泛型，在方法中也可使用 2、泛型接口 interface DemoInter<T>{ void show(T t); } class Demo3Impl1 implements DemoInter<String>{ @Override public void show(String t) { // TODO Auto-generated method
泛型集合及其使用
weixin_56073526的博客
06-06 342
概念:参数化类型、类型安全的集合，强制集合元素的类型必须一致。 二、Set集合 特点：无序、无下标、元素不可重复 方法：全部继承自CollectionSet实现类 HashSet：代码如下（示例）：
详解Java泛型及其应用
08-26
Java泛型详解 Java泛型是Java语言中的一种参数化类型机制，...2. 泛型的使用需要遵守命名约定和使用约定 Java泛型是一种非常有用的功能，能够帮助程序员编写更加灵活、可维护的代码，提高代码的可读性和可维护性。
Java基础：泛型及其擦除性、不可协变性
01-21
　基本指导原则：如果使用泛型方法可以取代将整个类泛型化，那么应该使用泛型方法，因为它可以让事情更加清楚。 　2.为什么使用泛型？ 　在Java SE1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现...
详细分析Java 泛型的使用
08-18
这使得可以使用`SomeClass`及其子类作为类型参数`T`。 7. **创建泛型方法** 除了泛型类和泛型接口，还可以在方法声明中使用泛型，使方法具有通用性。例如，可以定义一个泛型方法`swap(T a, T b)`，用于交换两个...
浅析Java泛型的使用.pdf
01-01
【Java泛型】Java泛型是自Java SE 1.5版本引入的一种...理解并熟练使用泛型、类型擦除和通配符，可以显著提高Java代码的质量和可维护性。在实际编程中，应谨慎处理泛型的边界条件，充分利用通配符以增强代码的适应性。
spring事务详细讲解-深入浅出
小电玩
09-08 446
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1438
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 465
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 519
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 702
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
MyBatis面试
Tony_yitao的博客
09-09 645
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 542
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 313
步骤很详细，直接上教程……
SpringBoot总结
2302_77073236的博客
09-06 278
都做成图了，方便理解和掌握全局关系。
基于SpringBoot的多媒体信息共享平台开发
qq_45800365的博客
09-06 257
基于SpringBoot的多媒体信息共享平台开发,java项目。eclipse和idea都能打开运行。推荐环境配置：eclipse/idea jdk1.8 maven mysql前端技术：vue，Ajax，Json后端技术：SpringBoot，MyBatis本系统共分为两个角色：管理员和用户。主要功能有:后台：系统首页个人中心用户管理作品分类管理作品信息管理私聊信息管理系统管理前台：首页作品信息公告信息后台管理个人中心。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值