学习笔记之JavaSE（38）--泛型

最新推荐文章于 2022-07-23 22:53:01 发布
最新推荐文章于 2022-07-23 22:53:01 发布
阅读量549 收藏
点赞数
分类专栏： 学习笔记 文章标签： java se
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huayuekonghoui/article/details/53342322
版权

今天学习的内容是泛型


一、泛型的意义

泛型意味着“类型安全”，它实现了参数化类型的概念。实际上泛型就是将运行时可能发生的问题放到编译期解决。比如：在泛型出现之前，任意类型的引用都可以存储进集合，并被向上转型为Object类型，取出的引用仍旧是Object类型，如果想要操作它就必须对其进行强制类型转换，这就存在了安全隐患！这是由于集合中可能存在不同类型的引用，强制转换就可能会发生ClassCastException。但如果使用泛型，编译器就知道集合中存储的一定是泛型类型或其子类/实现类的引用（多态与泛型并不冲突），并被向上转型为泛型类型，取出的一定是该泛型类型的引用，这时候就不用再对其进行强制类型转换，解决了类型安全问题。其实这么做就相当于将类型参数化：此集合只存储此类型或其子类/实现类的引用，不接收其他类型的引用。程序示例：

public class Test70 {

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {

		// 不使用泛型，会有安全隐患
		ArrayList list_1 = new ArrayList();
		list_1.add("a");// String类型的对象
		list_1.add(1);// Integer类型的对象
		Iterator it_1 = list_1.iterator();
		while (it_1.hasNext()) {
			try {
				String str = (String) it_1.next();// ClassCastException
				System.out.println(str);
			} catch (ClassCastException e) {
				e.printStackTrace();
			}
		}

		// 如果使用泛型，可以避免安全隐患
		ArrayList<String> list_2 = new ArrayList<>();
		list_2.add("a");
		// !list_2.add(1);
		Iterator<String> it_2 = list_2.iterator();
		while(it_2.hasNext()){
			String str = it_2.next();
			System.out.println(str);
		}
	}
}

注意：编译器生成的字节码文件中是不带有泛型的，这个称为泛型的擦除，这么做的目的主要是为了兼容JDK1.4的类加载器。相应的，JVM在运行时可以通过获取元素的类型，自动进行类型转换动作，这成为泛型的补偿。


二、自定义泛型

泛型使用最多的就是在集合类中，不过我们也可以自定义泛型。比如当类中要操作的引用类型不确定时，可以自定义泛型类；当方法中要操作的引用的类型不确定时，可以自定义泛型方法；除此之外，也可以自定义泛型接口。示例程序：

public class Test72 {

	public static void main(String[] args) {

		// 使用自定义泛型类
		Tool<String> tool_str = new Tool<>();
		Tool<Integer> tool_int = new Tool<>();
		tool_str.setTool("a");
		tool_int.setTool(1);
		tool_str.print("b");// b
		// ! tool_str.print(2); 如果方法使用的是类定义的泛型，必须按照类定义的泛型传参
		tool_int.print(2);// 2
		// ! tool_int.print("b"); 如果方法使用的是类定义的泛型，必须按照类定义的泛型传参
		System.out.println(tool_str.getTool());// a
		System.out.println(tool_int.getTool());// 1

		// 使用自定义泛型方法，可以传入任何参数
		tool_str.myPrint("a");// a
		tool_str.myPrint(1);// 1
		tool_int.myPrint("a");// a
		tool_int.myPrint(1);// 1
		Tool.myShow("a");// a
		Tool.myShow(1);// 1
	}
}

// 自定义泛型类，使用场景：当类中要操作的引用的类型不确定时
class Tool<T> {

	private T tool;

	public T getTool() {
		return tool;
	}

	public void setTool(T tool) {
		this.tool = tool;
	}

	public void print(T tool) {
		System.out.println(tool);
	}

	// 自定义泛型方法，使用场景：当方法中要操作的引用的类型不确定时
	public <E> void myPrint(E e) {
		System.out.println(e);
	}

	// 注意静态方法只能自定义泛型，不能使用类定义的泛型
	public static <E> void myShow(E a) {
		System.out.println(a);
	}
}

//自定义泛型接口
interface Inter<T>{
	void show(T t);
	<E> void myShow(E e);
}

