JavaSE——泛型

一、泛型的引入

二、泛型的好处

三、泛型介绍

四、泛型的语法

(一)泛型的声明

(二)泛型的实例化

五、泛型使用的注意事项和细节

六、泛型练习题1

七、自定义泛型

(一)自定义泛型类

(二)自定义泛型接口

(三)自定义泛型方法

八、泛型练习题2

九、泛型的继承和通配符

一、泛型的引入

使用传统的集合添加数据的时候，有以下几点弊端：

不能对加入到集合ArrayList中的数据类型进行约束(不安全)
遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

二、泛型的好处

1.编译时，检查添加元素的类型，提高了安全性

2.减少了类型转换的次数，提高效率

不使用泛型

Dog-加入->Object-取出->Dog 放入到ArrayList中会先转成Object，在取出时，还需要转换成Dog

使用泛型

Dog->Dog->Dog 放入和取出时，不需要类型转换，提高效率

3.不再提示编译警告

public class Generic01 {public static void main(String[] args) {// 做一个泛型约束ArrayList<Dog> arrayList = new ArrayList<Dog>();arrayList.add(new Dog("aa", 1));arrayList.add(new Dog("bb", 2));arrayList.add(new Dog("cc", 3));// 使用泛型遍历，不需要向下转型for (Dog dog : arrayList) {System.out.println(dog);}}
}class Dog {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}

三、泛型介绍

泛型是一种表示数据类型的数据类型。

泛型又称参数化类型，是JDK5出现的新特性，解决数据类型的安全性问题
在类声明或实例化时只要指定好需要的具体的类型即可
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
泛型的作业是：可以在类声明时通过一个标识，表示类中某个属性的类型，或者是方法的返回值的类型，或者是参数类型。
注意，特别强调： E具体的数据类型，在定义Person对象的时候指定，即在编译期间，就确定E是什么类型。

public class Generic03 {public static void main(String[] args) {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() {//返回类型使用Ereturn s;}}*/Person<Integer> person2 = new Person<Integer>(100);person2.show();//Integer/*class Person {Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型public Person(Integer s) {//E也可以是参数类型this.s = s;}public Integer f() {//返回类型使用Ereturn s;}}*/}
}// 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E> {E s; // E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型public Person(E s) { // E也可以是参数类型this.s = s;}public E f() {//返回类型使用Ereturn s;}public void show() {System.out.println(s.getClass()); // 显示s的运行类型}
}

四、泛型的语法

(一)泛型的声明

interface接口<T>{} 和 class类<K,V>{} 比如：List，ArrayList

说明：1)其中，T、K、V不代表值，而是表示类型

2)任意字母都可以。常用T表示，是Type的缩写

(二)泛型的实例化

要在类名后面指定类型参数的值(类型)。如：

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

创建3个学生对象，放入到HashSet中使用，放入到HashMap中使用，要求Key是 String name，Value 就是学生对象，使用两种方式遍历。

代码实现：

@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遍历for (Student student : students) {System.out.println(student);}System.out.println("--------------------------");// 使用泛型方式给HashMap 放入3个学生对象// K -> String V->StudentHashMap<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("tom", new Student("tom", 28));// 迭代器遍历Set<Map.Entry<String, Student>> entrySet = hm.entrySet();Iterator<Map.Entry<String, Student>> iterator = entrySet.iterator();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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

五、泛型使用的注意事项和细节

泛型类型只能是引用数据类型，不可以设置基本数据类型

List<Integer> list = new ArrayList<Integer>(); //OK
// List<int> list2 = new ArrayList<int>();//错误

在指定泛型具体类型后，可以传入该类型或其子类类型

