16.泛型

1. 泛型

1.1 泛型概述

• 泛型的介绍

  Java泛型是JAVASE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。

• 泛型的好处

  1. 提高了Java程序的类型安全，将运行期的类型转换异常提前到编译期
  2. 避免了强制类型转换

• 泛型的定义格式

  • <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如:
  • <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>

1.2 泛型类

• 定义格式

  修饰符 class 类名<类型> {  }

• 示例代码

  • 泛型类

  public class Generic<T> {
      private T t;
  
      public T getT() {
          return t;
      }
  
      public void setT(T t) {
          this.t = t;
      }
  }

  • 测试类

  public class GenericDemo1 {
      public static void main(String[] args) {
          Generic<String> g1 = new Generic<String>();
          g1.setT("bigData");
          System.out.println(g1.getT());
  
          Generic<Integer> g2 = new Generic<Integer>();
          g2.setT(30);
          System.out.println(g2.getT());
  
          Generic<Boolean> g3 = new Generic<Boolean>();
          g3.setT(true);
          System.out.println(g3.getT());
      }
  }

1.3 泛型方法

• 定义格式

  修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }

• 示例代码

  • 带有泛型方法的类

  public class Generic {
      public <T> void show(T t) {
          System.out.println(t);
      }
  }

  • 测试类

  public class GenericDemo2 {
      public static void main(String[] args) {
          Generic g = new Generic();
          g.show("bigDate");
          g.show(30);
          g.show(true);
          g.show(12.34);
      }
  }

1.4 泛型接口

• 定义格式

  修饰符 interface 接口名<类型> {  }

• 示例代码

  • 泛型接口

  public interface Generic<T> {
      void show(T t);
  }

  • 泛型接口实现类1

  ​ 定义实现类时,定义和接口相同泛型,创建实现类对象时明确泛型的具体类型

  public class GenericImpl1<T> implements Generic<T> {
      @Override
      public void show(T t) {
          System.out.println(t);
      }
  }

  • 泛型接口实现类2

  ​ 定义实现类时,直接明确泛型的具体类型

  public class GenericImpl2 implements Generic<Integer>{
       @Override
       public void show(Integer t) {
            System.out.println(t);
       }
  }

  • 测试类

  public class GenericDemo3 {
      public static void main(String[] args) {
          GenericImpl1<String> g1 = new GenericImpl<String>();
          g1.show("bigDate");
          GenericImpl1<Integer> g2 = new GenericImpl<Integer>();
          g2.show(30);
  
          GenericImpl2 g3 = new GenericImpl2();
          g3.show(10);
      }
  }
  

1.5 泛型通配符

通配符 ? 即占位符的意思，也就是在使用期间是无法确定其类型的，只有在将来实际使用时再指明类型，它有三种形式：

• <?> 无限定的通配符。是让泛型能够接受未知类型的数据
• < ? extends E>有上限的通配符。能接受指定类及其子类类型的数据，E就是该泛型的上边界
• <? super E>有下限的通配符。能接受指定类及其父类类型的数据，E就是该泛型的下边界

有上限的通配符示例：

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

        ArrayList<Father> list1 = new ArrayList<>();
        testBounds(list1);

        ArrayList<Son> list2 = new ArrayList<>();
        testBounds(list2);

        ArrayList<Daughter> list3 = new ArrayList<>();
        testBounds(list3);

        ArrayList<Mother> list4 = new ArrayList<>();
        // 代码报错，因为Mother类并不是Father的子类
        // testBounds(list4);
    }

    // 泛型方法
    public static <T> void testBounds(ArrayList<? extends Father> list) {

    }
}

class Father {}

class Son extends Father {}

class Daughter extends Father {}

class Mother {}

有下限的通配符示例：

public class Test {
    public static void main(String[] args) {
        ArrayList<Father> list1 = new ArrayList<>();
        testBounds(list1);

        ArrayList<GrandFather> list2 = new ArrayList<>();
        testBounds(list2);

        ArrayList<Son> list3 = new ArrayList<>();
        // 代码报错 因为Son类是Father的子类
        // testBounds(list3);
    }

    // 泛型方法
    public static <T> void testBounds(ArrayList<? super Father> list) {

    }
}

class GrandFather { }

class Father extends GrandFather { }

class Son extends Father { }