定义一个泛型类basicRobotController：

public class basicRobotController<R extends RoutePoint, O> {

@RequestMapping(value="updateRoutePoint", method = RequestMethod.POST,produces={"application/json;charset=utf-8"})
@ResponseBody
public void updateRoutePoint(String routePointStr,String collection){
R routePoint = JSONObject.parseObject(routePointStr, clazzR);
routePoint.getOrder();
...
    }
}

定义sprayRobotController 继承basicRobotController：

@Controller
@RequestMapping("sprayRobot")
public class sprayRobotController extends basicRobotController<SprayRoutePoint, SprayOperatorData> {

    @Resource
    public void setService(ISprayRobotService sprayRobotService){
        super.setBaseService(sprayRobotService);
    }

}

（1）如果basicRobotController的updateRoutePoint方法中，泛型类R的实例routePoint 需要调用其本身定义的方法，需要定义泛型R的具体类后才能调用。
（2）本例因为定义basicRobotController时，泛型R继承RoutePoint类，因此泛型R的实例routePoint可以调用RoutePoint类的方法。
（3）若定义basicRobotController时R没有继承至RoutePoint，则无法调用RoutePoint的getOrder()方法。

一、泛型

• 泛型：本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。

泛型定义格式：

• <类型>：指定一种类型的格式。这里的类型可以看成是形参。
• <类型1,类型2…>：指定多种类型的格式，多种类型用逗号隔开，这里的类型可以看成是形参。
• 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型。

泛型的好处：

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换

二、泛型类

泛型类的定义格式：

• 格式：修饰符 class 类名<类型>{}
• 泛例：public class Generic<T> {}
• T可以是任意标识

public class Generic<T>{
    private T t;

    public T get(){
        return t;
    }

    public void set(T t){
        this.t = t;
    }
}

public class CollectionDemo {

    public static void main(String[] args) {
        Generic<String> stu = new Generic<String>();
        stu.set("鸣人");
        System.out.println(stu.get());

        Generic<Integer> stu1 = new Generic<Integer>();
        stu1.set(10);
        System.out.println(stu1.get());
    }
}

三、泛型方法

泛型方法的定义格式：

• 格式：修饰符 <类型> 返回值类型方法名(类型变量名){}
• 范例：public <T> void show(T t){}

    public <T> T show(T t){
        return t;
    }

    public <T> void show1(T t){
        System.out.println(t);
    }

四、泛型接口

泛型接口的定义格式：

• 格式：修饰符 interface 接口名<类型>{}
• 范例：public interface Generic <T>{}

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

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

public class CollectionDemo{

    public static void main(String[] args) {
        GenImpl<String> str = new GenImpl<String>();
        str.show("加油");

        GenImpl<Integer> i = new GenImpl<>();
        i.show(30);
    }
}

五、类型通配符

为了表示各种泛型List的父类，可以使用类型通配符：

• 类型通配符：<?>
• List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果不希望List<?>是任何泛型的父类，只希望代表某一类泛型List的父类，可以使用类型通配符的上限。

• 类型通配符上限：<?extends类型>
• List<? extends Number>：表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，也可以指定类型通配符的下限：

• 类型通配符下限：<?super类型>
• List<?super Number>：表示的类型是Number或者其父类型

import java.util.ArrayList;
import java.util.List;

public class CollectionDemo{

    public static void main(String[] args) {
        List<?> numbersList = new ArrayList<Number>();

        //类型通配符上限
        List<? extends Number> list1 = new ArrayList<Number>();
        List<? extends Number> list2 = new ArrayList<Integer>();

        //类型通配符下限
        List<? super Number> list3 = new ArrayList<Number>();

    }
}

泛型

JDK1.5新特性

优点：

1. 类型安全：编译时检测类型
2. 减少类型转换

泛型类

概念：在类声明体中用到了类型参数。

语法：

