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=IntegerTiger<Double,String,Integer> 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=Objectg2.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<T, R, M> {//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;}@Overridepublic String toString() {return "Tiger{" +"name='" + name + '\'' +", r=" + r +", m=" + m +", t=" + t +", ts=" + Arrays.toString(ts) +'}';}
}

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

interface 接口名<T,R....>{成员}//...表示可以有多个泛型

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<String, Double> {}
   //当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
   //，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
   class AA implements IA {@Overridepublic Double get(String s) {return null;}@Overridepublic void hi(Double aDouble) {}@Overridepublic void run(Double r1, Double r2, String u1, String u2) {}
   }//实现接口时，直接指定泛型接口的类型
   //给U 指定Integer 给 R 指定了 Float
   //所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
   class BB implements IUsb<Integer, Float> {@Overridepublic Float get(Integer integer) {return null;}@Overridepublic void hi(Float aFloat) {}@Overridepublic void run(Float r1, Float r2, Integer u1, Integer u2) {}
   }
   //没有指定类型，默认为Object
   //建议直接写成 IUsb<Object,Object>
   class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {@Overridepublic Object get(Object o) {return null;}@Overridepublic void hi(Object o) {}@Overridepublic void run(Object r1, Object r2, Object u1, Object u2) {}}interface IUsb<U, R> {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;}
   }

自定义泛型方法

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-> ArrayListFish<String, ArrayList> fish = new Fish<>();fish.hello(new ArrayList(), 11.3f);}
   }//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
   class Car {//普通类public void run() {//普通方法}//说明 泛型方法//1. <T,R> 就是泛型//2. 是提供给 fly使用的public <T, R> void fly(T t, R r) {//泛型方法System.out.println(t.getClass());//StringSystem.out.println(r.getClass());//Integer}
   }class Fish<T, R> {//泛型类public void run() {//普通方法}public<U,M> void eat(U u, M m) {//泛型方法}//说明//1. 下面hi方法不是泛型方法//2. 是hi方法使用了类声明的 泛型public void hi(T t) {}//泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型public<K> void hello(R r, K k) {System.out.println(r.getClass());//ArrayListSystem.out.println(k.getClass());//Float}}
   

   注意格式

例题

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

注意字母代表的什么类型

泛型的继承和通配符

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<Object> list = new ArrayList<String>();//举例说明下面三个方法的使用List<Object> list1 = new ArrayList<>();List<String> list2 = new ArrayList<>();List<AA> list3 = new ArrayList<>();List<BB> list4 = new ArrayList<>();List<CC> list5 = new ArrayList<>();//如果是 List<?> c ，可以接受任意的泛型类型printCollection1(list1);printCollection1(list2);printCollection1(list3);printCollection1(list4);printCollection1(list5);//List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
   //        printCollection2(list1);//×
   //        printCollection2(list2);//×printCollection2(list3);//√printCollection2(list4);//√printCollection2(list5);//√//List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类printCollection3(list1);//√//printCollection3(list2);//×printCollection3(list3);//√//printCollection3(list4);//×//printCollection3(list5);//×//冒泡排序//插入排序//....}// ? extends AA 表示 上限，可以接受 AA或者AA子类public static void printCollection2(List<? extends AA> c) {for (Object object : c) {System.out.println(object);}}//说明: List<?> 表示 任意的泛型类型都可以接受public static void printCollection1(List<?> c) {for (Object object : c) { // 通配符，取出时，就是ObjectSystem.out.println(object);}}// ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，//规定了泛型的下限public static void printCollection3(List<? super AA> c) {for (Object object : c) {System.out.println(object);}}}class AA {
   }class BB extends AA {
   }class CC extends BB {
   }

   泛型没有继承性

Junit测试框架

1. 一个类有很多功能代码需要测试，为了测试，就需要写入main方法中，就需要来回注销，切换很麻烦。如果可以直接运行一个方法就方便很多。

2. package com.jshedu;import org.junit.jupiter.api.Test;/*** @author 韩顺平* @version 1.0*/
   public class JUnit_ {public static void main(String[] args) {//传统方式//new JUnit_().m1();//new JUnit_().m2();}@Testpublic void m1() {System.out.println("m1方法被调用");}@Testpublic void m2() {System.out.println("m2方法被调用");}@Testpublic void m3() {System.out.println("m3方法被调用");}
   }
   

   @Test

3. //定义一个Map 成员变量Map的键为String类型，值为T类型 
   private Map<String,T> map = new HashMap<>();