class InterImpl_1 implements Inter<String>{

	@Override
	public void show(String t) {
	}

	@Override
	public <E> void myShow(E e) {
	}
}

class Interimpl_2<T> implements Inter<T>{

	@Override
	public void show(T t) {
	}

	@Override
	public <E> void myShow(E e) {
	}
	
}

三、泛型与集合

之前学习多态时，我们知道泛型参数不支持多态，也就是List<Fu> list = new ArrayList<Zi>();是不被允许的；同理，如果方法的参数是List<Fu>类型，ArrayList<Zi>也不能作为参数传入方法。这主要是出于安全考虑，因为在方法内部有可能把另一个子类参数的引用存储进集合，这就会出现错误！这种问题的解决方法有两种:

  1. 修饰符 <T> 返回值类型 方法名(Collection<T> c){} 或者修饰符 <T extends X> 返回值类型 方法名(Collection<T> c){}
  2. 方法名(Collection<?> c){} 、方法名(Collection<? extends X> c){}或方法名(Collection<? super X> c){}
这两种方法功能相同，但通常使用第二种方法，因为这种方法不仅书写简便，而且一目了然。其中<? extends X>和<T extends X>叫做向上限定，也就是传进方法的只能是存储该类型或其子类/实现类的集合；而<? super X>叫做向下限定，也就是传进方法的只能是存储该类型或其父类的集合。那么这两种方法到底是如何解决问题的呢？答案是当方法带有<T>或<?>声明时， 只能对 传入的集合进行获取和删除操作，不能对其进行添加和修改。示例程序： 
public class Test71 {

	public static void main(String[] args) {
		// 泛型基本用法，使用String类集合
		ArrayList<String> al_1 = new ArrayList<>();
		al_1.add("a");
		al_1.add("s");
		al_1.add("fd");
		al_1.add("gsd");
		System.out.println("--------------泛型基本用法，使用String类集合----------------");
		printCollection_1(al_1);
		printCollection_2(al_1);
		// !printCollection_3(al_1);
		// !printCollection_4(al_1);
		// !printCollection_5(al_1);
		//!printCollection_6(al_1);

		// 泛型基本用法，使用Person类集合
		TreeSet<Person> ts = new TreeSet<>();// 也可以使用比较器排序
		ts.add(new Person("sf", 27));
		ts.add(new Person("fab", 21));
		ts.add(new Person("xc", 24));
		ts.add(new Person("popo", 23));
		System.out.println("\n\n--------------泛型基本用法，使用Person类集合----------------");
		printCollection_1(ts);
		printCollection_2(ts);
		printCollection_3(ts);
		printCollection_4(ts);
		printCollection_5(ts);
		printCollection_6(ts);

		// 向上限定的用法
		ArrayList<Student> al_2 = new ArrayList<>();
		al_2.add(new Student("a", 13));
		al_2.add(new Student("asfda", 12));
		al_2.add(new Student("asdf", 13));
		al_2.add(new Student("fda", 11));
		System.out.println("\n\n--------------向上限定的用法----------------");
		printCollection_1(al_2);
		printCollection_2(al_2);
		// !printCollection_3(al_2);
		printCollection_4(al_2);
		printCollection_5(al_2);
		//!printCollection_6(al_2);

		// 向下限定的用法
		ArrayList<Organism> al_3 = new ArrayList<>();
		al_3.add(new Organism());
		al_3.add(new Organism());
		al_3.add(new Organism());
		al_3.add(new Organism());
		System.out.println("\n\n--------------向下限定的用法----------------");
		printCollection_1(al_3);
		printCollection_2(al_3);
		//!printCollection_3(al_3);
		//!printCollection_4(al_3);
		//!printCollection_5(al_3);
		printCollection_6(al_3);
	}

	// 使用自定义泛型（可以接收存储任何对象的集合）
	public static <T> void printCollection_1(Collection<T> ts) {
		System.out.println("使用自定义泛型：");
		// !ts.add(new Worker("k", 12));
		//ts.clear();只能获取或删除，不能添加
		Iterator<T> it = ts.iterator();
		while (it.hasNext()) {
			T t = it.next();
			System.out.print(t);
		}
	}

