泛型的通配符

泛型的继承

●泛型不具备继承性,但是数据具备继承性

public class GenericsDemo5 {
    public static void main(String[] args) {

        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();


        // method(list1);
        // method(list2);//报错
        // method(list3);//报错

        list1.add(new Ye());
        list1.add(new Fu());
        list1.add(new Zi());

    }
    //此时，泛型里面写的是什么类型，那么只能传递什么类型的数据。
    public static void method(ArrayList<Ye> list){

    }

}

class Ye{}
class Fu extends Ye{}
class Zi extends Fu{}

希望:本方法虽然不确定类型，但是以后我希望只能传递指定类型

此时我们就可以使用泛型的通配符:

?也表示不确定的类型，他可以进行类型的限定

? extends E:表示可以传递E或者E所有的子类类型

? supler E:表示可以传递E或者E所有的父类类型

public class GenericsDemo5 {
    public static void main(String[] args) {

        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();


         method(list1);
         method(list2);
         method(list3);

    }

    public static void method(ArrayList<? super Zi> list){

    }

}

class Ye{}
class Fu extends Ye{}
class Zi extends Fu{}

应用场景:

1.如果我们在定义类、方法、接口的时候，如果类型不确定，就可以定义泛型类、泛型方法、泛型接口。2.如果类型不确定，但是能知道以后只能传递某个继承体系中的，就可以泛型的通配符

泛型的通配符:

关键点:可以限定类型的范围。

通配符综合练习代码：

动物类

public abstract class Animal {
    private String name;
    private int age;

    public Animal(){
    }

    public Animal(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;
    }

    public abstract void eat();

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

猫
public abstract class Cat extends Animal{
   public Cat(String name,int age){
        super(name, age);
    }


    //1.继承抽象类，重写里面的所有抽象方法
    //2.本身Cat也是一个抽象的，让Cat的子类重写重写方法

    //采取第二种方法
    //因为猫的两个子类中的eat的方法还是不一样的
}

狗
public abstract class Dog extends Animal{
}

public class HuskyDog extends Dog{
    @Override
    public void eat() {
        System.out.println("一只叫"+getName()+"的，"+getAge()+"岁的哈士奇，正在吃骨头，边吃边拆家");
    }
}

public class TedyDog extends Dog{
    @Override
    public void eat() {
        System.out.println("一只叫"+getName()+"的，"+getAge()+"岁的泰迪，正在吃骨头，边吃边蹭");
    }
}

public class PersianCat extends Cat{
    public PersianCat(String name,int age){
        super(name,age);
    }



    @Override
    public void eat() {
        System.out.println("一只叫"+getName()+"的，"+getAge()+"岁的波斯猫，正在吃小饼干");
    }
}

public class LiHuaCat extends Cat{
    public LiHuaCat(String name,int age){
        super(name,age);
    }


    @Override
    public void eat() {
        System.out.println("一只叫"+getName()+"的，"+getAge()+"岁的狸花猫，正在吃鱼");
    }
}

测试
public class Test1 {
    public static void main(String[] args) {

       ArrayList<PersianCat> list1 = new ArrayList<>();
        ArrayList<LiHuaCat> list2 = new ArrayList<>();
        ArrayList<TedyDog> list3 = new ArrayList<>();
        ArrayList<HuskyDog> list4 = new ArrayList<>();

       list1.add(new PersianCat("小花",10));
       list2.add(new LiHuaCat("小白",11));

        keePet(list1);
        keePet(list2);


       // keePet(list3);
       // keePet(list4);
    }

   /* //该方法能养所有动物，但不能传递其他类型
    public static void keePet(ArrayList<? extends Animal> list){
        //遍历集合，调用动物eat方法
    }

    */

  /*  //该方法能养所有品种的狗，但是不能养猫
    public static void keePet(ArrayList<? extends Dog> list){

    }

   */

    //该方法能养所有品种的猫，但是不能养狗
    public static void keePet(ArrayList<? extends Cat> list){
        for (Cat cat : list) {
            cat.eat();
        }
    }


}