自定义泛型，自定义泛型接口，自定义泛型方法，JUnit，

1. class 类名{成员}//...表示可以有多个泛型
2. 因义的为静态是和类相关的，在类加载时，对象还没有创建，
   泛型是对象创建的时候定
   所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
3. 注意事项

   package com.jshedu.generic;
   
   
   import java.util.Arrays;
   
   /**
    * @author 韩顺平
    * @version 1.0
    */
   @SuppressWarnings({"all"})
   public class CustomGeneric_ {
       public static void main(String[] args) {
   
           //T=Double, R=String, M=Integer
           Tiger g = new Tiger<>("john");
           
           g.setT(10.9); //OK
           //g.setT("yy"); //错误，类型不对,T是Double类型
           System.out.println(g);
           Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
           g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
           System.out.println("g2=" + g2);
   
       }
   }
   
   //老韩解读
   //1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
   //2, T, R, M 泛型的标识符, 一般是单个大写字母
   //3. 泛型标识符可以有多个.
   //4. 普通成员可以使用泛型 (属性、方法)
   //5. 使用泛型的数组，不能初始化
   //6. 静态方法中不能使用类的泛型
   class Tiger {
       //static int age;
       String name;
       R r; //属性使用到泛型
       M m;
       T t;
       //因为数组在new 不能确定T的类型，就无法在内存开空间
       T[] ts;
   
       public Tiger(String name) {
           this.name = name;
       }
   
       public Tiger(R r, M m, T t) {//构造器使用泛型
   
           this.r = r;
           this.m = m;
           this.t = t;
       }
   
       public Tiger(String name, R r, M m, T t) {//构造器使用泛型
           this.name = name;
           this.r = r;
           this.m = m;
           this.t = t;
       }
   
       //因为静态是和类相关的，在类加载时，对象还没有创建，
       //泛型是对象创建的时候定义的
       //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
   //    static R r2;
   //    public static void m1(M m) {
   //
   //    }
   
       //方法使用泛型
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public R getR() {
           return r;
       }
   
       public void setR(R r) {//方法使用到泛型
           this.r = r;
       }
   
       public M getM() {//返回类型可以使用泛型.
           return m;
       }
   
       public void setM(M m) {
           this.m = m;
       }
   
       public T getT() {
           return t;
       }
   
       public void setT(T t) {
           this.t = t;
       }
   
       @Override
       public String toString() {
           return "Tiger{" +
                   "name='" + name + '\'' +
                   ", r=" + r +
                   ", m=" + m +
                   ", t=" + t +
                   ", ts=" + Arrays.toString(ts) +
                   '}';
       }
   }
   
   

   注意自定义泛型的大写字母代表的是什么类型，没有指定类型就是Object，

4. interface 接口名{成员}//...表示可以有多个泛型

   1. package com.jshedu.generic;
      
      /**
       * @author 韩顺平
       * @version 1.0
       */
      public class CustomInterfaceGeneric {
          public static void main(String[] args) {
      
          }
      }
      
      /**
       *  泛型接口使用的说明
       *  1. 接口中，静态成员也不能使用泛型
       *  2. 泛型接口的类型, 在继承接口或者实现接口时确定
       *  3. 没有指定类型，默认为Object
       */
      
      //在继承接口 指定泛型接口的类型
      interface IA extends IUsb {
      
      }
      //当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
      //，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
      class AA implements IA {
      
          @Override
          public Double get(String s) {
              return null;
          }
          @Override
          public void hi(Double aDouble) {
      
          }
          @Override
          public void run(Double r1, Double r2, String u1, String u2) {
      
          }
      }
      
      //实现接口时，直接指定泛型接口的类型
      //给U 指定Integer 给 R 指定了 Float
      //所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
      class BB implements IUsb {
      
          @Override
          public Float get(Integer integer) {
              return null;
          }
      
          @Override
          public void hi(Float aFloat) {
      
          }
      
          @Override
          public void run(Float r1, Float r2, Integer u1, Integer u2) {
      
          }
      }
      //没有指定类型，默认为Object
      //建议直接写成 IUsb
      class CC implements IUsb { //等价 class CC implements IUsb {
          @Override
          public Object get(Object o) {
              return null;
          }
          @Override
          public void hi(Object o) {
          }
          @Override
          public void run(Object r1, Object r2, Object u1, Object u2) {
      
          }
      
      }
      
      interface IUsb {
      
          int n = 10;
          //U name; 不能这样使用
      
          //普通方法中，可以使用接口泛型
          R get(U u);
      
          void hi(R r);
      
          void run(R r1, R r2, U u1, U u2);
      
          //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
          default R method(U u) {
              return null;
          }
      }
      
      
      

5. 自定义泛型方法

   1. package com.jshedu.generic;
      
      import java.util.ArrayList;
      
      /**
       * @author 韩顺平
       * @version 1.0
       * 泛型方法的使用
       */
      @SuppressWarnings({"all"})
      public class CustomMethodGeneric {
          public static void main(String[] args) {
              Car car = new Car();
              car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
              System.out.println("=======");
              car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型
      
              //测试
              //T->String, R-> ArrayList
              Fish fish = new Fish<>();
              fish.hello(new ArrayList(), 11.3f);
          }
      }
      
      //泛型方法，可以定义在普通类中, 也可以定义在泛型类中
      class Car {//普通类
      
          public void run() {//普通方法
          }
          //说明 泛型方法
          //1.  就是泛型
          //2. 是提供给 fly使用的
          public  void fly(T t, R r) {//泛型方法
              System.out.println(t.getClass());//String
              System.out.println(r.getClass());//Integer
          }
      }
      
      class Fish {//泛型类
          public void run() {//普通方法
          }
          public void eat(U u, M m) {//泛型方法
      
          }
          //说明
          //1. 下面hi方法不是泛型方法
          //2. 是hi方法使用了类声明的 泛型
          public void hi(T t) {
          }
          //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
          public void hello(R r, K k) {
              System.out.println(r.getClass());//ArrayList
              System.out.println(k.getClass());//Float
          }
      
      }
      

      注意格式

6. 例题

   package com.hspedu.customgeneric;
   
   /**
    * @author 韩顺平
    * @version 1.0
    */
   public class CustomMethodGenericExercise {
       public static void main(String[] args) {
           //T->String, R->Integer, M->Double
           Apple apple = new Apple<>();
           apple.fly(10);//10 会被自动装箱 Integer10, 输出Integer
           apple.fly(new Dog());//Dog
   
       }
   }
   
   class Apple {//自定义泛型类
   
       public  void fly(E e) {  //泛型方法
           System.out.println(e.getClass().getSimpleName());
       }
   
       //public void eat(U u) {}//错误，因为U没有声明
       public void run(M m) {
       } //ok
   }
   
   class Dog {
   }
   
   
   
   

   注意字母代表的什么类型

7. 泛型的继承和通配符

   1. package com.hspedu;
      
      import java.util.ArrayList;
      import java.util.List;
      
      /**
       * @author 韩顺平
       * @version 1.0
       * 泛型的继承和通配符
       */
      public class GenericExtends {
          public static void main(String[] args) {
      
              Object o = new String("xx");
      
              //泛型没有继承性
              //List