	// 使用类型通配符（可以接收存储任何对象的集合）
	public static void printCollection_2(Collection<?> ts) {
		System.out.println("\n使用类型通配符：");
		// !ts.add(new Worker("k", 12));
		//ts.clear();只能获取或删除，不能添加
		Iterator<?> it = ts.iterator();
		while (it.hasNext()) {
			System.out.print(it.next());
		}
	}

	// 使用确定类型（只能接收存储Person对象的集合）
	public static void printCollection_3(Collection<Person> ts) {
		System.out.println("\n使用确定泛型：");
		ts.add(new Worker("k", 12));// 如果能传入Student的集合，这里就会出现错误的！所以编译不会通过！
		Iterator<Person> it = ts.iterator();
		while (it.hasNext()) {
			Person p = it.next();
			System.out.print(p);
		}
	}

	// 向上限定，使用自定义泛型（只能接收存储Person对象、Person子类对象或Person实现类的集合）
	public static <T extends Person> void printCollection_4(Collection<T> ts) {
		System.out.println("\n向上限定，使用自定义泛型：");
		// !ts.add(new Worker("k", 12));
		//ts.clear();只能获取或删除，不能添加
		Iterator<T> it = ts.iterator();
		while (it.hasNext()) {
			Person p = it.next();
			System.out.print(p);
		}
	}

	// 向上限定，使用类型通配符（只能接收存储Person对象、Person子类对象或Person实现类对象的集合）
	public static void printCollection_5(Collection<? extends Person> ts) {
		System.out.println("\n向上限定，使用类型通配符：");
		// !ts.add(new Worker("k", 12));
		//ts.clear();只能获取或删除，不能添加
		Iterator<? extends Person> it = ts.iterator();
		while (it.hasNext()) {
			Person p = it.next();
			System.out.print(p);
		}
	}
	
	// 向下限定，不能使用自定义泛型

	// 向下限定，使用类型通配符（只能接收存储Person对象或Person父类对象的集合）
	public static void printCollection_6(Collection<? super Person> ts) {
		System.out.println("\n向下限定，使用类型通配符：");
		// !ts.add(new Worker("k", 12));
		//ts.clear();只能获取或删除，不能添加
		Iterator<? super Person> it = ts.iterator();
		while (it.hasNext()) {
			System.out.print(it.next());
		}
	}
}

class Organism{

	@Override
	public String toString() {
		return "Organism []";
	}
	
}

class Person extends Organism implements Comparable<Person> {

	private String name;
	private int age;

	public Person() {
		super();
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Person o) {
		int temp = this.age - o.age;
		return temp == 0 ? this.name.compareTo(o.name) : temp;
	}

}

class Student extends Person {

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super(name, age);
	}

	@Override
	public String toString() {
		return "Student [name=" + getName() + ", age=" + getAge() + "]";
	}

}

class Worker extends Person {

	public Worker() {
		super();
	}

	public Worker(String name, int age) {
		super(name, age);
	}
}

// 比较器
class ComparatorByName implements Comparator<Person> {

	@Override
	public int compare(Person o1, Person o2) {

		int temp = o1.getName().compareTo(o2.getName());
		return temp == 0 ? o1.getAge() - o2.getAge() : temp;
	}
}


