目录

一、泛型的理解

二、泛型的作用

三、泛型有哪些使用方式

四、上限、下限通配符的使用

五、泛型的原理

---

一、泛型的理解

泛型在jdk5中开始有的，泛型其实就是将类型进行参数话，使得类型在编译时就确定了，这种类型参数可以用在类、接口、方法上面

泛型的初衷是为了安全和方便的 安全是类型转换安全 方便是指可以不需要类型转换了

它的这种安全体现在如果说编译的时候能够检测出来问题，最好，就不要拖到运行的时候再来出错

有句话正好贴合这里：越早出错，代价越好

例子：

Object s= new String();

Integer s1 = (Interger)s;这个编译的时候不会出错，但是实际运行会出现ClassCastException类型转换异常。

如果说使用了泛型的话，那么是那种类型就得是哪种类型

List<String> list = new ArrayList();

实现安全就体现在添加元素上面，其次如果取元素，那么就只能使用正确的类型进行接收，如果类型不一致接收都接收不了，不能强转成非法的类型

二、泛型的作用

其实作用大的来说就两点：安全 + 方便

安全：避免错误的强转，比如说现在定义一个泛型类型为String类型的集合，那么从中取出来元素就不能强转成其他类型，否则就会报错。如果说它让你强转的话，那么在运行时会出错

参考上面理解中的例子

方便：其实就是不需要手动的强转了，自动的为我们强转...这里的例子，比如说方法返回值接收

当然除了这两点主要的，还有其他的一些好处：

1. 如果说使用了包装类型那么就根本就不需要拆箱与装箱

其实原因就在于指定了上面类型就会自动的返回什么类型 而不会像方法那么传递一个Integer返回一个int造成需要拆箱了

2. 提高了代码的重用性，需要什么类型我就指定好什么类型就行了。比如说一个求和的方法，我不再需要写多个重载的方法了，参数传递什么类型  结果就能是什么类型

三、泛型有哪些使用方式

泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{private T key;public Generic(T key) {this.key = key;}public T getKey(){return key;}
}

典型应用：用在接口统一结果返回对象 

泛型方法

  public static < E > void printArray( E[] inputArray ){for ( E element : inputArray ){System.out.printf( "%s ", element );}System.out.println();}

泛型方法不等于泛型类中的那个使用泛型属性的方法。那个有局限性：

我如果想要换一种类型，是不是就得重新创建另外一种类型的对象，不方便

典型应用：集合工具类中的排序方法，是需要对各种类型的集合都能排序的

如果是没有泛型方法，那么每次对一个新的类型的集合进行排序，就需要创建一个新的工具类对象

不够灵活

当然还有许多地方：

很多时候我们是需要直接就能得到对应的对象，而不想让得到一个Object类对象，我们再去进行强转。

可以使用泛型方法，参数就写Class<T> clazz 

然后在方法中强转 成T类型

public static <T> T copyBean(Object source,Class<T> clazz){T result = null;try {result = clazz.newInstance();BeanUtils.copyProperties(source,result);} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return result;}

 public static <T> List<T> copyBean(List<?> list,Class<T> clazz){return list.stream().map(o->copyBean(o,clazz)).collect(Collectors.toList());}

