找回密码
 立即注册
首页 业界区 安全 第 13 章泛型

第 13 章泛型

匡菲 2025-8-24 18:37:35
第 13 章泛型

13.1 泛型的理解和好处

13.1.1 看一个需求


  • 请编写程序,在ArrayList 中,添加3个Dog对象
  • Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
先使用传统的方法来解决 -> 引出泛型
  1. class Dog {
  2.     public String name;
  3.     public int age;
  4.     public Dog(String name, int age) {
  5.         this.name = name;
  6.         this.age = age;
  7.     }
  8.     @Override
  9.     public String toString() {
  10.         return "Dog [name=" + name + ", age=" + age + "]";
  11.     }
  12. }
复制代码
  1. public class Generic01 {
  2.     public static void main(String[] args) {
  3.         //使用传统的方法来解决
  4.         ArrayList arrayList = new ArrayList();
  5.         arrayList.add(new Dog("旺财", 10));
  6.         arrayList.add(new Dog("发财", 1));
  7.         arrayList.add(new Dog("小黄", 5));
  8.         //假如我们的程序员,不小心,添加了一只猫
  9.         arrayList.add(new Cat("招财猫", 8));
  10.         //遍历
  11.         for (Object o : arrayList) {
  12.             //向下转型Object ->Dog
  13.             Dog dog = (Dog) o;
  14.             System.out.println(dog.getName() + "-" + dog.getAge());
  15.         }
  16.     }
  17. }
  18. /*
  19. 请编写程序,在ArrayList 中,添加3个Dog对象
  20. Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
  21. */
  22. class Dog {
  23.     private String name;
  24.     private int age;
  25.     public Dog(String name, int age) {
  26.         this.name = name;
  27.         this.age = age;
  28.     }
  29.     public String getName() {
  30.         return name;
  31.     }
  32.     public void setName(String name) {
  33.         this.name = name;
  34.     }
  35.     public int getAge() {
  36.         return age;
  37.     }
  38.     public void setAge(int age) {
  39.         this.age = age;
  40.     }
  41. }
  42. class Cat { //Cat类
  43.     private String name;
  44.     private int age;
  45.     public Cat(String name, int age) {
  46.         this.name = name;
  47.         this.age = age;
  48.     }
  49.     public String getName() {
  50.         return name;
  51.     }
  52.     public void setName(String name) {
  53.         this.name = name;
  54.     }
  55.     public int getAge() {
  56.         return age;
  57.     }
  58.     public void setAge(int age) {
  59.         this.age = age;
  60.     }
  61. }
复制代码
13.1.2 使用传统方法的问题分析


  • 不能对加入到集合 ArrayList 中的数据类型进行约束(不安全)
  • 遍历的时候,需要进行类型转换,如果集合中的数据量较大,对效率有影响