华月箜篌
关注
专栏目录
Java学习笔记 --- 泛型
乌云的博客
11-11 744
1、泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题2、在类声明或实例化时只要指定好需要的具体的类型即可3、Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时代码更加简洁，健壮4、泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型//该数据类型在定义Person对象的时候指定，即在编译期间就确定E是什么类型。
Exer.java（JavaSE泛型学习笔记）
04-19
泛型学习笔记2的源代码，泛型 ： 要解决类型的安全问题， 如果使用Object类型会带来类型的损失。典型的应用就是在集合中， 集合中理论上可以保存任意对象，实际上我们应该让它泛型化，集合类<元素类型>, 添加元素...
Java泛型程序设计之定义简单泛型类、泛型方法、以及类型变量的限定
热门推荐
贝贝的博客
05-17 1万+
1
JavaSE---泛型学习笔记2
weixin_42066446的博客
04-19 176
泛型 ： 要解决类型的安全问题， 如果使用Object类型会带来类型的损失。典型的应用就是在集合中， 集合中理论上可以保存任意对象，实际上我们应该让它泛型化，集合类<元素类型>, 添加元素只能添加指定类型，获取元素时一定能获取指定类型的对象，不需要造型。 成员泛型 package com.atguigu.javase.exer; import org.junit.Test; c...
JavaSE---12泛型
feverd555的博客
05-24 183
泛型
学习笔记javaSE---集合
m0_72843976的博客
07-23 164
List Set Map
学习笔记-JavaSE之泛型
scc_make_belief的博客
03-27 106
泛型的概念， 为什么要有泛型 在集合中使用泛型 自定义泛型结构 泛型在继承上的体现 通配符的使用 泛型应用举例
JavaSE笔记-泛型与集合类
a35065521的博客
05-06 824
JavaSE笔记-泛型与集合类 在前面我们学习了最重要的类和对象，了解了面向对象编程的思想，注意，非常重要，面向对象是必须要深入理解和掌握的内容，不能草草结束。在本章节，我们会继续深入了解，从我们的泛型开始，再到我们的数据结构，最后再开始我们的集合类学习。 走进泛型 为了统计学生成绩，要求设计一个Score对象，包括课程名称、课程号、课程成绩，但是成绩分为两种，一种是以优秀、良好、合格 来作为结果，还有一种就是 60.0、75.5、92.5 这样的数字分数，那么现在该如何去设计这样的一个Score类呢？现在
JavaSE学习笔记之-----集合
彦帅的博客
07-30 734
JavaSE学习笔记之-----集合
JAVASE深度学习笔记 - - 泛型使用详解
qq_37779333的博客
08-12 289
泛型 所谓泛型就是变量类型的参数化，简单来理解就是（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 从使用的角度来讲的话就是，为了提高安全性，使用泛型的基础之上程序编译期间没有问题的话，那么执行期间一定没有问题，看下边这个例子； 在这里...
Java学习笔记（javase）
03-03
"Java学习笔记（javase）"这份资料主要涵盖了Java Standard Edition（Java SE）的基础知识，它是Java平台的核心，为桌面应用和服务器端应用提供了运行环境。这份笔记可能是作者在深入学习Java SE的过程中，对关键...
[Java学习笔记doc]-javase基本知识
最新发布
08-11
这份"Java学习笔记doc-javase基本知识"涵盖了Java SE的核心概念，对于初学者和有经验的开发者来说都是宝贵的参考资料。 1. **Java语法基础** - **关键字和标识符**：Java的关键字包括`public`, `private`, `...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
学习笔记之开发相关概念（1）--前端后端前台后台
huayuekonghoui的博客
02-13 5906
前端后端前台后台
学习笔记之JavaSE（29）--JavaAPI详解4
huayuekonghoui的博客
11-22 889
集合类之Collection接口
学习笔记之开发相关概念（3）--项目部署和项目发布
huayuekonghoui的博客
02-22 855
项目部署和项目发布
学习笔记之JavaSE（2）--Java基础语法1
huayuekonghoui的博客
10-24 749
一、Java主类结构 Java主类包括包声明、导入类库、成员变量和局部变量、方法等等，主类存在如下规范 每个Java文件有且只有一个与文件名同名的public主类 除了主类，可以自由定义任意个内部类与普通类（只能是包访问权限）main()方法可以定义在某个Java文件的任意类中（如果在内部类中就必须是静态内部类），可以在不同类中有多个main()方法 每个Java文件最好只有一个类
学习笔记之JavaSE（10）--面向对象编程1
huayuekonghoui的博客
10-31 744
一、面向对象编程思想 面向对象就是一种解决问题的思维方式，它与面向过程的对比如下： 面向过程就是分析出解决问题的所有步骤，然后用函数把这些步骤依次实现，使用的时候依次调用就可以了。 面向对象是把构成问题的事物抽象成各个对象，创建对象的目的不是为了完成一个步骤，而是为了描叙某个事物在解决问题过程中的行为。 例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3
JavaSE学习笔记：核心技术概览
"JavaSE_note 是一份学习Java标准版（JavaSE）的个人笔记，包含了对JavaSE基础知识的记录和理解。" JavaSE（Java Standard Edition）是Java平台的一个核心部分，主要关注桌面应用和客户端开发。以下是JavaSE中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值