public <T> T getData(TypeReference<T> typeReference) {Object data = get("data");	//默认是mapString jsonString = JSON.toJSONString(data);T t = JSON.parseObject(jsonString, typeReference);return t;}

public <R,ID> R queryShopWithCacheThrough(String cachePrefix, ID id, Class<R> type, Function<ID,R> dbFallBack,Long time, TimeUnit timeUnit){//1. 从redis中查询缓存String key = cachePrefix + id;String json = stringRedisTemplate.opsForValue().get(key);//2. 判断是否存在if(StrUtil.isNotBlank(json)){//3. 若存在，则直接返回R r = JSONUtil.toBean(json, type);return r;}if(json!=null){// 查到空数据，直接返回错误return null;}//4. 若不存在，则查询数据库R r = dbFallBack.apply(id);//5. 不存在，返回错误if (r == null) {//缓存空数据stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);return null;}//6. 存在，存入redisstringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(r),time,timeUnit);//7. 返回return r;}

泛型接口：

public interface Generator<T> {public T method();
}

实现泛型接口，不指定类型：

class GeneratorImpl<T> implements Generator<T>{@Overridepublic T method() {return null;}
}

典型应用：

在MP中的mapper接口、service接口都使用到了泛型接口 :

 MP中的mapper接口和service接口使用的就是上面那种  通过指定实体类的类型，从而确定是对哪张表进行操作，所以此时不能再传递参数的时候传递其他表对应的实体类了，以及wrapper也是

public interface CourseBaseMapper extends BaseMapper<CourseBase> {}

public interface BaseMapper<T> extends Mapper<T> {int insert(T entity);
}

 service：

public interface CourseBaseService extends IService<CourseBase> {}

public interface IService<T> {int DEFAULT_BATCH_SIZE = 1000;default boolean save(T entity) {return SqlHelper.retBool(this.getBaseMapper().insert(entity));}
}

四、上限、下限通配符的使用

首先介绍? 这个代表所有 是所有 T 的根父类

比如说我可以这样   List<?> list =  new ArrayList();

List<String> list1 = new ArrayList()；

将list1赋值给list    list = list1 这样不会报错

但是如果我是    List<Object> list = new ArrayList();

List<String> list1 = new ArrayList()； 那么就会报错。

小插一句：这里如果是 Person<T> p = new Person(); Student<T> s = new Student();

那么可以将 s 赋值给 p  p = s 这里就是单纯的子父类了

原因在于相当于 如果这样可以的话  相当于集合中现在就只能添加String类型的元素了，相当于就是可添加的范围减少了，显然这是不合理的，另外还有就是你声明的类型是 Object而实际的类型是String  那我如果取元素，那么取出来的元素到底应该是String还是Object呢？其实就说不清了，存也是一样，我到底是存String还是存Object呢？

其实通配符的作用就来了，使用?就可以代替Object 就可以接收任意泛型类型

如果只是使用？ 那么就是对泛型类型没有约束，什么类型都可以。但是如果你想要指定的范围，比如说我要求你给我的泛型类型必须是某一个类的父类或者是子类 ，那么就可以使用带范围的通配符。

<? extends Person>这个代表泛型类型只能是Person类型或者是其子类 也就是规定了上限

<? super Person>这个代表泛型类型只能是Person类型或者是Person的父类，规定了下限

那么方法参数的泛型类型就必须老实按规定来。

注意：

当集合类型的泛型定义为通配符的时候，是不能往里面添加元素的。只能存null 只能取元素

比如说：

List<?> list = new ArrayList(); list.add("avc") 这是会编译报错的。但是可以存null

这里看似应该是可以传递的，因为是?可以代表是Object的意思，但是为什么不能传，只能存null可能就是它这么规定的吧。

这个获取到集合中的元素，元素类型是Object类型

另外还有有范围的，比如说：

List<? extends Person> list = new ArrayList<>()

也只能存null,这个好理解，因为怕我存Person的父类对象进去了，为了安全起见，干脆就只能让你存null进去，这个因为无论怎样元素一定是Person类型或者是其子类类型，那么所以就完全使用Person类就可以接收

反过来如果是super，它怕你存进去Person的子类所以直接不让你存，就只能让你存null

这里因为不知道存进去的到底有多大，因此这个取出来直接使用根父类Object类接收

使用例子：

public static <T> List<T> copyBean(List<?> list,Class<T> clazz){return list.stream().map(o->copyBean(o,clazz)).collect(Collectors.toList());}

因为这里我不确定到底是需要对什么类型的集合进行拷贝，但是这里又不能写死成Object，所以就只能使用?通配符了，当然也可以使用 T的方式，那么相当于就多了一个泛型参数，所以在前面定义的时候也需要多给一个，就是下面这样：

public static <T,O> List<T> copyBean(List<O> list,Class<T> clazz){return list.stream().map(o->copyBean(o,clazz)).collect(Collectors.toList());}

五、泛型的原理

原理就是泛型擦除，其实泛型信息只会在编译时候保持，运行时就全没了，字节码中其实有泛型和没泛型的是一样的   如果没有设定范围  那么会被擦除成Object类型  如果给定了范围 那么擦除之后就是对应类型的 所以在编译的时候可以使用到编译器进行检查，因此这里不涉及到JVM，因此泛型是几乎不消耗性能的，所以使用泛型的另外一个作用就是：潜在的性能收益