第 13 章泛型
13.1 泛型的理解和好处
13.1.1 看一个需求
- 请编写程序,在ArrayList 中,添加3个Dog对象
- Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
先使用传统的方法来解决 -> 引出泛型- class Dog {
- public String name;
- public int age;
- public Dog(String name, int age) {
- this.name = name;
- this.age = age;
- }
- @Override
- public String toString() {
- return "Dog [name=" + name + ", age=" + age + "]";
- }
- }
复制代码- public class Generic01 {
- public static void main(String[] args) {
- //使用传统的方法来解决
- ArrayList arrayList = new ArrayList();
- arrayList.add(new Dog("旺财", 10));
- arrayList.add(new Dog("发财", 1));
- arrayList.add(new Dog("小黄", 5));
- //假如我们的程序员,不小心,添加了一只猫
- arrayList.add(new Cat("招财猫", 8));
- //遍历
- for (Object o : arrayList) {
- //向下转型Object ->Dog
- Dog dog = (Dog) o;
- System.out.println(dog.getName() + "-" + dog.getAge());
- }
- }
- }
- /*
- 请编写程序,在ArrayList 中,添加3个Dog对象
- Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
- */
- 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;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- }
- class Cat { //Cat类
- private String name;
- private int age;
- public Cat(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;
- }
- }
复制代码 13.1.2 使用传统方法的问题分析
- 不能对加入到集合 ArrayList 中的数据类型进行约束(不安全)
- 遍历的时候,需要进行类型转换,如果集合中的数据量较大,对效率有影响
13.1.3 泛型快速体验-用泛型来解决前面的问题
- public class Generic02 {
- public static void main(String[] args) {
- //使用传统的方法来解决===> 使用泛型
- //解读
- //1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型 (细节后面说...)
- //2. 如果编译器发现添加的类型,不满足要求,就会报错
- //3. 在遍历的时候,可以直接取出 Dog 类型而不是 Object
- //4. public class ArrayList<E> {} E称为泛型,那么 Dog->E
- ArrayList<Dog> arrayList = new ArrayList<Dog>();
- arrayList.add(new Dog("旺财", 10));
- arrayList.add(new Dog("发财", 1));
- arrayList.add(new Dog("小黄", 5));
- //假如我们的程序员,不小心,添加了一只猫
- //arrayList.add(new Cat("招财猫", 8));
- System.out.println("===使用泛型====");
- for (Dog dog : arrayList) {
- System.out.println(dog.getName() + "-" + dog.getAge());
- }
- }
- }
- /*
- 1.请编写程序,在ArrayList 中,添加3个Dog对象
- 2.Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
- 3.老师使用泛型来完成代码
- */
- 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;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- }
- class Cat { //Cat类
- private String name;
- private int age;
- public Cat(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;
- }
- }
复制代码 13.2 泛型的理解和好处
13.2.1 泛型的好处
- 编译时,检查添加元素的类型,提高了安全性
- 减少了类型转换的次数,提高效率
- 不使用泛型:Dog -> Object(放入 ArrayList 转成 Object )→ 取出时转成 Dog
- 使用泛型:Dog -> Dog(放入、取出无需类型转换 )
- 不再提示编译警告
13.3 泛型介绍
主讲人:韩顺平老师
韩顺平循序渐进 Java 零基础老韩理解:泛(广泛)型(类型)→ Integer、String、Dog
- 泛型又称参数化类型,是 JDK5.0 出现的新特性,解决数据类型的安全性问题
- 在类声明或实例化时只需指定好需要的具体类型即可
- Java 泛型可以保证:编译时没警告,运行时就不会产生 ClassCastException 异常。同时,代码更加简洁、健壮
- 泛型的作用:类声明时,通过标识表示类中属性、方法返回值、参数的类型
- public class Generic03 {
- public static void main(String[] args) {
- //注意,特别强调: E具体的数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
- 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() {//返回类型使用E
- return 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() {//返回类型使用E
- return s;
- }
- }
- */
- }
- }
- //泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型,
- // 或者是某个方法的返回值的类型,或者是参数类型
- class Person<E> {
- E s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
- public Person(E s) {//E也可以是参数类型
- this.s = s;
- }
- public E f() {//返回类型使用E
- return s;
- }
- public void show() {
- System.out.println(s.getClass());//显示s的运行类型
- }
- }
复制代码 13.4 泛型的语法
13.4.1 泛型的声明
- interface 接口<T>{}
- class 类<K,V>{}
- // 比如: 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 是学生对象
- 使用两种方式遍历
- 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 (Student student : students) {
- System.out.println(student);
- }
- //使用泛型方式给HashMap 放入3个学生对象
- //K -> String V->Student
- HashMap<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("hsp", new Student("hsp", 28));
- //迭代器 EntrySet
- /*
- public Set<Map.Entry<K,V>> entrySet() {
- Set<Map.Entry<K,V>> es;
- return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
- }
- */
- Set<Map.Entry<String, Student>> entries = hm.entrySet();
- /*
- public final Iterator<Map.Entry<K,V>> iterator() {
- return new EntryIterator();
- }
- */
- Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
- System.out.println("==============================");
- while (iterator.hasNext()) {
- Map.Entry<String, Student> next = iterator.next();
- System.out.println(next.getKey() + "-" + next.getValue());
-
- }
- }
- }
- /**
- * 创建 3个学生对象
- * 放入到HashSet中学生对象, 使用.
- * 放入到 HashMap中,要求 Key 是 String name, Value 就是 学生对象
- * 使用两种方式遍历
- */
- class Student {
- private String name;
- private int age;
- public Student(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;
- }
- @Override
- public String toString() {
- return "Student{" +
- "name='" + name + '\'' +
- ", age=" + age +
- '}';
- }
- }
复制代码 13.4.4 泛型使用的注意事项和细节
GenericDetail.java
- 接口/类泛型限制(如 interface List{}、public class HashSet{} )
- 说明:T、E 只能是引用类型
- 示例:
- List<Integer> list = new ArrayList<Integer>(); // OK
- List<int> list2 = new ArrayList<int>(); // 错误
复制代码
- 给泛型指定具体类型后,可传入该类型或其子类类型
- 泛型使用形式
- List<Integer> list1 = new ArrayList<Integer>();
- List<Integer> list2 = new ArrayList<>(); // 菱形语法(JDK7+)
复制代码 - 若直接写 List list3 = new ArrayList();
- public class GenericDetail {
- public static void main(String[] args) {
- //1.给泛型指向数据类型是,要求是引用类型,不能是基本数据类型
- List<Integer> list = new ArrayList<Integer>(); //OK
- //List<int> list2 = new ArrayList<int>();//错误
- //2. 说明
- //因为 E 指定了 A 类型, 构造器传入了 new A()
- //在给泛型指定具体类型后,可以传入该类型或者其子类类型
- Pig aPig = new Pig(new A());
- aPig.f();
- Pig aPig2 = new Pig(new B());
- aPig2.f();
- //3. 泛型的使用形式
- ArrayList<Integer> list1 = new ArrayList<Integer>();
- List<Integer> list2 = new ArrayList<Integer>();
- //在实际开发中,我们往往简写
- //编译器会进行类型推断, 老师推荐使用下面写法
- ArrayList<Integer> list3 = new ArrayList<>();
- List<Integer> list4 = new ArrayList<>();
- ArrayList<Pig> pigs = new ArrayList<>();
- //4. 如果是这样写 泛型默认是 Object
- ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
- /*
- public boolean add(Object e) {
- ensureCapacityInternal(size + 1); // Increments modCount!!
- elementData[size++] = e;
- return true;
- }
- */
- Tiger tiger = new Tiger();
- /*
- class Tiger {//类
- Object e;
- public Tiger() {}
- public Tiger(Object e) {
- this.e = e;
- }
- }
- */
- }
- }
- class Tiger<E> {//类
- E e;
- public Tiger() {}
- public Tiger(E e) {
- this.e = e;
- }
- }
- class 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()); //运行类型
- }
- }
复制代码 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 相同时,按生日日期先后排序
- public class GenericExercise02 {
- public static void main(String[] args) {
- ArrayList<Employee> employees = new ArrayList<>();
- employees.add(new Employee("tom", 20000, new MyDate(1980,12,11)));
- employees.add(new Employee("jack", 12000, new MyDate(2001,12,12)));
- employees.add(new Employee("tom", 50000, new MyDate(1980,12,10)));
- System.out.println("employees=" + employees);
- employees.sort(new Comparator<Employee>() {
- @Override
- public int compare(Employee emp1, Employee emp2) {
- //先按照name排序,如果name相同,则按生日日期的先后排序。【即:定制排序】
- //先对传入的参数进行验证
- if(!(emp1 instanceof Employee && emp2 instanceof Employee)) {
- System.out.println("类型不正确..");
- return 0;
- }
- //比较name
- int i = emp1.getName().compareTo(emp2.getName());
- if(i != 0) {
- return i;
- }
- //下面是对birthday的比较,因此,我们最好把这个比较,放在MyDate类完成
- //封装后,将来可维护性和复用性,就大大增强.
- return emp1.getBirthday().compareTo(emp2.getBirthday());
- }
- });
- System.out.println("==对雇员进行排序==");
- System.out.println(employees);
- }
- }
- /**
- * 定义Employee类
- * 1) 该类包含:private成员变量name,sal,birthday,其中 birthday 为 MyDate 类的对象;
- * 2) 为每一个属性定义 getter, setter 方法;
- * 3) 重写 toString 方法输出 name, sal, birthday
- * 4) MyDate类包含: private成员变量month,day,year;并为每一个属性定义 getter, setter 方法;
- * 5) 创建该类的 3 个对象,并把这些对象放入 ArrayList 集合中(ArrayList 需使用泛型来定义),对集合中的元素进行排序,并遍历输出:
- *
- * 排序方式: 调用ArrayList 的 sort 方法 ,
- * 传入 Comparator对象[使用泛型],先按照name排序,如果name相同,则按生日日期的先后排序。【即:定制排序】
- * 有一定难度 15min , 比较经典 泛型使用案例 GenericExercise02.java
- */
复制代码- public class MyDate implements Comparable<MyDate>{
- private int year;
- private int month;
- private int day;
- public MyDate(int year, int month, int day) {
- this.year = year;
- this.month = month;
- this.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;
- }
- @Override
- public String toString() {
- return "MyDate{" +
- "year=" + year +
- ", month=" + month +
- ", day=" + day +
- '}';
- }
- @Override
- public int compareTo(MyDate o) { //把对year-month-day比较放在这里
- int yearMinus = year - o.getYear();
- if(yearMinus != 0) {
- return yearMinus;
- }
- //如果year相同,就比较month
- int monthMinus = month - o.getMonth();
- if(monthMinus != 0) {
- return monthMinus;
- }
- //如果year 和 month
- return day - o.getDay();
- }
- }
复制代码 13.6 自定义泛型
13.6.1 自定义泛型类(难度)
基本语法
- class 类名<T, R...> { //...表示可以有多个泛型
- 成员
- }
复制代码 注意细节
- 普通成员(属性、方法)可以使用泛型
- 使用泛型的数组,不能初始化
- 静态方法中不能使用类的泛型(泛型类的泛型在创建对象时确定,静态方法加载早于对象创建 )
- 泛型类的类型,在创建对象时确定(需指定具体类型 )
- 创建对象时未指定类型,默认按 Object 处理
应用案例 CustomeGeneric.java
- class Tiger<T, R, M> {
- String name;
- R r;
- M m;
- T t;
- }
复制代码- public class CustomGeneric_ {
- public static void main(String[] args) {
- //T=Double, R=String, M=Integer
- Tiger<Double,String,Integer> g = new Tiger<>("john");
- g.setT(10.9); //OK
- //g.setT("yy"); //错误,类型不对
- System.out.println(g);
- Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
- g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
- System.out.println("g2=" + g2);
- }
- }
- //解读
- //1. Tiger 后面泛型,所以我们把 Tiger 就称为自定义泛型类
- //2, T, R, M 泛型的标识符, 一般是单个大写字母
- //3. 泛型标识符可以有多个.
- //4. 普通成员可以使用泛型 (属性、方法)
- //5. 使用泛型的数组,不能初始化
- //6. 静态方法中不能使用类的泛型
- class Tiger<T, R, M> {
- String name;
- R r; //属性使用到泛型
- M m;
- T t;
- //因为数组在new 不能确定T的类型,就无法在内存开空间
- 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;
- }
- @Override
- public String toString() {
- return "Tiger{" +
- "name='" + name + '\'' +
- ", r=" + r +
- ", m=" + m +
- ", t=" + t +
- ", ts=" + Arrays.toString(ts) +
- '}';
- }
- }
复制代码 13.6.2 自定义泛型接口
基本语法
- interface 接口名<T, R...> {
- //...
- }
复制代码 注意细节
- 接口中静态成员不能使用泛型(同泛型类规则 )
- 泛型接口的类型,在继承/实现接口时确定
- 未指定类型时,默认按 Object 处理
应用实例 CustomInterfaceGeneric.java
- interface IUsb<U, R> {
- R get(U u);
- void hi(R r1, R r2, U u1, U u2);
- default R method(U u) {
- return null;
- }
- }
- class C implements IUsb {}
- class A implements IUsb<String, Integer> {}
- interface MyInterface extends IUsb<String, Integer> {}
- class D implements MyInterface {}
复制代码- public class CustomInterfaceGeneric {
- public static void main(String[] args) {
- }
- }
- /**
- * 泛型接口使用的说明
- * 1. 接口中,静态成员也不能使用泛型
- * 2. 泛型接口的类型, 在继承接口或者实现接口时确定
- * 3. 没有指定类型,默认为Object
- */
- //在继承接口 指定泛型接口的类型
- interface IA extends IUsb<String, Double> {
- }
- //当我们去实现IA接口时,因为IA在继承IUsu 接口时,指定了U 为String R为Double
- //,在实现IUsu接口的方法时,使用String替换U, 是Double替换R
- class AA implements IA {
- @Override
- public Double get(String s) {
- return null;
- }
- @Override
- public void hi(Double aDouble) {
- }
- @Override
- public 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> {
- @Override
- public Float get(Integer integer) {
- return null;
- }
- @Override
- public void hi(Float aFloat) {
- }
- @Override
- public void run(Float r1, Float r2, Integer u1, Integer u2) {
- }
- }
- //没有指定类型,默认为Object
- //建议直接写成 IUsb<Object,Object>
- class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
- @Override
- public Object get(Object o) {
- return null;
- }
- @Override
- public void hi(Object o) {
- }
- @Override
- public 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;
- }
- }
复制代码 13.6.3 自定义泛型方法
基本语法
- 修饰符 <T, R...> 返回类型 方法名(参数列表) {
- //...
- }
复制代码 注意细节
- 泛型方法可定义在普通类、泛型类中
- 泛型方法被调用时,类型由传入参数确定
- 如 public void eat(E e)(无 修饰符 ),不是泛型方法,只是使用了泛型
应用案例 CustomMethodGeneric.java
- class Bird<T, R, M> {
- public <E> void fly(E e) {
- System.out.println(e);
- }
- }
- class Fish {
- public A show(A a) {
- System.out.println("a的值: " + a);
- System.out.println("a的类型: " + a.getClass().getSimpleName());
- return a;
- }
- }
复制代码- public class CustomMethodGeneric {
- public static void main(String[] args) {
- Car car = new Car();
- car.fly("宝马", 100);//当调用方法时,传入参数,编译器,就会确定类型
- System.out.println("=======");
- car.fly(300, 100.1);//当调用方法时,传入参数,编译器,就会确定类型
- //测试
- //T->String, R-> ArrayList
- Fish<String, ArrayList> fish = new Fish<>();
- fish.hello(new ArrayList(), 11.3f);
- }
- }
- //泛型方法,可以定义在普通类中, 也可以定义在泛型类中
- class Car {//普通类
- public void run() {//普通方法
- }
- //说明 泛型方法
- //1. <T,R> 就是泛型
- //2. 是提供给 fly使用的
- public <T, R> void fly(T t, R r) {//泛型方法
- System.out.println(t.getClass());//String
- System.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());//ArrayList
- System.out.println(k.getClass());//Float
- }
- }
复制代码 13.6.4 自定义泛型方法(课堂练习)
题目:CustomMethodGenericExercise.java(2min)
- class Apple<T, R, M> { // 自定义泛型类
- public <E> void fly(E e) { // 泛型方法
- System.out.println(e.getClass().getSimpleName());
- }
- public void eat(U u) {} // 错误:U 未声明
- public void run(M m) {} // ok
- }
- class Dog {}
- // 输出什么?
- Apple<String, Integer, Double> apple = new Apple<>();
- apple.fly(10);
- apple.fly(new Dog());
复制代码 分析
- eat(U u) 错误:方法未声明泛型 <U>,需改为 public <U> void eat(U u)
- 调用 fly(10) → 输出 Integer(10 是 Integer 类型 )
- 调用 fly(new Dog()) → 输出 Dog
- public class CustomMethodGenericExercise {
- public static void main(String[] args) {
- //T->String, R->Integer, M->Double
- Apple<String, Integer, Double> apple = new Apple<>();
- apple.fly(10);//10 会被自动装箱 Integer10, 输出Integer
- apple.fly(new Dog());//Dog
- }
- }
- class Apple<T, R, M> {//自定义泛型类
- public <E> void fly(E e) { //泛型方法
- System.out.println(e.getClass().getSimpleName());
- }
- //public void eat(U u) {}//错误,因为U没有声明
- public void run(M m) {
- } //ok
- }
- class Dog {
- }
复制代码 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 |