学习总目标

【每日一学】泛型编程实战：Java程序员的利器

本次学习目标

【每日一学】泛型编程实战：Java程序员的利器

1 泛型的概念

1.1 泛型的引入

例如：生产瓶子的厂家，一开始并不知道我们将来会用瓶子装什么，我们什么都可以装，但是有的时候，我们在使用时，想要限定某个瓶子只能用来装什么，这样我们不会装错，而用的时候也可以放心的使用，无需再三思量。我们生活中是在使用这个瓶子时在瓶子上“贴标签”，这样就轻松解决了问题。

【每日一学】泛型编程实战：Java程序员的利器

还有，在Java中我们在声明方法时，当在完成方法功能时如果有未知的数据需要参与，这些未知的数据需要在调用方法时才能确定，那么我们把这样的数据通过形参表明。那么在方法体中，用这个形参名来代表那个未知的数据，而调用者在调用时，对应的传入值就可以了。

【每日一学】泛型编程实战：Java程序员的利器

受以上两点启发，JDK1.5设计了泛型的概念。泛型即为“类型参数”，这个类型参数在声明它的类、接口或方法中，代表未知的通用的类型。例如：

java.lang.Comparable接口和java.util.Comparator接口，是用于对象比较大小的规范接口，这两个接口只是限定了当一个对象大于另一个对象时返回正整数，小于返回负整数，等于返回0。但是并不确定是什么类型的对象比较大小，之前的时候只能用Object类型表明，使用时既麻烦又不安全，因此JDK1.5就给它们增加了泛型。

public interface Comparable<T>{
int compareTo(T o) ;
}

public interface Comparator<T>{
int compare(T o1, T o2) ;
}

其中就是类型参数，即泛型。

1.2 泛型的好处

示例代码：

JavaBean：圆类型

package com.atguigu.generic;

public class Circle{
private double radius;

public Circle(double radius) {
super();
this.radius = radius;
}

public double getRadius() {
return radius;
}

public void setRadius(double radius) {
this.radius = radius;
}

@Override
public String toString() {
return “Circle [radius=” + radius + “]”;
}

}

比较器

package com.atguigu.generic;

import java.util.Comparator;

public class CircleRadiusComparator implements Comparator{

@Override
public int compare(Object o1, Object o2) {
//强制类型转换
Circle c1 = (Circle) o1;
Circle c2 = (Circle) o2;
return Double.compare(c1.getRadius(), c2.getRadius());
}

}

测试类

package com.atguigu.generic;

public class TestNoGeneric {
public static void main(String[] args) {
CircleRadiusComparator com = new CircleRadiusComparator();
System.out.println(com.compare(new Circle(1), new Circle(2)));

System.out.println(com.compare(“圆1”, “圆2”));//运行时异常：ClassCastException
}
}

那么我们在使用如上面这样的接口时，如果没有泛型或不指定泛型，很麻烦，而且有安全隐患。

由于在设计（编译）Comparator接口时，不知道它会用于哪种类型的对象比较，因此只能将compare方法的形参设计为Object类型，而实际在compare方法中需要向下转型为Circle，才能调用Circle类的getRadius()获取半径值进行比较。

使用泛型：

比较器：

package com.atguigu.generic;

import java.util.Comparator;

public class CircleComparator implements Comparator<Circle> {

@Override
public int compare(Circle o1, Circle o2) {
//不再需要强制类型转换，代码更简洁
return Double.compare(o1.getRadius(), o2.getRadius());
}

}

测试类

package com.atguigu.generic;

public class TestHasGeneric {
public static void main(String[] args) {
CircleComparator com = new CircleComparator();
System.out.println(com.compare(new Circle(1), new Circle(2)));

// System.out.println(com.compare(“圆1”, “圆2″));//编译错误，由于”圆1”, “圆2″不是Circle类型，是String类型，编译器提前报错，而不是冒着风险在运行时再报错
}
}

