泛型&通配符
文章目录
- 泛型&通配符
- 一、泛型介绍&理解
- 1.1 泛型概述&使用(集合/比较器)
- 1.2 自定义范型结构(类/接口/方法)
- 二、通配符&读写特点
- 三、企业真题
一、泛型介绍&理解
1.1 泛型概述&使用(集合/比较器)
泛型：类似于场景中的标签，即为类型参数，在声明它的类、接口或方法中，代表未知的某种通用类型。
比如使用集合存储数据时，除了元素的类型不确定，其他部分是确定的（例如关于这个元素如何保存，如何管理等）。
JDK1.5设计了泛型的概念，例如：JDK5.0改写了集合框架中的全部接口和类、java.lang.Comparable接口、java.util.Comparator接口、Class类等。为这些接口、类增加了泛型支持，从而可以在声明变量、创建对象时传入类型实参。
简单示例：不确定的类型用T来表示，如果不指定的话，可传入任意类型的
public class Teacher<T> {
T name;
int add(T num){
return 0;
}
}
//测试：不指定具体类型，缺点：会出现类型转换异常等等
@Test
public void test1(){
Teacher tea = new Teacher();
tea.name = 1;//可以是任意类型的
tea.name ="23";
}
//测试：指定具体类型，此时所有T代表的类型参数全部替换为类型String
@Test
public void test2(){
Teacher<String> tea = new Teacher<>();
//tea.name = 1;//报错
tea.name ="23";
}
1.什么是泛型?
即类型参数，允许在定义类、接口、方法时通过一个标识表示类中某个属性的类型、某个方法的返回值或参数的类型
这个类型参数将在使用时(例如，继承或实现这个接口、创建对象或调用方法时)确定(即传入实际的类型参数，也称为类型实参)。
2、使用泛型之前可能存在的问题
- 在集合中
- 问题1：类型不安全，因为add()的参数是0bject类型，意味着任何类型的对象都可以添加成功
- 问题2：需要使用强转操作，繁琐。还有可能导致ClassCastException异常。
- 在比较器中
- 不能确定是什么类型的对象比较大小，需要判断是否是该类型的实例、类型转换等操作，用了泛型之后，他就只能接受指定类型的对象
3、使用泛型的好处：以集合为例：把一个集合中的内容限制为一个特定的数据类型，这就是generic背后的核心思想。
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。即，把不安全的因素在编译期间就排除了，而不是运行期；既然通过了编译，那么类型一定是符合要求的，就避免了类型转换。
集合使用泛型示例：ArrayList，注意可以用类型推断
实现功能：使用集合的removeIf方法删除偶数，为Predicate接口指定泛型<Ineteger>
public class TestNumber {
public static void main(String[] args) {
ArrayList<Integer> coll = new ArrayList<Integer>();
Random random = new Random();
for (int i = 1; i <= 5 ; i++) {
coll.add(random.nextInt(100));
}
System.out.println("coll中5个随机数是：");
for (Integer integer : coll) {
System.out.println(integer);
}
//方式1：使用集合的removeIf方法删除偶数
coll.removeIf(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
return integer % 2 == 0;
}
});
//方式2：调用Iterator接口的remove()方法
//Iterator<Integer> iterator1 = coll.iterator();
//while(coll.hasNext()){
// Integer i = coll.next();
// if(i % 2 == 0){
// coll.remove();
// }
//}
System.out.println("coll中删除偶数后：");
Iterator<Integer> iterator = coll.iterator();
while(iterator.hasNext()){
Integer number = iterator.next();
System.out.println(number);
}
}
}
集合使用泛型示例：HashMap，注意可以用类型推断
//泛型在Map中的使用
@Test
public void test2(){
//HashMap<String,Integer> map = new HashMap<String,Integer>();
HashMap<String,Integer> map = new HashMap<>();//使用类型推断
map.put("Tom",67);
map.put("Jim",56);
map.put("Rose",88);
//编译不通过
//ap.put(67,"Jack");
//遍历key集
Set<String> keySet = map.keySet();
for(String str:keySet){
System.out.println(str);
}
//遍历value集
//var values = map.values();//可以使用类型推断
Collection<Integer> values = map.values();
Iterator<Integer> iterator = values.iterator();
while(iterator.hasNext()){
Integer value = iterator.next();
System.out.println(value);
}
//遍历entry集
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator1 = entrySet.iterator();
while(iterator1.hasNext()){
Map.Entry<String, Integer> entry = iterator1.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + ":" + value);
}
}
Comparable接口使用泛型后
class CircleComparator1 implements Comparator<Circle> {//指定具体的泛型类型
@Override
public int compare(Circle o1, Circle o2) {
//不再需要强制类型转换，代码更简洁
return Double.compare(o1.getRadius(), o2.getRadius());
}
}
//测试类
public class TestHasGeneric {
public static void main(String[] args) {
CircleComparator1 com = new CircleComparator1();
System.out.println(com.compare(new Circle(1), new Circle(2)));//如果有错误，会在编译阶段就报错
//System.out.println(com.compare("圆1", "圆2"));
//编译错误，因为"圆1", "圆2"不是Circle类型，是String类型，编译器提前报错，
//而不是冒着风险在运行时再报错。
}
}
CompareTor构造器的定义方式：使用泛型实现，指定只接受某个类型的
只有比较的定义不一样，其它的部分都是一样的，这里以匿名内部类方式
//价格从小打到排序，价格一样，name从大到小排序
Comparator<Product> comp = new Comparator<Product>() {
@Override
public int compare(Product p1, Product p2) {
int res = Double.compare(p1.price,p1.price);
if(res != 0){
return res;//从小到大排序
}
return -p1.name.compareTo(p2.name);//从大到小排序
}
};
1.2 自定义范型结构(类/接口/方法)
1、<类型>这种语法形式就叫泛型。
<T>：称为类型参数，代表未知的数据类型，可以指定为<String>，<Integer>，<Circle>等。类比方法中形参将<T>称为类型形参，将<Circle>称为类型实参。T可以替换成K，V等任意字母
泛型类/接口的声明：在类名或接口名后面声明泛型类型，我们把这样的类或接口称为
泛型类或泛型接口。
多个泛型参数声明：<E1,E2,E3>
JDK7.0 开始，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();
【修饰符】 class 类名<类型变量列表> 【extends 父类】 【implements 接口们】{
}
【修饰符】 interface 接口名<类型变量列表> 【implements 接口们】{
}
//例如：
public class ArrayList<E>
public interface Map<K,V>{
....
}
泛型方法声明格式：在【修饰符】与返回值类型之间声明类型变量。把声明了类型变量的方法，称为泛型方法。
[修饰符] <类型变量列表> 返回值类型 方法名([形参列表])[throws 异常列表]{
//...
}
public class DAO {
public <E> E get(int id, E e) {
E result = null;
return result;
}
}
1、自定义泛型类或泛型接口、方法：
- 泛型类或接口：在类或接口中定义某个成员时，该成员的相关类型是不确定的，而这个类型需要在使用这个类或接口时才可以确定
- 在类的内部（比如：属性、方法、构造器中）使用类的泛型。其在本类或本接口中即代表某种类型
- 创建自定义泛型类的对象时：
- 可指明泛型参数类型。一旦指明，内部凡是使用类的泛型参数的位置，都具体化为指定的类的泛型类型。
- 泛型擦除：如果没有指明泛型参数类型，那么泛型对应的类型均按照Object处理，但不等价于Object。
- 指定泛型类型：只能是引用数据类型，如果是基本则可以使用包装类型代替
- 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
- 不可以在静态方法中使用类的泛型。
- 异常类不能是带泛型的
- 不能用new E[]，但可E[] elements = (E[])new Object[capacity];参考ArrayList源码声明：Object[] elementData，而非泛型参数类型数组。
- 泛型方法：在没有定义泛型类/接口时，但是某个方法形参类型不确定时，可以单独定义<泛型参数>。
- 方法可以被泛型化，并且可以被声明为static的，与所在类是否泛型无关，其中的泛型参数在方法被调用时确定。
2、泛型类/接口继承的一些特性
- 泛型类型的继承性：继承/实现泛型类/接口时，子类/接口可以确定泛型结构中的泛型参数。如果不确定泛型的类型，则可以继续使用泛型参数，还可以新增泛型参数。
- 如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G<B>并不是G<A>的子类型！
比如：String是Object的子类，但是List<String>并不是List<Object>的子类。
泛型继承的一些特性
class A<T>{
}
//1)没有类型 擦除
class B extends A{}
//子类：继承父类的泛型参数// 1)全部保留
class B extends A<T>{
}
//子类：指定父类的泛型参数类型 // 2)具体类型
class C extends A<Integer>{
}
//子类：在父类的基础上新增泛型参数
class D<E> extends A<Integer>{
}
泛型类/接口、方法的一些实现（及泛型方法的调用方式）
@Test
public void test8(){
//T[] arr = new T[];//是错误的写法
//T[] arr = (T[])new Object[6];
Integer[] arr = new Integer[]{12,21,43,56};
Integer[] arr1 = reverse(arr);
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
} //编写一个泛型方法，接收一个任意引用类型的数组，并反转数组中的所有元素
public <T> T[] reverse(T[] arr){
for (int min = 0,max = arr.length-1; min <max; min++,max--) {
T temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
return arr;
}
泛型类的使用场景：声明一个学生类，该学生包含姓名、成绩，而此时学生的成绩类型不确定，为什么呢，因为，语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”，数学老师希望成绩是89.5, 65.0，英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时，就可以使用泛型。
//省略了get/set方式
class Student<T>{
String name;
T score;
public Student() {
super();
}
public Student(String name, T score) {
super();
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "姓名：" + name + ", 成绩：" + score;
}
}
public class TestStudent {
public static void main(String[] args) {
//语文老师使用时：
Student<String> stu1 = new Student<String>("张三", "良好");
//数学老师使用时：
//Student<double> stu2 = new Student<double>("张三", 90.5);//错误，必须是引用数据类型
Student<Double> stu2 = new Student<Double>("张三", 90.5);
//英语老师使用时：
Student<Character> stu3 = new Student<Character>("张三", 'C');
//错误的指定
//Student<Object> stu = new Student<String>();//错误的
}
}
二、通配符&读写特点
1、通配符：?
注意：不能用在泛型方法声明上；不能用在泛型类的声明上；不能用在创建对象
2、通配符的使用：以ArrayList<?>为例 G\<?> 可以看做是G<A>类型的父类，G<?>引用/变量=G<A>对象
读写数据的特点(以集合ArrayList<?>为例说明)
读取数据：允许的，读取的值的类型为Object类型
写入数据：不允许的。特例写入null值。
4、有限制条件的通配符
List<? extends A>：理解"<=“(-∞,A]，可以将List<A>或List<B>赋值给List<? extends A>。其中B类是A类的子类。
List<? super A>：理解”>="[A,+∞)，可以将List<A>或List<B>赋值给List<?extends A>。其中B类是A类的父类。
读写数据的特点：技巧，开发中编译是否报错
? extends A：以集合为例：可以读取数据、不能写入数据（例外：null）
? super A：以集合为例：可以读取数据、可以写入A类型或A类型子类的数据（例外：null）
通配符的使用
//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}
//注意点2：编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{
}
//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();
有限制的通配符
<? extends Number> //(无穷小 , Number]
//只允许泛型为Number及Number子类的引用调用
<? super Number> //[Number , 无穷大)
//只允许泛型为Number及Number父类的引用调用
<? extends Comparable>
//只允许泛型为实现Comparable接口的实现类的引用调用
测试通配符及有限制条件的通配符、读写特点
//测试：通配符?的使用
@Test
public void test1() {
List<?> list = null;
List<Object> list1 = null;
List<String> list2 = null;
list = list1;
list = list2;
method(list1);
method(list2);
}
public void method(List<?> list) {
for (Object obj : list) {
System.out.println(obj);
}
//list.add("AA");//错误的
}
//测试：通配符?的读写数据的特点
@Test
public void test2() {
List<?> list = null;
List<String> list1 = new ArrayList<>();
list1.add("AA");
list = list1;
//读取数据(以集合为例说明)
Object obj = list.get(0);
System.out.println(obj);
//list.add("BB");//写入数据(以集合为例说明)//写入数据，操作失败。
//特例:可以将null写入集合中。
list.add(null);
}
//有限制条件的通配符的使用:? extends Father。范围(无穷小,Father]
@Test
public void test3(){
List<? extends Father> list = null;
List<Object> list1 = null;
List<Father> list2 = null;
List<Son> list3 = null;
//list = list1;//编译错误，?不包括这个范围
list = list2;
list = list3;
}
//针对于? extends A的读写
@Test
public void test3_1() {
List<? extends Father> list = null;
List<Father> list1 = new ArrayList<>();
list1.add(new Father());
list = list1;
//读取数据:可以的Father father = list.get(0);
//写入数据:
list.add(null);
//list.add(new Father());
//list.add(new Son());//编译错误，还可能是更小的
}
//有限制条件的通配符的使用:? super Father。范围[Father,无穷大)
@Test
public void test4() {
List<? super Father> list = null;
List <Object > list1 = null;
List<Father> list2 = null;
List<Son> list3 = null;
list = list1;
list = list2;
//list = list3;//不包括这个范围
}
public void test4_1() {
List<? super Father> list = null;
List<Father> list1 = new ArrayList<>() list1.add(new Father());
list = list1;
//读取数据:可以的
Object obj = list.get(0);
//写入数据:
list.add(null);
//list.add(new Object());
list.add(new Father());//多态的特性，小的可以添加给大的
list.add(new Son());
}
三、企业真题
1、Java 的泛型是什么？有什么好处和优点？JDK 不同版本的泛型有什么区别？（软动力）
泛型，是程序中出现的不确定的类型。
以集合来举例：把一个集合中的内容限制为一个特定的数据类型，这就是generic背后的核心思想。
jdk7.0新特性：
ArrayList<String> list = new ArrayList<>(); //类型推断
后续版本的新特性：
Comparator<Employee> comparator = new Comparator<>(){} //类型推断