/*
class 类型名<泛型标识，泛型标识， ...>{
    private 泛型标示 变量名;
}
*/
public class GenericDemo<T> {
    private T key;

    public GenericDemo(T key) {
        this.key = key;
    }

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    public static void main(String[] args) {
        
        /*
        类名<具体的数据类型> 对象名 = new 类目<具体的数据类型>();

        JDK1.7后，可以省略成这样：
        类名<具体的数据类型> 对象名 = new 类目<>();
        */
        GenericDemo<Integer> integerGenericDemo = new GenericDemo<>(10);
        GenericDemo<String> stringGenericDemo = new GenericDemo<>("abc");
        //如果没有指定具体的数据类型，此时，操作类型是Object
        GenericDemo genericDemo = new GenericDemo("genericDemo");

        System.out.println(integerGenericDemo.key);
        System.out.println(stringGenericDemo.key);
        System.out.println(genericDemo.key);
        //泛型类型在逻辑上可以看成是多个不同的类型，但实际上是相同类型
      System.out.println(integerGenericDemo.getClass()==stringGenericDemo.getClass());	//输出结果为true
    }
}

注意：

1. 泛型类只支持类类型，不支持基本数据类型（如int），但可以用包装类（如Integer ）

泛型标识<>：类型形参

由外部使用类的时候来指定

泛型类的继承

1. 子类也是泛型类，子类和父类的泛型标识要一致。子类也可以扩展泛型标识，但子类中至少有一个泛型标识与父类相同

2. 子类不是泛型类，父类要明确泛型的数据类型

//1.子类也是泛型类，子类和父类的泛型标识要一致

class Child<T> extends Parent<T>{}

//也可以扩展，但子类中至少有一个泛型标识与父类相同
class Child<T，E> extends Parent<T>{}

//2.子类不是泛型类，父类要明确泛型的数据类型

class Child extends Parent<String>{}

泛型接口

1. 实现类不是泛型类时，接口要明确数据类型
2. 实现类也是泛型类时，实现类和接口的泛型类型要一致

泛型方法

泛型方法比泛型类更加灵活

语法

修饰符 <T,E,...> 返回值类型 方法名（形参列表）{
    方法体... 
}

1. public 和 返回类型中间的标识符，可以理解为，声明该方法为泛型方法
2. 只有声明了的方法是泛型方法，泛型类中的成员方法不是泛型方法
3. 表明，该方法使用泛型类型T，可以使用在返回类型，传入参数列表，方法体里

泛型方法与可变参数

public class GenericDemo<T> {

    public static <E> void print(E... e){
        for(int i = 0; i < e.length; i++){
            System.out.println(e[i]);
        }
    }

    public static void main(String[] args) {
        GenericDemo.print(1,2,3,4,5);
        GenericDemo.print("a","b","c");
    }
}

类型通配符： ？

概念：用“？”代替具体类型，是类型实参，不是类型形参

/*
	类型通配符上限
	语法：
	类/接口 <? extends 实参类型>
	作用：要求该泛型的类型只能是《该实参类型或其子类型》  
*/

public static void showAnimal(ArrayList<? extends Cat> list){
    for(int i;i<list.size();i++){
        Cat cat = list.get(i);
        System.out.println(cat);
    }
}
public static void main(String[] args){
    ArrayList<Animal> animals = new ArrayList<>();
    ArrayList<Cat> cats = new ArrayList<>();
    ArrayList<MiniCat> miniCats = new ArrayList<>();
    
    //showAnimal(animals); 编译报错
    showAnimal(cats);
    showAnimal(miniCats);
}

/*
	类型通配符下限
	语法：
	类/接口 <? super 实参类型>
	作用：要求该泛型的类型只能是《该实参类型或其父类型》  
*/

类型擦除

概念：

JDK1.5以前没有泛型，但泛型代码能很好地和之前版本的代码兼容，是因为，泛型信息只存在于代码编译阶段，

在进入JVM之前，与泛型相关的信息会被擦除