Pig<A> aPig = new Pig<A>(new A());
aPig.f();
// class com.testdemo.generic.APig<A> aPig2 = new Pig<A>(new B());
aPig2.f();
// class com.testdemo.generic.Bclass A {}
class B extends A {}class Pig<E> {E e;public Pig(E e) {this.e = e;}public void f() {System.out.println(e.getClass()); // 运行类型}
}

泛型使用形式可以简化

ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();

不写泛型默认是 Object类型

ArrayList arrayList = new ArrayList();
// 等价于 ArrayList<Object> arrayList = new ArrayList<Object>();

六、泛型练习题1

代码实现：

MyDate类：

public class MyDate implements Comparable<MyDate> {private int year;private int month;private int day;@Overridepublic String toString() {return "MyDate{" +"year=" + year +", month=" + month +", day=" + day +'}';}public int getYear() {return year;}public void setYear(int year) {this.year = year;}public int getMonth() {return month;}public void setMonth(int month) {this.month = month;}public int getDay() {return day;}public void setDay(int day) {this.day = day;}public MyDate(int year, int month, int day) {this.year = year;this.month = month;this.day = day;}/*** 比较brithday* @param o the object to be compared.* @return*/@Overridepublic int compareTo(MyDate o) {// 比较生日int yearMinus = year - o.getYear();if (yearMinus != 0) {return yearMinus;}int monthMinus = month - o.getMonth();if (monthMinus != 0) {return monthMinus;}return day - o.getDay();}
}

Employee类：

public class Employee {private String name;private double sal;private MyDate birthday;@Overridepublic String toString() {return "Employee{" +"name='" + name + '\'' +", sal=" + sal +", birthday=" + birthday +'}';}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSal() {return sal;}public void setSal(double sal) {this.sal = sal;}public MyDate getBirthday() {return birthday;}public void setBirthday(MyDate birthday) {this.birthday = birthday;}public Employee(String name, double sal, MyDate birthday) {this.name = name;this.sal = sal;this.birthday = birthday;}
}

测试类：

public class GenericExercise02 {public static void main(String[] args) {ArrayList<Employee> employees = new ArrayList<>();Employee aa = new Employee("aa", 8000, new MyDate(1980, 2, 4));Employee bb = new Employee("张三", 9000, new MyDate(1999, 12, 24));Employee ccc = new Employee("张三", 5500, new MyDate(1999, 12, 18));employees.add(aa);employees.add(bb);employees.add(ccc);System.out.println("----------排序后：----------");for (Employee employee : employees) {System.out.println(employee);}// 排序employees.sort(new Comparator<Employee>() {@Overridepublic int compare(Employee o1, Employee o2) {if (!(o1 instanceof Employee && o2 instanceof Employee)) {System.out.println("类型不正确...");return 0;}// 比较nameint i = o1.getName().length() - o2.getName().length();if (i != 0) {return i;}return o1.getBirthday().compareTo(o2.getBirthday());}});System.out.println("----------排序后：----------");for (Employee employee : employees) {System.out.println(employee);}}
}

运行结果：

七、自定义泛型

(一)自定义泛型类

基本语法：

class 类名<T,R...>{ // ...表示多个成员
}

注意细节：

普通成员可以使用泛型 (属性、方法)

使用泛型的数组，不能初始化

静态方法中不能使用类的泛型

泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)

如果在创建对象时，没有指定类型，默认为Object

代码示例：

public class CustomGeneric_ {public static void main(String[] args) {// T=Double, R=String, M=IntegerTiger<Double, String, Integer> g = new Tiger<>("john");g.setT(10.9); // OK// g.setT("yy"); // 错误，类型不对System.out.println(g);// Tiger{name='john', r=null, m=null, t=10.9, ts=null}Tiger g2 = new Tiger("john~~"); // OK T=Object R=Object M=Objectg2.setT("yy"); // OK ,因为 T=Object "yy"=String 是Object子类System.out.println("g2=" + g2);// g2=Tiger{name='john~~', r=null, m=null, t=yy, ts=null}}
}// 1. Tiger 后面定义泛型，所以Tiger 就称为自定义泛型类
// 2. T, R, M 泛型的标识符, 一般是单个大写字母
// 3. 泛型标识符可以有多个
class Tiger<T, R, M> {String name;R r; // 属性使用到泛型M m;T t;// 因为数组在new 不能确定T的类型，就无法在内存开空间，不能new泛型数组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;}@Overridepublic String toString() {return "Tiger{" +"name='" + name + '\'' +", r=" + r +", m=" + m +", t=" + t +", ts=" + Arrays.toString(ts) +'}';}
}

(二)自定义泛型接口

基本语法：

interface 接口名<T,R...>{
}

注意细节：

接口中，静态成员也不能使用泛型(和泛型类规定相同)
泛型接口的类型，在继承接口或实现接口时确定
没有指定类型，默认为Object

代码示例：

public class CustomInterfaceGeneric {public static void main(String[] args) {}
}
// 在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {}// 当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
// 在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {@Overridepublic Double get(String s) {return null;}@Overridepublic void hi(Double aDouble) {}@Overridepublic void run(Double r1, Double r2, String u1, String u2) {}
}// 实现接口时，直接指定泛型接口的类型
// 给U 指定Integer 给 R 指定了 Float
// 所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {@Overridepublic Float get(Integer integer) {return null;}@Overridepublic void hi(Float aFloat) {}@Overridepublic void run(Float r1, Float r2, Integer u1, Integer u2) {}
}// 没有指定类型，默认为Object，建议直接写成 IUsb<Object,Object>
class CC implements IUsb { // 等价于 class CC implements IUsb<Object,Object> {@Overridepublic Object get(Object o) {return null;}@Overridepublic void hi(Object o) {}@Overridepublic void run(Object r1, Object r2, Object u1, Object 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;}
}

(三)自定义泛型方法

基本语法：

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

注意细节：

泛型方法，可以定义在普通类中，也可以定义在泛型类中
当泛型方法被调用时，类型会确定
修饰符后没有泛型，那么该方法就不是泛型方法，而是使用了泛型

代码示例：

public class CustomMethodGeneric {public static void main(String[] args) {Car car = new Car();car.fly("宝马", 100);// 当调用方法时，传入参数，编译器，就会确定类型// class java.lang.String// class java.lang.IntegerSystem.out.println("=======");car.fly(300, 100.1);// 当调用方法时，传入参数，编译器，就会确定类型// class java.lang.Integer// class java.lang.Double// 测试// T->String, R-> ArrayListFish<String, ArrayList> fish = new Fish<>();fish.hello(new ArrayList(), 11.3f);// class java.util.ArrayList// class java.lang.Float}
}// 泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car { // 普通类//普通方法public void run() {}// 说明 泛型方法// 1. <T,R> 就是泛型// 2. 是提供给 fly使用的public <T, R> void fly(T t, R r) { // 泛型方法System.out.println(t.getClass()); // StringSystem.out.println(r.getClass()); // Integer}
}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());//ArrayListSystem.out.println(k.getClass());//Float}
}

八、泛型练习题2

public class CustomMethodGenericExercise {public static void main(String[] args) {// T->String, R->Integer, M->DoubleApple<String, Integer, Double> apple = new Apple<>();apple.fly(10); // 10 会被自动装箱 Integer10, 输出Integerapple.fly(new Dog()); // Dog}
}class Apple<T, R, M> { // 自定义泛型类public <E> void fly(E e) {  // 泛型方法System.out.println(e.getClass().getSimpleName()); // 只显示类名：Integer}// public void eat(U u) {} // 错误，因为U没有声明public void run(M m) {} // ok
}
class Dog {}

九、泛型的继承和通配符

泛型不具备继承性
// List<Object> list = new ArrayList<String>(); // 错误写法，编译报错
<?>：支持任意类型泛型
<? extends A>：支持A类以及A类的子类，规定了泛型的上限
<? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

代码示例：

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);//×}// ? extends AA 表示 上限，可以接受 AA或者AA子类public static void printCollection2(List<? extends AA> c) {for (Object object : c) {System.out.println(object);}}// 说明: List<?> 表示 任意的泛型类型都可以接受public static void printCollection1(List<?> c) {for (Object object : c) { // 通配符，取出时，就是ObjectSystem.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 {}