13.1.3 泛型快速体验-用泛型来解决前面的问题


  1. public class Generic02 {
  2.     public static void main(String[] args) {
  3.         //使用传统的方法来解决===> 使用泛型
  4.         //解读
  5.         //1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型 (细节后面说...)
  6.         //2. 如果编译器发现添加的类型,不满足要求,就会报错
  7.         //3. 在遍历的时候,可以直接取出 Dog 类型而不是 Object
  8.         //4. public class ArrayList<E> {} E称为泛型,那么 Dog->E
  9.         ArrayList<Dog> arrayList = new ArrayList<Dog>();
  10.         arrayList.add(new Dog("旺财", 10));
  11.         arrayList.add(new Dog("发财", 1));
  12.         arrayList.add(new Dog("小黄", 5));
  13.         //假如我们的程序员,不小心,添加了一只猫
  14.         //arrayList.add(new Cat("招财猫", 8));
  15.         System.out.println("===使用泛型====");
  16.         for (Dog dog : arrayList) {
  17.             System.out.println(dog.getName() + "-" + dog.getAge());
  18.         }
  19.     }
  20. }
  21. /*
  22. 1.请编写程序,在ArrayList 中,添加3个Dog对象
  23. 2.Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
  24. 3.老师使用泛型来完成代码
  25. */
  26. class Dog {
  27.     private String name;
  28.     private int age;
  29.     public Dog(String name, int age) {
  30.         this.name = name;
  31.         this.age = age;
  32.     }
  33.     public String getName() {
  34.         return name;
  35.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  39.     public int getAge() {
  40.         return age;
  41.     }
  42.     public void setAge(int age) {
  43.         this.age = age;
  44.     }
  45. }
  46. class Cat { //Cat类
  47.     private String name;
  48.     private int age;
  49.     public Cat(String name, int age) {
  50.         this.name = name;
  51.         this.age = age;
  52.     }
  53.     public String getName() {
  54.         return name;
  55.     }
  56.     public void setName(String name) {
  57.         this.name = name;
  58.     }
  59.     public int getAge() {
  60.         return age;
  61.     }
  62.     public void setAge(int age) {
  63.         this.age = age;
  64.     }
  65. }
复制代码
13.2 泛型的理解和好处

13.2.1 泛型的好处


  • 编译时,检查添加元素的类型,提高了安全性
  • 减少了类型转换的次数,提高效率

    • 不使用泛型:Dog -> Object(放入 ArrayList 转成 Object )→ 取出时转成 Dog
    • 使用泛型:Dog -> Dog(放入、取出无需类型转换 )

  • 不再提示编译警告
13.3 泛型介绍

主讲人:韩顺平老师
韩顺平循序渐进 Java 零基础
  1. int a = 10;
复制代码
老韩理解:泛(广泛)型(类型)→ Integer、String、Dog

  • 泛型又称参数化类型,是 JDK5.0 出现的新特性,解决数据类型的安全性问题
  • 在类声明或实例化时只需指定好需要的具体类型即可
  • Java 泛型可以保证:编译时没警告,运行时就不会产生 ClassCastException 异常。同时,代码更加简洁、健壮
  • 泛型的作用:类声明时,通过标识表示类中属性、方法返回值、参数的类型
  1. public class Generic03 {
  2.     public static void main(String[] args) {
  3.         //注意,特别强调: E具体的数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
  4.         Person<String> person = new Person<String>("韩顺平教育");
  5.         person.show(); //String
  6.         /*
  7.             你可以这样理解,上面的Person类
  8.             class Person {
  9.                 String s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
  10.                 public Person(String s) {//E也可以是参数类型
  11.                     this.s = s;
  12.                 }
  13.                 public String f() {//返回类型使用E
  14.                     return s;
  15.                 }
  16.             }
  17.          */
  18.         Person<Integer> person2 = new Person<Integer>(100);
  19.         person2.show();//Integer
  20.         /*
  21.             class Person {
  22.                 Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
  23.                 public Person(Integer s) {//E也可以是参数类型
  24.                     this.s = s;
  25.                 }
  26.                 public Integer f() {//返回类型使用E
  27.                     return s;
  28.                 }
  29.             }
  30.          */
  31.     }
  32. }
  33. //泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型,
  34. // 或者是某个方法的返回值的类型,或者是参数类型
  35. class Person<E> {
  36.     E s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
  37.     public Person(E s) {//E也可以是参数类型
  38.         this.s = s;
  39.     }
  40.     public E f() {//返回类型使用E
  41.         return s;
  42.     }
  43.     public void show() {
  44.         System.out.println(s.getClass());//显示s的运行类型
  45.     }
  46. }
复制代码
13.4 泛型的语法

13.4.1 泛型的声明
  1. interface 接口<T>{}  
  2. class 类<K,V>{}  
  3. // 比如: List,ArrayList  
复制代码
说明:

  • 其中,T、K、V 不代表值,而是表示类型
  • 任意字母都可以。常用 T 表示,是 Type 的缩写
13.4.2 泛型的实例化

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

  • List strList = new ArrayList();
  • Iterator iterator = customers.iterator();
13.4.3 泛型使用举例

举例说明,泛型在 HashSet、HashMap 的使用情况,演示 GenericExercise.java
练习:

  • 创建 3 个学生对象
  • 放入到 HashSet 中学生对象,使用
  • 放入到 HashMap 中,要求 Key 是 String name,Value 是学生对象
  • 使用两种方式遍历
  1. public class GenericExercise {
  2.     public static void main(String[] args) {
  3.         //使用泛型方式给HashSet 放入3个学生对象
  4.         HashSet<Student> students = new HashSet<Student>();
  5.         students.add(new Student("jack", 18));
  6.         students.add(new Student("tom", 28));
  7.         students.add(new Student("mary", 19));
  8.         //遍历
  9.         for (Student student : students) {
  10.             System.out.println(student);
  11.         }
  12.         //使用泛型方式给HashMap 放入3个学生对象
  13.         //K -> String V->Student
  14.         HashMap<String, Student> hm = new HashMap<String, Student>();
  15.         /*
  16.             public class HashMap<K,V>  {}
  17.          */
  18.         hm.put("milan", new Student("milan", 38));
  19.         hm.put("smith", new Student("smith", 48));
  20.         hm.put("hsp", new Student("hsp", 28));
  21.         //迭代器 EntrySet
  22.         /*
  23.         public Set<Map.Entry<K,V>> entrySet() {
  24.             Set<Map.Entry<K,V>> es;
  25.             return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
  26.         }
  27.          */
  28.         Set<Map.Entry<String, Student>> entries = hm.entrySet();
  29.         /*
  30.             public final Iterator<Map.Entry<K,V>> iterator() {
  31.                 return new EntryIterator();
  32.             }
  33.          */
  34.         Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
  35.         System.out.println("==============================");
  36.         while (iterator.hasNext()) {
  37.             Map.Entry<String, Student> next =  iterator.next();
  38.             System.out.println(next.getKey() + "-" + next.getValue());
  39.             
  40.         }
  41.     }
  42. }
  43. /**
  44. * 创建  3个学生对象
  45. * 放入到HashSet中学生对象, 使用.
  46. * 放入到  HashMap中,要求 Key 是 String name, Value 就是 学生对象
  47. * 使用两种方式遍历
  48. */
  49. class Student {
  50.     private String name;
  51.     private int age;
  52.     public Student(String name, int age) {
  53.         this.name = name;
  54.         this.age = age;
  55.     }
  56.     public String getName() {
  57.         return name;
  58.     }
  59.     public void setName(String name) {
  60.         this.name = name;
  61.     }
  62.     public int getAge() {
  63.         return age;
  64.     }
  65.     public void setAge(int age) {
  66.         this.age = age;
  67.     }
  68.     @Override
  69.     public String toString() {
  70.         return "Student{" +
  71.                 "name='" + name + '\'' +
  72.                 ", age=" + age +
  73.                 '}';
  74.     }
  75. }
复制代码
13.4.4 泛型使用的注意事项和细节

GenericDetail.java

  • 接口/类泛型限制(如 interface List{}、public class HashSet{} )

    • 说明:T、E 只能是引用类型
    • 示例:
      1. List<Integer> list = new ArrayList<Integer>(); // OK  
      2. List<int> list2 = new ArrayList<int>(); // 错误  
      复制代码

  • 给泛型指定具体类型后,可传入该类型或其子类类型
  • 泛型使用形式
    1. List<Integer> list1 = new ArrayList<Integer>();  
    2. List<Integer> list2 = new ArrayList<>(); // 菱形语法(JDK7+)  
    复制代码
  • 若直接写 List list3 = new ArrayList();

    • 默认泛型是  E = Object

  1. public class GenericDetail {
  2.     public static void main(String[] args) {
  3.         //1.给泛型指向数据类型是,要求是引用类型,不能是基本数据类型
  4.         List<Integer> list = new ArrayList<Integer>(); //OK
  5.         //List<int> list2 = new ArrayList<int>();//错误
  6.         //2. 说明
  7.         //因为 E 指定了 A 类型, 构造器传入了 new A()
  8.         //在给泛型指定具体类型后,可以传入该类型或者其子类类型
  9.         Pig aPig = new Pig(new A());
  10.         aPig.f();
  11.         Pig aPig2 = new Pig(new B());
  12.         aPig2.f();
  13.         //3. 泛型的使用形式
  14.         ArrayList<Integer> list1 = new ArrayList<Integer>();
  15.         List<Integer> list2 = new ArrayList<Integer>();
  16.         //在实际开发中,我们往往简写
  17.         //编译器会进行类型推断, 老师推荐使用下面写法
  18.         ArrayList<Integer> list3 = new ArrayList<>();
  19.         List<Integer> list4 = new ArrayList<>();
  20.         ArrayList<Pig> pigs = new ArrayList<>();
  21.         //4. 如果是这样写 泛型默认是 Object
  22.         ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
  23.         /*
  24.             public boolean add(Object e) {
  25.                 ensureCapacityInternal(size + 1);  // Increments modCount!!
  26.                 elementData[size++] = e;
  27.                 return true;
  28.             }
  29.          */
  30.         Tiger tiger = new Tiger();
  31.         /*
  32.             class Tiger {//类
  33.                 Object e;
  34.                 public Tiger() {}
  35.                 public Tiger(Object e) {
  36.                     this.e = e;
  37.                 }
  38.             }
  39.          */
  40.     }
  41. }
  42. class Tiger<E> {//类
  43.     E e;
  44.     public Tiger() {}
  45.     public Tiger(E e) {
  46.         this.e = e;
  47.     }
  48. }
  49. class A {}
  50. class B extends A {}
  51. class Pig<E> {//
  52.     E e;
  53.     public Pig(E e) {
  54.         this.e = e;
  55.     }
  56.     public void f() {
  57.         System.out.println(e.getClass()); //运行类型
  58.     }
  59. }
复制代码
13.5 泛型课堂类型

13.5.1 泛型课堂练习题

定义 Employee 类

  • 包含:private 成员变量 name、sal、birthday(birthday 为 MyDate 类的对象 )
  • 为每个属性定义 getter、setter 方法
  • 重写 toString 方法,输出 name、sal、birthday
MyDate 类要求:

  • 包含:private 成员变量 month、day、year
  • 为每个属性定义 getter、setter 方法
步骤:

  • 创建 3 个 Employee 对象,放入泛型定义的 ArrayList 集合中
  • 对集合元素排序并遍历输出
排序方式:
调用 ArrayList 的 sort 方法,传入 Comparator 对象(使用泛型),规则:

  • 先按 name 排序
  • name 相同时,按生日日期先后排序
  1. public class GenericExercise02 {
  2.     public static void main(String[] args) {
  3.         ArrayList<Employee> employees = new ArrayList<>();
  4.         employees.add(new Employee("tom", 20000, new MyDate(1980,12,11)));
  5.         employees.add(new Employee("jack", 12000, new MyDate(2001,12,12)));
  6.         employees.add(new Employee("tom", 50000, new MyDate(1980,12,10)));
  7.         System.out.println("employees=" + employees);
  8.         employees.sort(new Comparator<Employee>() {
  9.             @Override
  10.             public int compare(Employee emp1, Employee emp2) {
  11.                 //先按照name排序,如果name相同,则按生日日期的先后排序。【即:定制排序】
  12.                 //先对传入的参数进行验证
  13.                 if(!(emp1 instanceof  Employee && emp2 instanceof Employee)) {
  14.                     System.out.println("类型不正确..");
  15.                     return 0;
  16.                 }
  17.                 //比较name
  18.                 int i = emp1.getName().compareTo(emp2.getName());
  19.                 if(i != 0) {
  20.                     return i;
  21.                 }
  22.                 //下面是对birthday的比较,因此,我们最好把这个比较,放在MyDate类完成
  23.                 //封装后,将来可维护性和复用性,就大大增强.
  24.                 return emp1.getBirthday().compareTo(emp2.getBirthday());
  25.             }
  26.         });
  27.         System.out.println("==对雇员进行排序==");
  28.         System.out.println(employees);
  29.     }
  30. }
  31. /**
  32. * 定义Employee类
  33. * 1) 该类包含:private成员变量name,sal,birthday,其中 birthday 为 MyDate 类的对象;
  34. * 2) 为每一个属性定义 getter, setter 方法;
  35. * 3) 重写 toString 方法输出 name, sal, birthday
  36. * 4) MyDate类包含: private成员变量month,day,year;并为每一个属性定义 getter, setter 方法;
  37. * 5) 创建该类的 3 个对象,并把这些对象放入 ArrayList 集合中(ArrayList 需使用泛型来定义),对集合中的元素进行排序,并遍历输出:
  38. *
  39. * 排序方式: 调用ArrayList 的 sort 方法 ,
  40. * 传入 Comparator对象[使用泛型],先按照name排序,如果name相同,则按生日日期的先后排序。【即:定制排序】
  41. * 有一定难度 15min , 比较经典 泛型使用案例 GenericExercise02.java
  42. */
复制代码
  1. public class MyDate implements Comparable<MyDate>{
  2.     private int year;
  3.     private int month;
  4.     private int day;
  5.     public MyDate(int year, int month, int day) {
  6.         this.year = year;
  7.         this.month = month;
  8.         this.day = day;
  9.     }
  10.     public int getYear() {
  11.         return year;
  12.     }
  13.     public void setYear(int year) {
  14.         this.year = year;
  15.     }
  16.     public int getMonth() {
  17.         return month;
  18.     }
  19.     public void setMonth(int month) {
  20.         this.month = month;
  21.     }
  22.     public int getDay() {
  23.         return day;
  24.     }
  25.     public void setDay(int day) {
  26.         this.day = day;
  27.     }
  28.     @Override
  29.     public String toString() {
  30.         return "MyDate{" +
  31.                 "year=" + year +
  32.                 ", month=" + month +
  33.                 ", day=" + day +
  34.                 '}';
  35.     }
  36.     @Override
  37.     public int compareTo(MyDate o) { //把对year-month-day比较放在这里
  38.         int yearMinus = year - o.getYear();
  39.         if(yearMinus != 0) {
  40.             return  yearMinus;
  41.         }
  42.         //如果year相同,就比较month
  43.         int monthMinus = month - o.getMonth();
  44.         if(monthMinus != 0) {
  45.             return monthMinus;
  46.         }
  47.         //如果year 和 month
  48.         return day - o.getDay();
  49.     }
  50. }
复制代码
13.6 自定义泛型

13.6.1 自定义泛型类(难度)

基本语法
  1. class 类名<T, R...> { //...表示可以有多个泛型  
  2.     成员  
  3. }  
复制代码
注意细节


  • 普通成员(属性、方法)可以使用泛型
  • 使用泛型的数组,不能初始化
  • 静态方法中不能使用类的泛型(泛型类的泛型在创建对象时确定,静态方法加载早于对象创建 )
  • 泛型类的类型,在创建对象时确定(需指定具体类型 )
  • 创建对象时未指定类型,默认按 Object 处理
应用案例 CustomeGeneric.java
  1. class Tiger<T, R, M> {  
  2.     String name;  
  3.     R r;  
  4.     M m;  
  5.     T t;  
  6. }  
复制代码
  1. public class CustomGeneric_ {
  2.     public static void main(String[] args) {
  3.         //T=Double, R=String, M=Integer
  4.         Tiger<Double,String,Integer> g = new Tiger<>("john");
  5.         g.setT(10.9); //OK
  6.         //g.setT("yy"); //错误,类型不对
  7.         System.out.println(g);
  8.         Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
  9.         g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
  10.         System.out.println("g2=" + g2);
  11.     }
  12. }
  13. //解读
  14. //1. Tiger 后面泛型,所以我们把 Tiger 就称为自定义泛型类
  15. //2, T, R, M 泛型的标识符, 一般是单个大写字母
  16. //3. 泛型标识符可以有多个.
  17. //4. 普通成员可以使用泛型 (属性、方法)
  18. //5. 使用泛型的数组,不能初始化
  19. //6. 静态方法中不能使用类的泛型
  20. class Tiger<T, R, M> {
  21.     String name;
  22.     R r; //属性使用到泛型
  23.     M m;
  24.     T t;
  25.     //因为数组在new 不能确定T的类型,就无法在内存开空间
  26.     T[] ts;
  27.     public Tiger(String name) {
  28.         this.name = name;
  29.     }
  30.     public Tiger(R r, M m, T t) {//构造器使用泛型
  31.         this.r = r;
  32.         this.m = m;
  33.         this.t = t;
  34.     }
  35.     public Tiger(String name, R r, M m, T t) {//构造器使用泛型
  36.         this.name = name;
  37.         this.r = r;
  38.         this.m = m;
  39.         this.t = t;
  40.     }
  41.     //因为静态是和类相关的,在类加载时,对象还没有创建
  42.     //所以,如果静态方法和静态属性使用了泛型,JVM就无法完成初始化
  43. //    static R r2;
  44. //    public static void m1(M m) {
  45. //
  46. //    }
  47.     //方法使用泛型
  48.     public String getName() {
  49.         return name;
  50.     }
  51.     public void setName(String name) {
  52.         this.name = name;
  53.     }
  54.     public R getR() {
  55.         return r;
  56.     }
  57.     public void setR(R r) {//方法使用到泛型
  58.         this.r = r;
  59.     }
  60.     public M getM() {//返回类型可以使用泛型.
  61.         return m;
  62.     }
  63.     public void setM(M m) {
  64.         this.m = m;
  65.     }
  66.     public T getT() {
  67.         return t;
  68.     }
  69.     public void setT(T t) {
  70.         this.t = t;
  71.     }
  72.     @Override
  73.     public String toString() {
  74.         return "Tiger{" +
  75.                 "name='" + name + '\'' +
  76.                 ", r=" + r +
  77.                 ", m=" + m +
  78.                 ", t=" + t +
  79.                 ", ts=" + Arrays.toString(ts) +
  80.                 '}';
  81.     }
  82. }
复制代码
13.6.2 自定义泛型接口

基本语法
  1. interface 接口名<T, R...> {  
  2.     //...  
  3. }  
复制代码
注意细节


  • 接口中静态成员不能使用泛型(同泛型类规则 )
  • 泛型接口的类型,在继承/实现接口时确定
  • 未指定类型时,默认按 Object 处理
应用实例 CustomInterfaceGeneric.java
  1. interface IUsb<U, R> {  
  2.     R get(U u);  
  3.     void hi(R r1, R r2, U u1, U u2);  
  4.     default R method(U u) {  
  5.         return null;  
  6.     }  
  7. }  
  8. class C implements IUsb {}  
  9. class A implements IUsb<String, Integer> {}  
  10. interface MyInterface extends IUsb<String, Integer> {}  
  11. class D implements MyInterface {}  
复制代码
  1. public class CustomInterfaceGeneric {
  2.     public static void main(String[] args) {
  3.     }
  4. }
  5. /**
  6. *  泛型接口使用的说明
  7. *  1. 接口中,静态成员也不能使用泛型
  8. *  2. 泛型接口的类型, 在继承接口或者实现接口时确定
  9. *  3. 没有指定类型,默认为Object
  10. */
  11. //在继承接口 指定泛型接口的类型
  12. interface IA extends IUsb<String, Double> {
  13. }
  14. //当我们去实现IA接口时,因为IA在继承IUsu 接口时,指定了U 为String R为Double
  15. //,在实现IUsu接口的方法时,使用String替换U, 是Double替换R
  16. class AA implements IA {
  17.     @Override
  18.     public Double get(String s) {
  19.         return null;
  20.     }
  21.     @Override
  22.     public void hi(Double aDouble) {
  23.     }
  24.     @Override
  25.     public void run(Double r1, Double r2, String u1, String u2) {
  26.     }
  27. }
  28. //实现接口时,直接指定泛型接口的类型
  29. //给U 指定Integer 给 R 指定了 Float
  30. //所以,当我们实现IUsb方法时,会使用Integer替换U, 使用Float替换R
  31. class BB implements IUsb<Integer, Float> {
  32.     @Override
  33.     public Float get(Integer integer) {
  34.         return null;
  35.     }
  36.     @Override
  37.     public void hi(Float aFloat) {
  38.     }
  39.     @Override
  40.     public void run(Float r1, Float r2, Integer u1, Integer u2) {
  41.     }
  42. }
  43. //没有指定类型,默认为Object
  44. //建议直接写成 IUsb<Object,Object>
  45. class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
  46.     @Override
  47.     public Object get(Object o) {
  48.         return null;
  49.     }
  50.     @Override
  51.     public void hi(Object o) {
  52.     }
  53.     @Override
  54.     public void run(Object r1, Object r2, Object u1, Object u2) {
  55.     }
  56. }
  57. interface IUsb<U, R> {
  58.     int n = 10;
  59.     //U name; 不能这样使用
  60.     //普通方法中,可以使用接口泛型
  61.     R get(U u);
  62.     void hi(R r);
  63.     void run(R r1, R r2, U u1, U u2);
  64.     //在jdk8 中,可以在接口中,使用默认方法, 也是可以使用泛型
  65.     default R method(U u) {
  66.         return null;
  67.     }
  68. }
