java之 ------ 泛型【从基础到加强】

2024-06-09 13:08
文章标签 java 基础 加强 ------ 泛型

本文主要是介绍java之 ------ 泛型【从基础到加强】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

泛型

基础篇

一、为什么要泛型

1、原因

先看一个集合的例子（至于集合，前面有讲解，集合详解链接，不懂得可以先去看看那篇）

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;import cn.hncu.bean.Person;public class CollectionDemo {public static void main(String[] args) {Collection col = new ArrayList();//增 addcol.add(new Person(23,"qwe")); //从jdk1.5以后，可以自动包装col.add(new Person(22,"df"));col.add(new Person(21,"af"));col.add(new Person(24,"fgr"));col.add(new Person(26,"et"));col.add(new Person(27,"ghj"));//添加重复的元素，对于List是可以的，而对于Set是加不进的。 //删 remove 移除的是元素本身//col.remove(3);//col.remove(2);//改//col.remove(1); col.add(4); //不合理，因为位置变了//Object objs[] = col.toArray();//col.clear();//for(int i=0;i<objs.length;i++){//	if(objs[i].equals(1)){//		objs[i]=4;//	}//	col.add(objs[i]);//}Iterator<Object> it = col.iterator();while(it.hasNext()){Object obj = it.next();if(obj instanceof Person){System.out.println("Object:"+obj);}else if(obj instanceof Integer){System.out.println("int:"+obj);}else{System.out.println("Other:"+obj);}}}}

这个程序就是一个简单的集合，先输入和输出。咋一看没什么问题，就算放在myeclipse运行，结果也是对的。但是你会发现，在myeclipse中会出现很多黄色感叹号，这表示此程序有警告，也就是存在不安全因素。

会出现这些警告的原因是：集合是可以存放多种不同的种类的元素，但是在取出来的时候就不能确定放的时候到底是什么类型了。

书面解释：集合中可以存储任意类型对象，但是在取出时，如果要使用具体对象的特有方法时，需要进行向下转型，如果存储的对象类型不一致，在转型过程中就会出现ClassCastException异常。这样就给程序带来了不安全性。

在jdk1.5以后就有了解决方案——泛型技术：在存储元素时，就不允许存储不同类型的元素。存储了就编译失败。 所以就需要在存储元素时，在容器上明确具体的元素类型，这其实和数组定义很像。（数组定义：int[] ,double[] ,类名[],String[]等

等，看看写法应该能明白一二了吧，前面都明确了数组的类型）

要除去上面的黄色感叹号，只要改这两句即可：

Collection<Person> col = new ArrayList<Person>();
Iterator<Person> it = col.iterator();

2、好处

1）将运行时期的ClassCastException异常转移到了编译时期，进行检查，并以编译失败来体现。 这样有利于程序员尽早解决问题。 

2）避免了向下转型(强转)的麻烦。

例：

import java.util.ArrayList;
import java.util.Iterator;public class GenericDemo1 {public static void main(String[] args) {//demo1();demo2();}private static void demo1() {ArrayList aList = new ArrayList();aList.add("abcd");aList.add("abcewew");aList.add("a333d");aList.add(8);//编译没错，但运行时出错了。这是不安全的，对软件开发来讲，很不利。Iterator it = aList.iterator();while(it.hasNext()){String str = (String) it.next();str = str.toUpperCase();System.out.println(str.length());}}private static void demo2() {ArrayList<String> aList = new ArrayList<String>();aList.add("abcd");aList.add("abcewew");aList.add("a333d");//aList.add(8);//加泛型后，该句会直接报错。泛型的好处(1)Iterator<String> it = aList.iterator();while(it.hasNext()){String str = it.next();//加泛型后，不需要进行类型强转。泛型的好处(2)str = str.toUpperCase();System.out.println(str.length());}}}
调用demo1()时，放的时候用了两个不同的类型元素，编译的时候没有报错，输出的时候，因为没给泛型，所以要强转，问题就出现在这，int型的8强转到string就会出错，也就是运行时出错。

调用demo1()时，因为提前用了泛型，也就是规定了这个集合放什么样类型的数据，所以在写完add(8)的时候，就会直接报错。而且后面输出的时候，也不用再强转了。

总而言之，就是，java写了一个可以同时操作多种不同类型元素功能的容器，也就是集合，但是在运用的它的时候发现存在不安全因素，所以在运用它的时候又规定了只能用哪一种，也就是加的泛型。（如同数组）

二、泛型运用的原理

1、什么时候写泛型

只要在使用类或者接口时，该类或者接口在api文当描述时都带着<>，就需要在使用时定义泛型。 其实，泛型无非就是通过<>定义了一个形式参数，专门用于接收具体的引用类型。在使用时，一定要传递对应的实际参数类型。集合中泛型的应

用特别多见。

2、泛型的擦除

泛型技术是用于编译时期的技术，编译器会按照<>中的指定类型对元素进行检查，检查不匹配，就编译失败，匹配，就编译通过，通过后，生产的class文件中是没有泛型的，这就成为泛型的擦除。

3、泛型的补偿

运行时，可以根据具体的元素对象获取其具体的类型，并用该类型对元素进行自动转换。（也就是取出的时候，不用再用强转了）

三、泛型的使用

1、使用泛型的动机举例（以集合为例）：

对集合中存放元素的类型进行限定，防止后期出错。如果限定某个集合只能存放Person类对象（因为后期会把元素取出来当作Person对象来处理)，这样放其它类型的对象在编译时就会报错。相当于把一

个类泛化成很多个不同类型（具体化，限定化）的类。

泛型使用的代码如：

List<Person> persons = new ArrayList<Person>;
Map<String,String> m = new HashMap<String,String>;

2、泛型的含义

在定义泛型类或声明泛型类的变量时，使用尖括号来指定形式类型参数，称为类型形参，在调用时传递的实际类型成为类型实参。类型形参与类型实参之间的关系类似于形式方法参数与实际方法参数之间的关系，只是类型参数表示类型，而不

是表示值。

注意：当一个变量被声明为泛型时，只能被实例变量和方法调用，而不能被静态变量和方法调用。原因很简单，参数化的泛型是一些实例。静态成员是被类的实例和参数化的类所共享的，所以静态成员不应该有类型参数和他们关联。

四、泛型类（自定义）

1、定义成泛型类情况

当一个类要操作的引用数据类型不确定的时候，可以将该类型定义一个形参。用到的这类时，由使用者来通过传递类型参数的形式，来确定要操作的具体的对象类型。

这意味着在定义这个类时，需要在类上定义形参，用于接收具体的类型实参。这就是将泛型定义在类上，即泛型类。

例：

/** 泛型类的演示*/
public class GenericDemo2 {public static void main(String[] args) {MyVessel<Worker> u = new MyVessel<Worker>();//u.setObject(new Student());//不行，u中存放的是Worker，实参只能是Worker类型u.setObject(new Worker());Worker w = u.getObject();System.out.println(w);MyVessel<Student> v = new MyVessel<Student>();//v.setObject(new Worker());//不行，实参只能是Student类型}}class MyVessel<E>{ //从语法上讲把“E”取成别的名字如“QQ”也是可以的，但不规范。private E obj;public void setObject(E obj){this.obj = obj;}public E getObject(){return obj;}
}class Student{String profession;
}
class Worker{String company; 
}

2、泛型类的好处

什么时候使用泛型类呢？只要类中操作的引用数据类型不确定的时候，就可以定义泛型类。 有了泛型类，省去了曾经的强转和类型转换异常的麻烦。 

3、泛型方法的定义

1）与类的泛型捆绑

方法要操作的类型不确定的，但是和调用该方法的对象指定的类型是一致。

2）独立于类的泛型

方法要操作的类型不确定的，而且不一定和调用该方法的对象指定的类型是一致。

3）静态方法的泛型

静态方法不能访问类上定义的泛型，因为它没有对象。如果静态方法需要泛型，该泛型只能定义在方法上。

例：

/** 泛型方法演示*/
public class GenericDemo3 {public static void main(String[] args) {Tool<String> t1 = new Tool<String>();t1.show("abc");//t1.show(new Integer(6));//不行，因为t1限定只能处理String型数据Tool<Integer> t2 = new Tool<Integer>();//t2.show("abc");//不行，因为t2限定只能处理Integer型数据t2.show(new Integer(6));String s = t1.myprint("aaa");System.out.println(s);int i = t1.myprint(new Integer(6));//String s2 = t1.myprint(new Integer(6));//不行，因为方法上定义了泛型，且返回类型和方法的实参类型是一致的System.out.println(i);}}class Tool<W>{//方法上的泛型和类的一致，或者说依赖于类的泛型   法1public void show(W w){System.out.println("show:"+w.toString());}//不带泛型，不安全。因为在调用方可以把该方法的返回值强转成其它类型，从而出现强转异常public Object myprint0(Object a){System.out.println("myprint:"+a);return a;}//方法带泛型，但要求和类的泛型相互独立。可以限定返回类型和方法的实参相同，更安全，而且不用强转。   法2public <A> A myprint(A a){System.out.println("myprint:"+a);return a;}//静态方法带泛型，泛型一定要独立于类，因为它没有对象。   法3public static <A> A myprint2(A a){System.out.println("myprint:"+a);return a;}}

五、泛型接口

public class GenericDemo4 {public static void main(String[] args) {String str = new InterImpl().show("abc");System.out.println("main:"+str);//Integer i = new InterImpl2<Integer>().show(80);InterImpl2<Integer> mm = new InterImpl2<Integer>();//mm.show("aaa");//上一句加了泛型，因此这里会报告编译错误int i = mm.show(80);System.out.println(i);}}interface Inter<V>{public abstract V show(V v);
}//实现泛型接口的类的定义。 方法中的参数类型和类声明实现接口时指定的类型一致，且已经确定为String!-----本例假设我们写这个类的时候知道该类就是专门处理String型数据的
class InterImpl implements Inter<String>{@Overridepublic String show(String s) {System.out.println(s);return s;}
}//实现泛型接口的类的定义。 方法中的参数类型和类声明实现接口时指定的类型一致，但不确定!-----本例假设我们写这个类的时候不知道该类是处理什么类型的数据的，但有一点确定：声明类对象时指定什么类型(泛型的实参)，show方法就处理该类型
class InterImpl2<C> implements Inter<C>{@Overridepublic C show(C s) {System.out.println(s);return s;}
}



加强篇

一、泛型的通配符：?

当操作的不同容器中的类型都不确定的时候，而且使用的都是元素从Object类中继承的方法， 这时泛型就用通配符?来表示即可。（助理解的比方: 泛型中的多态应用)

import java.util.ArrayList;
import java.util.Iterator;public class GenericAdvDemo1_1 {public static void main(String[] args) {ArrayList<String> a1 = new ArrayList<String>();a1.add("abc1");a1.add("abc2");a1.add("abc3");ArrayList<Integer> a2 = new ArrayList<Integer>();a2.add(100);a2.add(6);a2.add(8);//		printColl(a1);//此方法只能输出a1
//		printColl2(a2);//<span style="font-family: Arial, Helvetica, sans-serif;">此方法只能输出a2</span>printColl3(a1);//此方法既能输出a1也能输出a2，这就是泛型的通配符的用途printColl3(a2);}/* 该解决方案从思路上讲是对的，但在语法上通不过。因为这是运行期的多态，而我们的泛型在编译期public static void printColl(ArrayList<Object> a){Iterator<Object> it = a.iterator();while(it.hasNext()){Object str = it.next();System.out.println(str);}}*/public static void printColl(ArrayList<String> a){Iterator<String> it = a.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);}}public static void printColl2(ArrayList<Integer> a){Iterator<Integer> it = a.iterator();while(it.hasNext()){Integer str = it.next();System.out.println(str);}}public static void printColl3(ArrayList<?> a){Iterator<?> it = a.iterator();while(it.hasNext()){Object str = it.next();System.out.println(str); //元素只能调用从Object类中继承的方法}}
}


二、泛型的限定

对操作的类型限制在一个范围之内。比如：定义一个功能，只操作Person类型或者Person的子类型。这时可以用:  

? extends E:接收E类型或者E的子类型。这就是上限。 

import java.util.ArrayList;
import java.util.Iterator;public class GenericAdvDemo3 {public static void main(String[] args) {ArrayList<Person> a1 = new ArrayList<Person>();a1.add(new Person("Jack1",20));a1.add(new Person("Jack3",23));a1.add(new Person("Jack2",22));ArrayList<Integer> a2 = new ArrayList<Integer>();a2.add(100);a2.add(6);a2.add(8);ArrayList<Student> a3 = new ArrayList<Student>();a3.add(new Student("aa",10));a3.add(new Student("bb",20));a3.add(new Student("cc",30));printColl(a1);//printColl(a2);printColl(a3);}/*自己写带上限的泛型方法*/public static void printColl(ArrayList<? extends Person> a){Iterator<? extends Person> it = a.iterator();while(it.hasNext()){Person p = it.next();System.out.println(p.getName()); //元素只能调用从Person类中继承的方法}}
}


? super E:   接收E类型或者E的父类型。 这就是下限。

API查看：Collection中的addAll()方法中的泛型就是一个上限的运用。TreeSet类的构造方法就分别用了上限和下限。

一般情况下:

只要是往容器中添加元素时，使用上限。 ? extends E

只要是从容器中取出元素时，是用下限。 ? super E

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;public class GenericAdvDemo2 {public static void main(String[] args) {//演示上限，应用场合：往集合中放元素//extendsEDemo();//演示下限，应用场合：从集合中取元素superEDemo();}private static void extendsEDemo() {Collection<Person> coll = new ArrayList<Person>();coll.add(new Person("Jack",23));coll.add(new Person("Tom",124));coll.add(new Person("Rose",25));Collection<Student> coll2 = new ArrayList<Student>();coll2.add(new Student("Jack2",223));coll2.add(new Student("Tom2",224));coll2.add(new Student("Rose2",225));TreeSet<Person> ts = new TreeSet<Person>(coll);ts.add(new Student("aaa",100));ts.addAll(coll2);//上限:coll2中的元素类型(泛型)必须是Person或Person的子类Iterator<Person> it = ts.iterator();while(it.hasNext()){Person p = it.next();System.out.println(p.toString());}//		TreeSet<Student> ts2 = new TreeSet<Student>(coll2);
//		Iterator<Student> it2 = ts2.iterator();
//		while(it2.hasNext()){
//			Student p = it2.next();
//			System.out.println(p.toString());
//		}}private static void superEDemo() {//TreeSet<Student> ts = new TreeSet<Student>( new CompByName1() );TreeSet<Student> ts = new TreeSet<Student>( new CompByName() );ts.add(new Student("lisi1",21));ts.add(new Student("lisi3",23));ts.add(new Student("lisi2",22));Iterator<Student> it = ts.iterator();while(it.hasNext()){Student p = it.next();System.out.println(p.toString());}//TreeSet<Worker> ts2 = new TreeSet<Worker>( new CompByName2() );TreeSet<Worker> ts2 = new TreeSet<Worker>( new CompByName() );ts2.add(new Worker("lisi21",21));ts2.add(new Worker("lisi23",23));ts2.add(new Worker("lisi22",22));Iterator<Worker> it2 = ts2.iterator();while(it2.hasNext()){Worker p = it2.next();System.out.println(p.toString());}}}@SuppressWarnings("rawtypes")
class Person implements Comparable{String name;int age;public Person(String name, int age) {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;}@Overridepublic int compareTo(Object o) {Person p = (Person) o;return this.age-p.age;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}}class Student extends Person{String profession;public Student(String name, int age) {super(name, age);}
}
class CompByName1 implements Comparator<Student>{@Overridepublic int compare(Student s1, Student s2) {return s1.getName().compareTo(s2.getName());}
}class Worker extends Person{String company;public Worker(String name, int age) {super(name, age);}
}class CompByName2 implements Comparator<Worker>{@Overridepublic int compare(Worker s1, Worker s2) {return s1.getName().compareTo(s2.getName());}
}//利用泛型中的“Comparator<? super E> comparator”即下限特性，做一个通用的比较器(比较所有Person及其子类对象0
class CompByName implements Comparator<Person>{@Overridepublic int compare(Person s1, Person s2) {return s1.getName().compareTo(s2.getName());}
}















这篇关于java之 ------ 泛型【从基础到加强】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1045261。

相关文章

Java Predicate接口定义详解

Java Predicate接口定义详解

《JavaPredicate接口定义详解》Predicate是Java中的一个函数式接口,它代表一个判断逻辑,接收一个输入参数,返回一个布尔值,：本文主要介绍JavaPredicate接口的定义... 目录Java Predicate接口Java lamda表达式 Predicate<T>、BiFuncti
阅读更多...
Spring Security基于数据库的ABAC属性权限模型实战开发教程

Spring Security基于数据库的ABAC属性权限模型实战开发教程

《SpringSecurity基于数据库的ABAC属性权限模型实战开发教程》：本文主要介绍SpringSecurity基于数据库的ABAC属性权限模型实战开发教程,本文给大家介绍的非常详细,对大... 目录1. 前言2. 权限决策依据RBACABAC综合对比3. 数据库表结构说明4. 实战开始5. MyBA
阅读更多...
Spring Security方法级安全控制@PreAuthorize注解的灵活运用小结

Spring Security方法级安全控制@PreAuthorize注解的灵活运用小结

《SpringSecurity方法级安全控制@PreAuthorize注解的灵活运用小结》本文将带着大家讲解@PreAuthorize注解的核心原理、SpEL表达式机制,并通过的示例代码演示如... 目录1. 前言2. @PreAuthorize 注解简介3. @PreAuthorize 核心原理解析拦截与
阅读更多...
一文详解JavaScript中的fetch方法

一文详解JavaScript中的fetch方法

《一文详解JavaScript中的fetch方法》fetch函数是一个用于在JavaScript中执行HTTP请求的现代API,它提供了一种更简洁、更强大的方式来处理网络请求,：本文主要介绍Jav... 目录前言什么是 fetch 方法基本语法简单的 GET 请求示例代码解释发送 POST 请求示例代码解释
阅读更多...
Java图片压缩三种高效压缩方案详细解析

Java图片压缩三种高效压缩方案详细解析

《Java图片压缩三种高效压缩方案详细解析》图片压缩通常涉及减少图片的尺寸缩放、调整图片的质量(针对JPEG、PNG等)、使用特定的算法来减少图片的数据量等,：本文主要介绍Java图片压缩三种高效... 目录一、基于OpenCV的智能尺寸压缩技术亮点：适用场景：二、JPEG质量参数压缩关键技术：压缩效果对比
阅读更多...
Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...
springboot+dubbo实现时间轮算法

springboot+dubbo实现时间轮算法

《springboot+dubbo实现时间轮算法》时间轮是一种高效利用线程资源进行批量化调度的算法,本文主要介绍了springboot+dubbo实现时间轮算法,文中通过示例代码介绍的非常详细,对大家... 目录前言一、参数说明二、具体实现1、HashedwheelTimer2、createWheel3、n
阅读更多...
Java利用docx4j+Freemarker生成word文档

Java利用docx4j+Freemarker生成word文档

《Java利用docx4j+Freemarker生成word文档》这篇文章主要为大家详细介绍了Java如何利用docx4j+Freemarker生成word文档,文中的示例代码讲解详细,感兴趣的小伙伴... 目录技术方案maven依赖创建模板文件实现代码技术方案Java 1.8 + docx4j + Fr
阅读更多...
SpringBoot首笔交易慢问题排查与优化方案

SpringBoot首笔交易慢问题排查与优化方案

《SpringBoot首笔交易慢问题排查与优化方案》在我们的微服务项目中,遇到这样的问题：应用启动后,第一笔交易响应耗时高达4、5秒,而后续请求均能在毫秒级完成,这不仅触发监控告警,也极大影响了用户体... 目录问题背景排查步骤1. 日志分析2. 性能工具定位优化方案：提前预热各种资源1. Flowable
阅读更多...
Python基础文件操作方法超详细讲解(详解版)

Python基础文件操作方法超详细讲解(详解版)

《Python基础文件操作方法超详细讲解(详解版)》文件就是操作系统为用户或应用程序提供的一个读写硬盘的虚拟单位,文件的核心操作就是读和写,：本文主要介绍Python基础文件操作方法超详细讲解的相... 目录一、文件操作1. 文件打开与关闭1.1 打开文件1.2 关闭文件2. 访问模式及说明二、文件读写1.
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2