1. 泛型类
（1）使用语法
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();
（2）Java1.7以后，后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();
注意事项 :
- 泛型类，如果没有指定具体的数据类型，此时，操作类型是Object
- 泛型的类型参数只能是类类型，不能是基本数据类型, 如 int , float
- 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型
package com.hjy.pojo;
import lombok.Data;
@Data
public class MyGeneric<T> {
private T value;
}
public class Main {
public static void main(String[] args) {
MyGeneric<String> myGeneric = new MyGeneric<>();
MyGeneric<Integer> myGeneric2 = new MyGeneric<>();
myGeneric.setValue("hello");
System.out.println("myGeneric = " + myGeneric);
System.out.println(myGeneric.getClass() == myGeneric2.getClass()); // true
}
}
2. 泛型类派生子类
存在两种请求
- 子类也是泛型类，子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T> - 子类不是泛型类，父类要明确泛型的数据类型
class ChildGeneric extends Generic<String>
//父类
public class Parent<E> {
private E value;
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = value;
}
}
/**
* 泛型类派生子类，子类也是泛型类，那么子类的泛型标识要和父类一致。
* @param <T>
*/
public class ChildFirst<T> extends Parent<T> {
@Override
public T getValue() {
return super.getValue();
}
}
/**
* 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
*/
public class ChildSecond extends Parent<Integer> {
@Override
public Integer getValue() {
return super.getValue();
}
@Override
public void setValue(Integer value) {
super.setValue(value);
}
}
3. 泛型接口
泛型接口的定义语法：
interface 接口名称 <泛型标识，泛型标识，…> {
泛型标识 方法名();
.....
}
使用和泛型类的派生对象一样, 也分两种情况
- 实现类也是泛型类，实现类和接口的泛型类型要一致
/**
* 泛型接口
* @param <T>
*/
public interface Generator<T> {
T getKey();
}
package com.hjy.pojo;
import lombok.Data;
/**
* 泛型接口的实现类，是一个泛型类，
* 那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
* @param <T>
* @param <E>
*/
@Data
public class Pair<T,E> implements Generator<T>{
private T key;
private E value;
@Override
public T getKey() {
return key;
}
}
- 实现类不是泛型类，接口要明确数据类型
/**
* 实现泛型接口的类，不是泛型类，需要明确实现泛型接口的数据类型。
*/
public class Apple implements Generator<String> {
@Override
public String getKey() {
return "hello generic";
}
}
4. 泛型方法
泛型方法是在调用方法的时候指明泛型的具体类型。
语法: 修饰符 <T，E, ...> 返回值类型 方法名(形参列表) { 方法体... }
- public与返回值中间非常重要，可以理解为声明此方法为泛型方法
- 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法
- < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
- 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
- 泛型方法声明的泛型标志和类独立, 但是如果没有发生重叠, 泛型方法是可以使用类定义的泛型标志的
- 泛型方法是可以声明为静态方法的, 如果static方法要使用泛型能力，就必须使其成为泛型方法
package com.hjy.pojo;
import lombok.Data;
import java.util.List;
import java.util.Random;
@Data
public class MyGeneric<T> {
private T value;
// 使用类的泛型标志
public <R> T hello1(R r) {
return value;
}
// 自定义的泛型标志覆盖类的泛型标志
public <T> T hello2(List<T> list) {
Random random = new Random();
int i = random.nextInt(list.size());
return list.get(i);
}
// 声明静态方法
public static <T> T hello3(T t) {
return t;
}
}
package com.hjy;
import com.hjy.pojo.Children;
import com.hjy.pojo.MyGeneric;
import com.hjy.pojo.Pair;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
MyGeneric<String> g = new MyGeneric<>();
g.setValue("hello");
System.out.println(g.hello1(1));
List<String> list = new ArrayList<>();
list.add("笔记本");
list.add("手机");
list.add("哈哈");
System.out.println(g.hello2(list));
System.out.println(MyGeneric.hello3("he"));
}
}
5. 类型通配符
在java中，数组是可以协变的，比如dog extends Animal，那么Animal[] 与dog[]是兼容的。而集合是不能协变的，也就是说List<Animal>不是List<dog>的父类，这时候就可以用到通配符了。
- 类型通配符一般是使用"?"代替具体的类型实参。
- 所以，类型通配符是类型实参，而不是类型形参
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
h1(list); //报错
h2(list); // 正常
}
public static void h1(List<Number> list) {
}
public static void h2(List<Integer> list) {
}
}
如上, Number 是 Integer 类的父类, h1(list) 按道理来说不会报错, 可以指定泛型就是认死理 ,不是指定的类型就报错, 这个时候我们就可以使用 ? 类型通配符来操作
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
h1(list); //报错
h2(list); // 正常
}
public static void h1(List<?> list) {
}
public static void h2(List<?> list) {
for (Object o : list) {
}
}
}
现在就不报错了, 可是单纯的使用通配符会让其类型默认为 Object, 我们有什么办法解决呢 ?
类型通配符的上限
- 语法：
类/接口<? extends 实参类型>
要求该泛型的类型，只能是实参类型，或实参类型的子类类型,多用于函数参数
class Animal {
}
class Cat extends Animal{
}
class MiniCat extends Cat{
}
public class Main {
public static void main(String[] args) {
List<Animal> list1 = new ArrayList<>();
List<Cat> list2 = new ArrayList<>();
List<MiniCat> list3 = new ArrayList<>();
show(list1); // 报错
show(list2); // 正常
show(list3); //正常
}
public static void show(List<? extends Cat> list) {
// 报错, 因为这时候它只知道你是 Cat 的子类, 但是不知道你是 Cat 具体的哪个子类
// list.add(new Cat());
}
}
类型通配符的下限
- 语法：
类/接口<? super 实参类型>
要求该泛型的类型，只能是实参类型，或实参类型的父类类型。多用于函数参数
class Animal {
}
class Cat extends Animal{
}
class MiniCat extends Cat{
}
public class Main {
public static void main(String[] args) {
List<Animal> list1 = new ArrayList<>();
List<Cat> list2 = new ArrayList<>();
List<MiniCat> list3 = new ArrayList<>();
show(list1); // 正常
show(list2); // 正常
show(list3); //报错
}
public static void show(List<? super Cat> list) {
// 正常, 因为这时候它知道你是 Cat 的父类, 符合编译
list.add(new Cat());
}
}
总结
我们要记住这么几个使用原则, 有人将其称为PECS(即"Producer Extends, Consumer Super", 网上翻译为"生产者使用extends, 消费者使用super", 我觉得还是不翻译的好). 也有的地方写作"in out"原则, 总的来说就是:
- in或者producer就是你要读取出数据以供随后使用(想象一下List的get), 这时使用extends关键字, 固定上边界的通配符. 你可以将该对象当做一个只读对象;
- out或者consumer就是你要将已有的数据写入对象(想象一下List的add), 这时使用super关键字, 固定下边界的通配符. 你可以将该对象当做一个只能写入的对象;
- 当你希望in或producer的数据能够使用Object类中的方法访问时, 使用无边界通配符;
- 当你需要一个既能读又能写的对象时, 就不要使用通配符了.
普通的泛型标志使用类型通配符的上限和下限
我们可以使用 extends 和 super 来缩小 泛型的范围
先看下面这个样例
@Data
public class MyGeneric<T> {
private T value;
public void he() {
value.he();
}
}
class Animal {
public void he() {
System.out.println("heh");
}
}
public class Main {
public static void main(String[] args) {
MyGeneric<Animal> generic = new MyGeneric<>();
generic.setValue(new Animal());
generic.he();
}
}
这样使用的话, 就会报错, 可是我想让他可以正常使用, 怎么办呢 ?
我们可以指定其上限为 Animal ,这样它即可以泛化 Animal 的子类, 也可以使用 Animal 中定义的方法
package com.hjy.pojo;
class Animal {
public void he() {
System.out.println("heh");
}
}
package com.hjy.pojo;
import lombok.Data;
@Data
public class MyGeneric<T extends Animal> {
private T value;
public void he() {
value.he();
}
}
public class Main {
public static void main(String[] args) {
MyGeneric<Animal> generic = new MyGeneric<>();
generic.setValue(new Animal());
generic.he();
}
}
当然, 我们也可以使用 下限
@Data
public class MyGeneric<T> {
private T value;
// 锁定了参数一定是 T 的 父类或者它自己
public void he(Comparator<? super T> comparator) {
value.he();
}
}
6. 类型擦除
泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为–类型擦除。
类型擦除有四种情况, 下面我们以反射为例为大家解释
无限制类型擦除
package com.hjy;
import java.lang.reflect.Field;
class TheGeneric<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
public class Main {
public static void main(String[] args) {
TheGeneric<String> generic = new TheGeneric<>();
// 获取字节码
Class<? extends TheGeneric> aClass = generic.getClass();
Field[] fields = aClass.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName() + ":" + field.getType().getSimpleName());
}
}
}
结果:
value:Object
有限制类型擦除
package com.hjy;
import java.lang.reflect.Field;
class TheGeneric<T extends String> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
public class Main {
public static void main(String[] args) {
TheGeneric<String> generic = new TheGeneric<>();
// 获取字节码
Class<? extends TheGeneric> aClass = generic.getClass();
Field[] fields = aClass.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName() + ":" + field.getType().getSimpleName());
}
}
}
value:String
擦除方法中类型定义的参数
package com.hjy;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
class TheGeneric<T extends String> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public <T extends Number> T hehe(T t) {
return t;
}
}
public class Main {
public static void main(String[] args) {
TheGeneric<String> generic = new TheGeneric<>();
// 获取字节码
Class<? extends TheGeneric> aClass = generic.getClass();
Method[] methods = aClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName() + ":"+ method.getReturnType().getSimpleName());
}
}
}
hehe:Number
getValue:String
setValue:void
桥接方法
package com.hjy;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
interface Info<T> {
T info(T var);
}
class TheGeneric implements Info<Integer> {
@Override
public Integer info(Integer var) {
return null;
}
}
public class Main {
public static void main(String[] args) {
TheGeneric generic = new TheGeneric();
// 获取字节码
Class<? extends TheGeneric> aClass = generic.getClass();
Method[] methods = aClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName() + ":"+ method.getReturnType().getSimpleName());
}
}
}
info:Integer
info:Object
7. 泛型与数组
- 可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
ArrayList<String>[] listArr = new ArrayList<5>(); //会报错
但是我们可以先创建出不带泛型的对象, 再将这个赋值给带泛型的对象
ArrayList[] list = new ArrayList[5];
ArrayList<String>[] listArr = list;
// 或者
ArrayList<String>[] listArr = new ArrayList[5];
- 可以通过java.lang.reflect.Array的newInstance(Class,int)创建T[]数组
public class Fruit<T> {
private T[] array;
public Fruit(Class<T> clz, int length){
//通过Array.newInstance创建泛型数组
array = (T[])Array.newInstance(clz, length);
}
}