如果有了泛型并使用泛型，那么既能保证安全，又能简化代码。

由于把不安全的因素在编译期间就排除了；既然通过了编译，那么类型必定是符合要求的，就避免了类型转换。

1.3 泛型的相关名词

这种语法形式就叫泛型。

其中：

•是类型变量（Type Variables），而是代表未知的数据类型，我们可以指定为，，等，那么的形式我们成为类型参数；

–类比方法的参数的概念，我们可以把，称为类型形参，将称为类型实参，有助于我们理解泛型；

•Comparator这种就称为参数化类型（Parameterized Types）。

自从有了泛型之后，Java的数据类型就更丰富了：

【每日一学】泛型编程实战：Java程序员的利器

image-20200521081637509

Class：Class 类的实例表明正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有一样元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表明为 Class 对象。

•GenericArrayType：泛化的数组类型，即T[]

•ParameterizedType：参数化类型，例如：Comparator，Comparator

•TypeVariable：类型变量，例如：Comparator中的T，Map中的K,V

•WildcardType：通配符类型，例如：Comparator等

1.4 在哪里可以声明类型变量

•声明类或接口时，在类名或接口名后面声明类型变量，我们把这样的类或接口称为泛型类或泛型接口

【修饰符】 class 类名<类型变量列表> 【extends 父类】【implements 父接口们】{

}
【修饰符】 interface 接口名<类型变量列表> 【implements 父接口们】{

}

例如：
public class ArrayList<E>
public interface Map<K,V>{
….
}

•声明方法时，在【修饰符】与返回值类型之间声明类型变量，我们把声明（是声明不是单纯的使用）了类型变量的方法称为泛型方法

【修饰符】 <类型变量列表> 返回值类型方法名(【形参列表】)【throws 异常列表】{
//…
}

例如：java.util.Arrays类中的
public static <T> List<T> asList(T… a){
….
}

2 泛型类与泛型接口

2.1 使用核心类库中的泛型类/接口

自从JDK1.5引入泛型的概念之后，对之前核心类库中的API做了很大的修改，例如：集合框架聚焦的相关接口和类、java.lang.Comparable接口、java.util.Comparator接口、Class类等等。

下面以Collection、ArrayList集合以及Iterator迭代器为例演示，泛型类与泛型接口的使用。

案例一：Collection集合相关类型

（1）创建一个Collection集合（暂时创建ArrayList集合对象），并指定泛型为

（2）添加5个[0,100)以内的整数到集合中，

（3）使用foreach遍历输出5个整数，

（4）使用集合的removeIf方法删除偶数，为Predicate接口指定泛型

（5）再使用Iterator迭代器输出剩下的元素，为Iterator接口指定泛型。

package com.atguigu.genericclass.use;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Random;
import java.util.function.Predicate;

public class TestNumber {
public static void main(String[] args) {
Collection<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);
}

coll.removeIf(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
return integer % 2 == 0;
}
});

System.out.println(“coll中删除偶数后：”);
Iterator<Integer> iterator = coll.iterator();
while(iterator.hasNext()){
Integer number = iterator.next();
System.out.println(number);
}

}
}

案例二：Comparable接口

（1）声明矩形类Rectangle，包含属性长和宽，属性私有化，提供有参构造、get/set方法、重写toString方法，提供求面积和周长的方法。

（2）矩形类Rectangle实现java.lang.Comparable接口，并指定泛型为，重写int compareTo(T t)方法，按照矩形面积比较大小，面积相等的，按照周长比较大小。

（3）在测试类中，创建Rectangle数组，并创建5个矩形对象

（4）调用Arrays的sort方法，给矩形数组排序，并显示排序前后的结果。

package com.atguigu.genericclass.use;

public class Rectangle implements Comparable<Rectangle>{
private double length;
private double width;

public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}

public double getLength() {
return length;
}