复制代码
13.6.3 自定义泛型方法

基本语法
  1. 修饰符 <T, R...> 返回类型 方法名(参数列表) {  
  2.     //...  
  3. }  
复制代码
注意细节


  • 泛型方法可定义在普通类、泛型类
  • 泛型方法被调用时,类型由传入参数确定
  • 如 public void eat(E e)(无  修饰符 ),不是泛型方法,只是使用了泛型
应用案例 CustomMethodGeneric.java
  1. class Bird<T, R, M> {  
  2.     public <E> void fly(E e) {  
  3.         System.out.println(e);  
  4.     }  
  5. }  
  6. class Fish {  
  7.     public  A show(A a) {  
  8.         System.out.println("a的值: " + a);  
  9.         System.out.println("a的类型: " + a.getClass().getSimpleName());  
  10.         return a;  
  11.     }  
  12. }  
复制代码
  1. public class CustomMethodGeneric {
  2.     public static void main(String[] args) {
  3.         Car car = new Car();
  4.         car.fly("宝马", 100);//当调用方法时,传入参数,编译器,就会确定类型
  5.         System.out.println("=======");
  6.         car.fly(300, 100.1);//当调用方法时,传入参数,编译器,就会确定类型
  7.         //测试
  8.         //T->String, R-> ArrayList
  9.         Fish<String, ArrayList> fish = new Fish<>();
  10.         fish.hello(new ArrayList(), 11.3f);
  11.     }
  12. }
  13. //泛型方法,可以定义在普通类中, 也可以定义在泛型类中
  14. class Car {//普通类
  15.     public void run() {//普通方法
  16.     }
  17.     //说明 泛型方法
  18.     //1. <T,R> 就是泛型
  19.     //2. 是提供给 fly使用的
  20.     public <T, R> void fly(T t, R r) {//泛型方法
  21.         System.out.println(t.getClass());//String
  22.         System.out.println(r.getClass());//Integer
  23.     }
  24. }
  25. class Fish<T, R> {//泛型类
  26.     public void run() {//普通方法
  27.     }
  28.     public<U,M> void eat(U u, M m) {//泛型方法
  29.     }
  30.     //说明
  31.     //1. 下面hi方法不是泛型方法
  32.     //2. 是hi方法使用了类声明的 泛型
  33.     public void hi(T t) {
  34.     }
  35.     //泛型方法,可以使用类声明的泛型,也可以使用自己声明泛型
  36.     public<K> void hello(R r, K k) {
  37.         System.out.println(r.getClass());//ArrayList
  38.         System.out.println(k.getClass());//Float
  39.     }
  40. }
