java--泛型--类型通配符

标签：override   通配   ati   实现   种类型   stat   具体类   继承   必须   

1. 什么是类型通配符
   1. 

   2. package com.model.fanxing;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/30 23:46
       * 演示类型通配符
       */
      public class FanXingDemo07 {
      
          public static void main(String[] args) {
              Boss<String> boss = new Boss<>();
              boss.setName("张紫韩");
              get(boss);
              Boss<Integer> boss1 = new Boss<>();
              boss1.setName(100);
              get(boss1);
              /**
               * 当泛型类做形参时，必须为泛型类指定具体的类型，而指定具体类型后，我们只当传入一种类型的参数，则不能实现多种类型的调用
               * 即：public static void get(Boss<String> boss){ 当泛型类对象做参数时，必须指定具体的类型，（不能用E，T代替）
               * 指定了String类型的Boss泛型类，
               * 我们只能传入String的类型的泛型类的参数，当我们想传入Integer类型的泛型参数时，是错误的
               * 为解决这一问题引入了 泛型通配符 ？ ：即可以传入任意具体类型的泛型类对象
               * */
          }
      //    public static void get(Boss<String> boss){
      //        System.out.println(boss.getName());
      //    }
            public static void get(Boss<?> boss){
                System.out.println(boss.getName());
            }
      }
      
      class Boss<E>{
          private E name;
      
          public void setName(E name) {
              this.name = name;
          }
      
          public E getName() {
              return name;
          }
      }

       

2. 类型通配符的上限

   1. 

   2.  

      package com.model.fanxing;
      
      import java.util.ArrayList;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/7/1 10:45
       */
      public class FanXingDemo08 {
          public static void main(String[] args) {
      //        1.上限测试
              ArrayList<One> list1 = new ArrayList<>();
              ArrayList<Two> list2 = new ArrayList<>();
              ArrayList<Three> list3 = new ArrayList<>();
              list1.add(new One());
              list1.add(new One());
              list1.add(new One());
              list1.add(new One());
              list2.add(new Two());
              list2.add(new Two());
              list2.add(new Two());
              list2.add(new Two());
              list3.add(new Three());
              list3.add(new Three());
              list3.add(new Three());
              list3.add(new Three());
      //        testOne(list1);
              testOne(list2);
              testOne(list3);
          //        boss1 不可以，boss2和boss3可以当作参数传入
              Boss<One> boss1 = new Boss<>();
              Boss<Two> boss2 = new Boss<>();
              Boss<Three> boss3 = new Boss<>();
      //        testOne(boss1);
              testOne(boss2);
              testOne(boss3);
      
      //        2.下限测试,Boss1可以因为Boss1中传入的泛型标识类是Boss2中传入的父类
              testTwo(boss1);
              testTwo(boss2);
      //        testTwo(boss3);
      
      
      
          }
      //    上限测试，传入的参数又要求，传入泛型的参数必须是继承自Two类
          public static void testOne(ArrayList<? extends Two> list){
      
          }
          public static void testOne(Boss<? extends Two> boss){
              //只有当创建Boss类时
              // 传入的是Two类或者是Two类的子类才能当作参数传入此方法
      
          }
      //    下限测试，传入泛型类的泛型标识类，必须是two类的父类
          public static void testTwo(Boss<? super Two> boss){ //要求人Boss泛型类的换入的参数是 Two的父类后者是Two本身才能传入
      //      当作参数
          }
      }
      
      class One{
      
      }
      class Two extends One{
      
      }
      class Three extends Two{
      
      }

       

3. 类型通配符的下限
   1. 

   2. package com.model.fanxing;
      
      import java.util.ArrayList;
      import java.util.Comparator;
      import java.util.TreeSet;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/7/1 11:16
       */
      public class FanXingDemo09 {
          public static void main(String[] args) {
              /**
               *     public TreeSet(Comparator<? super E> comparator) {
               *         this(new TreeMap<>(comparator));
               *     }
               * */
              //已经知道，Tree的构造哦方法可以传入Comparator<? super E>,传入Comparator接口
      
              Comparator1 comparator1 = new Comparator1();
              Comparator2 comparator2 = new Comparator2();
              Comparator3 comparator3 = new Comparator3();
              TreeSet<B> treeSet1 = new TreeSet<>(comparator1); //按名字比较
              TreeSet<B> treeSet2 = new TreeSet<>(comparator2); //按年领比较
      //        TreeSet<B> treeSet3 = new TreeSet<>(comparator3); //传入的比较器泛型类型不能是B类的子类，所以不能按照Comparator3比器进行比较
      // TreeSet传入的泛型标识是B，而Comparator3比较传入的C并非是B类的父类
              treeSet1.add(new B("a", 18));
              treeSet1.add(new B("b", 19));
              treeSet1.add(new B("c", 20));
              treeSet1.add(new B("d", 10));
              for (B tree:treeSet1){
                  System.out.println(tree.toString());
              }
              treeSet2.add(new B("a", 18));
              treeSet2.add(new B("b", 19));
              treeSet2.add(new B("c", 20));
              treeSet2.add(new B("d", 10));
              for (B tree:treeSet2){
                  System.out.println(tree.toString());
              }
      
          }
          public static void show(TreeSet<? super B> treeSet){
      //        下限 约束可以添加元素，且只能添加B和B的子类不能添加B的父类
              treeSet.add(new C("a", 18, "男"));
      //        treeSet.add(new A("a"));
              treeSet.add(new B("a", 18));
      
          }
      }
      //定义Comparator接口实现类
      class Comparator1 implements Comparator<A> {
          @Override
          public int compare(A o1, A o2) {
              return o1.getName().compareTo(o2.getName());
          }
      }
      class Comparator2 implements Comparator<B> {
          @Override
          public int compare(B o1, B o2) {
              return o1.getAge().compareTo(o2.getAge()); //只能引用类型的，不能比较基本数据类型
          }
      }
      class Comparator3 implements Comparator<C> {
          @Override
          public int compare(C o1,C o2) {
              return o1.getSex().compareTo(o2.getSex());
          }
      }
      
      class A{
          public String name;
      
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public A(String name) {
              this.name = name;
          }
      
          @Override
          public String toString() {
              return "A{" +
                      "name=‘" + name + ‘\‘‘ +
                      ‘}‘;
          }
      }
      
      class B extends A{
          private Integer age;
      
          public Integer getAge() {
              return age;
          }
      
          public void setAge(Integer age) {
              this.age = age;
          }
      
          public B(String name, Integer age) {
              super(name);
              this.age = age;
          }
      
          @Override
          public String toString() {
              return "B{" +
                      "name=‘" + name + ‘\‘‘ +
                      ", age=" + age +
                      ‘}‘;
          }
      }
      
      class C extends B{
          private String sex;
      
          public String getSex() {
              return sex;
          }
      
          public void setSex(String sex) {
              this.sex = sex;
          }
      
          @Override
          public String toString() {
              return "C{" +
                      "sex=‘" + sex + ‘\‘‘ +
                      ‘}‘;
          }
      
          public C(String name, int age, String sex) {
              super(name, age);
              this.sex = sex;
      
          }
      
      }

       

       

java--泛型--类型通配符

标签：override   通配   ati   实现   种类型   stat   具体类   继承   必须   

原文地址：https://www.cnblogs.com/zzhAylm/p/14957028.html