public void setLength(double length) {
this.length = length;
}

public double getWidth() {
return width;
}

public void setWidth(double width) {
this.width = width;
}

public double area(){
return length * width;
}

public double perimeter(){
return 2 * (length + width);
}

@Override
public String toString() {
return “Rectangle{“ +
“length=” + length +
“, width=” + width +
“,area =” + area() +
“,perimeter = “ + perimeter() +
'}';
}

@Override
public int compareTo(Rectangle o) {
int compare = Double.compare(area(), o.area());
return compare != 0 ? compare : Double.compare(perimeter(),o.perimeter());
}
}

package com.atguigu.genericclass.use;

import java.util.Arrays;

public class TestRectangle {
public static void main(String[] args) {
Rectangle[] arr = new Rectangle[4];
arr[0] = new Rectangle(6,2);
arr[1] = new Rectangle(4,3);
arr[2] = new Rectangle(12,1);
arr[3] = new Rectangle(5,4);

System.out.println(“排序之前：”);
for (Rectangle rectangle : arr) {
System.out.println(rectangle);
}

Arrays.sort(arr);

System.out.println(“排序之后：”);
for (Rectangle rectangle : arr) {
System.out.println(rectangle);
}
}
}

2.2 自定义泛型类与泛型接口

当我们在类或接口中定义某个成员时，该成员的相关类型是不确定的，而这个类型需要在使用这个类或接口时才可以确定，那么我们可以使用泛型。

•当某个类/接口的非静态实例变量的类型不确定，需要在创建对象或子类继承时才能确定

•当某个（些）类/接口的非静态方法的形参类型不确定，需要在创建对象或子类继承时才能确定

语法格式：

【修饰符】 class 类名<类型变量列表> 【extends 父类】【implements 父接口们】{

}
【修饰符】 interface 接口名<类型变量列表> 【extends 父接口们】{

}

注意：

•：可以是一个或多个类型变量，一般都是使用单个的大写字母表明。例如：、等。

•中的类型变量不能用于静态成员上。

示例代码：

例如：我们要声明一个学生类，该学生包含姓名、成绩，而此时学生的成绩类型不确定，为什么呢，由于，语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”，数学老师希望成绩是89.5, 65.0，英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时，就可以使用泛型。

package com.atguigu.genericclass.define;

public class Student<T>{
private String name;
private T score;

public Student() {
super();
}
public Student(String name, T score) {
super();
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public T getScore() {
return score;
}
public void setScore(T score) {
this.score = score;
}
@Override
public String toString() {
return “姓名：” + name + “, 成绩：” + score;
}
}

2.3 使用泛型类与泛型接口小结

在使用这种参数化的类与接口时，我们需要指定泛型变量的实际类型参数：

（1）实际类型参数必须是引用数据类型，不能是基本数据类型

（2）子类继承泛型父类时，子接口继承泛型父接口、或实现类实现泛型父接口时，

•指定类型变量对应的实际类型参数，此时子类或实现类不再是泛型类

package com.atguigu.genericclass.define;

//ChineseStudent不再是泛型类
public class ChineseStudent extends Student<String>{

public ChineseStudent() {
super();
}

public ChineseStudent(String name, String score) {
super(name, score);
}

}

public class Rectangle implements Comparable<Rectangle>

•指定类型变量（该类型变量可以和原来字母一样，也可以换一个字母），此时子类、子接口、实现类依旧是泛型类或泛型接口

public interface Iterable<T>

public interface Collection<E>extends Iterable<E>

public interface List<E>extends Collection<E>

public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

（3）在创建泛型类的对象时指定类型变量对应的实际类型参数

package com.atguigu.genericclass.define;

public class TestStudent {
public static void main(String[] args) {
//语文老师使用时：
Student<String> stu1 = new Student<String>(“张三”, “良好”);
ChineseStudent chineseStudent = new ChineseStudent(“张三”, “良好”);