复制代码
13.6.4 自定义泛型方法(课堂练习)

题目:CustomMethodGenericExercise.java(2min)
  1. class Apple<T, R, M> { // 自定义泛型类  
  2.     public <E> void fly(E e) { // 泛型方法  
  3.         System.out.println(e.getClass().getSimpleName());  
  4.     }  
  5.     public void eat(U u) {} // 错误:U 未声明  
  6.     public void run(M m) {} // ok  
  7. }  
  8. class Dog {}  
  9. // 输出什么?  
  10. Apple<String, Integer, Double> apple = new Apple<>();  
  11. apple.fly(10);  
  12. apple.fly(new Dog());  
复制代码
分析


  • eat(U u) 错误:方法未声明泛型 <U>,需改为 public <U> void eat(U u)
  • 调用 fly(10) → 输出 Integer(10 是 Integer 类型 )
  • 调用 fly(new Dog()) → 输出 Dog
  1. public class CustomMethodGenericExercise {
  2.     public static void main(String[] args) {
  3.         //T->String, R->Integer, M->Double
  4.         Apple<String, Integer, Double> apple = new Apple<>();
  5.         apple.fly(10);//10 会被自动装箱 Integer10, 输出Integer
  6.         apple.fly(new Dog());//Dog
  7.     }
  8. }
  9. class Apple<T, R, M> {//自定义泛型类
  10.     public <E> void fly(E e) {  //泛型方法
  11.         System.out.println(e.getClass().getSimpleName());
  12.     }
  13.     //public void eat(U u) {}//错误,因为U没有声明
  14.     public void run(M m) {
  15.     } //ok
  16. }
  17. class Dog {
  18. }
复制代码
13.7 泛型的继承和通配符

13.7.1 泛型的继承和通配符说明 GenericExtends.java

<ol>泛型不具备继承性

  • 示例:List list = new ArrayList(); → 错误(编译不通过 )
:支持任意泛型类型
<strong> c ,可以接受任意的泛型类型        printCollection1(list1);        printCollection1(list2);        printCollection1(list3);        printCollection1(list4);        printCollection1(list5);        //List 表示 任意的泛型类型都可以接受    public static void printCollection1(List c) {        for (Object object : c) { // 通配符,取出时,就是Object            System.out.println(object);        }    }    // ? super 子类类名AA:支持AA类以及AA类的父类,不限于直接父类,    //规定了泛型的下限    public static void printCollection3(List
您需要登录后才可以回帖 登录 | 立即注册