java泛型

泛型

泛型是编程语言的一种特性，允许在定义类，接口和方法时使用参数化类型。这样你可以编写能够处理各种数据类型的通用代码，而不需要为每种数据类型都编写特定的代码。java用引用泛型，为程序员提供了一种在编译时检查类型的安全机制。

JDK1.5以后出现的机制

泛型出现的原因

早期4的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

泛型出现的好处

java中泛型的引用提高了代码的可读性，可维护性和健壮性，是程序更加安全和高效

泛型为集合框架引入类型安全性。使用泛型后，可以在编译时确保集合只包含特定类型的元素，避免了在运行时进行类型转换的需要。

泛型的书写格式

• 泛型类
  把泛型定义在类上
  格式:public class 类名<泛型类型1,…>
  注意:泛型类型必须是引用类型

  class Demo1<E> { // Demo1<String>
      //E在一个类中是唯一的。
      public void fun1(E a){ //String
          System.out.println(a);
      }
  }
  
  /*
      泛型类：在开发代码的时候，将泛型写在类上
   */
  public class FanXingDemo1 {
      public static void main(String[] args) {
          Demo1<String> stringDemo1 = new Demo1<>();
          stringDemo1.fun1("12");
      }
  }
  
  

• 泛型方法
  把泛型定义在方法上
  格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

  class Demo2{
      //泛型方法，将来调用时可以传入任意的数据类型，与类上面的泛型无关
      public <E> void fun1(E e){
          System.out.println(e);
      }
  }
  
  /*
      泛型方法：将泛型定义在方法上
   */
  public class FanXingDemo2 {
      public static void main(String[] args) {
          Demo2 demo2 = new Demo2();
          demo2.fun1("da");
          demo2.fun1(12);
          demo2.fun1(12.34);
      }
  }
  
  

• 泛型接口
  把泛型定义在接口上
  格式:public interface 接口名<泛型类型1…>

  
  interface Inter1<E>{
      void fun1(E e);
  }
  
  //如果一个类实现一个接口，这个接口有泛型的话，类定义时，也要有泛型，一般情况下与接口的泛型写法一致
  class Demo3<E> implements Inter1<E>{
      @Override
      public void fun1(E e) {
          System.out.println(e);
      }
  }
  
  /*
      泛型接口：将泛型定义在接口上
   */
  public class FanXingDemo3 {
      public static void main(String[] args) {
          Inter1<String> s = new Demo3<>();
          s.fun1("abc");
  
          /*
                  interface List<E>
                  class ArrayList<E> implements List<E>{
                      add(E e){}
                  }
           */
          List<String> list = new ArrayList<>();
          list.add("dsa");
  //        list.add(12);
  
      }
  }
  
  

泛型高级(通配符)

• 泛型通配符<?>
  任意类型，如果没有明确，那么就是Object以及任意的Java类了

• ? extends E
  向下限定，E及其子类

• ? super E
  向上限定，E及其父类

  class Animal {
  }
  
  class Dog extends Animal {
  }
  
  class Cat extends Animal {
  }
  
  class Demo4<E> { // E: Animal
      public void fun1(Collection<? super E> e) {
  
      }
  }
  
  public class FanXingDemo4 {
      public static void main(String[] args) {
  //        ArrayList<?> list1 = new ArrayList<Dog>();
  
          //向下限定
  //        ArrayList<? extends Animal> list1 = new ArrayList<Object>();
          ArrayList<Animal> list1 = new ArrayList<>();
          //E: Animal
  
          //ddAll(Collection<? extends E> c)
          // Collection<? extends E> 表示将来应该传入一个Collection集合对象，并且集合中的元素类型是E本身或者是E的子类类型
          // E: Animal
  
  //        ArrayList<Dog> list2 = new ArrayList<>();
  //        ArrayList<Cat> list3 = new ArrayList<>();
  //        ArrayList<Object> list4 = new ArrayList<>();
  //        list1.addAll(list2);
  //        list1.addAll(list3);
  //        list1.addAll(list4);
  
          // ? super E 向上限定
          Demo4<Animal> d = new Demo4<>();
          //fun1(Collection<? super E> e)
          //Collection<? super E> 表示将来应该传入一个Collection集合对象，但是集合中的元素类型只能是E的本身类型或者E的父类类型
          ArrayList<Dog> list2 = new ArrayList<>();
          ArrayList<Cat> list3 = new ArrayList<>();
          ArrayList<Object> list4 = new ArrayList<>();
  //        d.fun1(list2);
  //        d.fun1(list3);
          d.fun1(list4);
          d.fun1(list1);
  
      }
  }