java--泛型--泛型接口&泛型方法

Posted 2021-07-01 张紫韩

1. 泛型接口
   1. 

   2. 

   3.   

      package com.model.fanxing;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/30 22:14
       * 泛型接口和实现类
       * 1.泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类的反省表示中要包含 泛型接口的泛型标识
       * 2.泛型接口的实现类，不是一个泛型类是，要保证泛型接口的泛型标识要指定具体的 类型，否则泛型接口的实现类会报错
       * 为什么子类的和父类的泛型类型标识要一样呢，我们创建子类对象是，需要现创建父类对象，我们会为子类指定具体的泛型类型，
       * 这是如果子类和父类的泛型类型不一致时，父类无法的得到具体的类型，就无法创建具体的实例对象，无法创建父类对象，就无法创建子类对象
       *
       * */
      public class FanXingDemo05 {
          public static void main(String[] args) {
              Chile chile = new Chile();
              System.out.println(chile.getValue());
      
              ChileOne<String> strChileOne = new ChileOne<>();
              strChileOne.setName("张紫韩");
              System.out.println(strChileOne.getValue());
          }
      }
      //泛型接口
      interface Parent<T>{
          public T getValue();
      }
      //泛型接口的实现类
      class Chile implements  Parent<String>{
          @Override
          public String getValue() {
              return "张紫韩";
          }
      }
      //泛型接口的实现类（实现了是泛型类）
      class ChileOne<T> implements Parent<T>{
          private T name;
      
          public ChileOne() {
      
          }
      
          @Override
          public T getValue() {
              return name;
          }
      
          public void setName(T name) {
              this.name = name;
          }
      
          public ChileOne(T name) {
              this.name = name;
          }
      }　　

2. 泛型方法
   1. 

   2. 

   3. 

   4. 

   5.  

       

      package com.model.fanxing;
      
      import java.util.ArrayList;
      import java.util.List;
      import java.util.Random;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/30 23:03
       * 演示泛型方法的使用
       * 泛型方法和泛型类没有关系，当泛型类中标识类和泛型方法的标识类中有相同的标识符时，他们直接也不会相互影响，即泛型类指定的类型，
       * 于泛型方法指定的类型是两码事，他们事不会相互影响，泛型方法脱离泛型类的控制
       *
       * 泛型方法的返回值可以时泛型方法指定的任意类型，而泛型类中的成员方法返回的只能是类中指定的泛型类型
       * 泛型方法可以是静态的，泛型类中的成员方法不能是静态的
       *
       * 泛型方法支持静态的
       * 支持可变参数的泛型方法
       *
       */
      public class FanXingDemo06 {
          public static void main(String[] args) {
              Product<String> product = new Product<>();
              product.add("a");
              product.add("b");
              product.add("c");
              product.add("d");
              System.out.println(product.getProduct());
      
              ArrayList<Integer> list = new ArrayList<>();
              list.add(100);
              list.add(200);
              list.add(300);
              list.add(400);
              System.out.println(product.getProduct02(list));
              ArrayList<String> strList = new ArrayList<>();
              strList.add("a");
              strList.add("b");
              strList.add("c");
              strList.add("d");
              System.out.println(product.getProduct02(strList));
      
      //        静态的泛型方法的调用
              System.out.println(Product.getProduct04(strList));
      //        可变参数的泛型方法的调用
              product.get(1,2,3,4,5,6);
              product.get("a","b","c","d");
      
          }
      }
      class Product<E>{
          private E product;
      
          List<E> list=new ArrayList<>();
          public void add(E product){
              list.add(product);
          }
          public E getProduct(){
             product=list.get(new Random().nextInt(list.size()));
             return product;
          }
          public <T> T getProduct02(ArrayList<T> list2){ //泛型方法有标识符列表 <E,T>,且只有标识列表中有的标识符，返回值和参数中才能用
      
              return list2.get(new Random().nextInt(list2.size()));
          }
          public <E> E getProduct03(ArrayList<E> list3){ //泛型方法有标识符列表 <E,T>
      
              return list3.get(new Random().nextInt(list3.size()));
          }
      
      //    静态的泛型方法
          public static <E> E getProduct04(ArrayList<E> list4){ //泛型方法有标识符列表 <E,T>,
      
              return list4.get(new Random().nextInt(list4.size()));
          }
      
      //    可变参数的泛型方法
          public <E> void get(E... e){
              for (E v:e){
                  System.out.println(v);
              }
          }
      }