首页 > 编程语言 > 深入了解JAVA泛型
2020
10-06

深入了解JAVA泛型

什么是泛型

泛型的概念:Java泛型(generics)是JDK1.5中引入的一个新特性,泛型提供了编译时的类型安全监测机制,该机制允许我们在编译时检测到非法的类型数据结构。

泛型的本质就是类型参数化,也就是所操作的数据类型被指定为一个参数。

使用泛型的好处:

1  在编译期间提供了类型检查

2  取数据时无须进行类型装换

泛型类、接口

泛型类

语法:

class 类名称 <泛型标识,泛型标识,泛型标识,...> {
 private 泛型标识 变量名;
 // ...
}

常用的泛型标识:T、E、K、V

使用语法:

类名 <具体的数据类型> 对象名 = new 类名<具体的数据类型>();

JDK 1.7 之后,后面的 <> 中的具体的数据类型可以省略不写。

定义一个简单的泛型类:

/**
 * 泛型类 T:类型形参,在类创建对象时,指定具体的数据类型
 * @author rainszj
 * 2020/3/19
 */
public class GenericDemo01<T> {

 private T value;
 public GenericDemo01() {
 }

 public GenericDemo01(T value) {
  this.value = value;
 }

 @Override
 public String toString() {
  return "GenericDemo01{" +
    "value=" + value +
    '}';
 }

 public T getValue() {
  return value;
 }

 public void setValue(T value) {
  this.value = value;
 }
}

测试一下:

public class Test {

 public static void main(String[] args) {
  // 在创建对象时指定具体的数据类型
  GenericDemo01<String> genericDemo01 = new GenericDemo01<>("java");
  // 泛型类不支持基本数据类型,但可以使用基本类型对应的包装类
  GenericDemo01<Integer> genericDemo02 = new GenericDemo01<>(1);
  // 在泛型类对象时,不指定具体的数据类型,将会使用Object类型来接收

  // 同一个泛型类,根据不同数据类型创建的对象,本质上是同一类型,公用同一个类模板
  // class com.rainszj.GenericDemo01
  System.out.println(genericDemo01.getClass());
  // class com.rainszj.GenericDemo01
  System.out.println(genericDemo02.getClass());
  // true
  System.out.println(genericDemo01.getClass() == genericDemo02.getClass());
  
 }
}

注意事项:

泛型类,如果没有指定具体的数据类型,按Object类型来接收

泛型的类型参数只能是类类型,也就是引用数据类型,不能是基本数据类型

泛型类型在逻辑上可以看成是多个不同的类型,但实际上都是相同类型

/**
 * 抽奖池
 *
 * @author rainszj
 * 2020/3/19
 */
public class ProductGetter<T> {
 // 奖品
 private T product;

 private ArrayList<T> list = new ArrayList<>();

 /**
  * 添加奖品
  *
  * @param product
  */
 public void addProduct(T product) {
  list.add(product);
 }

 /**
  * 抽取随机奖品
  *
  * @return
  */
 public T getProduct() {
  return list.get(new Random().nextInt(list.size()));
 }

 @Override
 public String toString() {
  return "ProductGetter{" +
    "product=" + product +
    '}';
 }
}

public static void main(String[] args) {
 ProductGetter<String> productGetter1 = new ProductGetter<>();
 // 奖品类型 礼物
 String[] products1 = {"华为手机", "苹果手机", "扫地机器人", "微波炉"};
 // 添加奖品
 for (int i = 0, length = products1.length; i < length; i++) {
 productGetter1.addProduct(products1[i]);
 }
 // 获取奖品
 String product1 = productGetter1.getProduct();
 System.out.println("恭喜您抽中了," + product1.toString());

 ProductGetter<Integer> productGetter2 = new ProductGetter<>();
 // 奖品类型 money
 Integer[] products2 = {1000, 3000, 10000, 500};
 for (Integer money : products2) {
 productGetter2.addProduct(money);
 }
 Integer product2 = productGetter2.getProduct();
 System.out.println("恭喜您抽中了," + product2.toString());
}

从泛型类派生子类

子类也是泛型类,子类的泛型标识 T 要和父类的泛型标识 T 保持一致,或者是包含关系,子类的泛型标识包含父类的泛型标识

class ChildGeneric<T> extends ParentGeneric<T>
class ChildGeneric<T, E> extends ParentGeneric<T>

子类不是泛型类,父类要明确泛型的数据类型

class ChildGeneric extends ParentGeneric<String>

泛型接口

语法:

interface 接口名称 <泛型标识,泛型标识,...> {
 泛型标识 方法名();
}

实现泛型接口的类,不是泛型类,需要明确实现泛型接口的数据类型

public class Apple implements Generic<String> {}

实现类也是泛型类,实现类和接口的泛型类型要一致,或者是包含关系,实现类的泛型标识包含泛型接口的泛型标识

public class Apple<K> implements Generic<K> {}
public class Apple<K, V> implements Generic<K> {}

定义一个泛型接口

public interface Generic<K> {
 K getKey();

}

实现其中方法:

/**
 * 泛型接口的实现类,是一个泛型类,
 * 那么要保证实现接口的泛型类的泛型标识包含泛型接口的泛型标识
 */
public class Pair<K, V> implements Generic<K> {
 private K key;
 private V value;
 
 public Pair() {
 }

 public Pair(K key, V value) {
  this.key = key;
  this.value = value;
 }

 @Override
 public K getKey() {
  return key;
 }

 public V getValue() {
  return value;
 }

 @Override
 public String toString() {
  return "Pair{" +
    "key=" + key +
    ", value=" + value +
    '}';
 }
}

测试:

public class MyTest {
 public static void main(String[] args) {
  Pair<String, Integer> pair = new Pair<>("数学", 100);
  System.out.println(pair.toString());
  // Pair{key=数学, value=100}
 }
}

泛型方法

普通泛型方法

泛型类,是在实例化类时指明泛型的具体类型。

泛型方法,是在调用方法时,指明泛型的具体类型。

语法:

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

public 与返回值中间 <T,E,...> (泛型列表)非常重要,可以理解为声明此方法为泛型方法。

只有声明了 <T,E,...> 的方法才是泛型方法,泛型类中使用了泛型的成员方法并不是泛型方法

<T> 表明该方法将使用泛型类型 T,此时才可以在方法中使用泛型类型 T。

public class ProductSetter<T> {

 private T product;
 private Random random= new Random();
 private ArrayList<T> list = new ArrayList<>();

 public void addProduct(T product) {
  list.add(product);
 }

 /**
  * @param list
  * @param <E> 泛型方法的类型,是在调用泛型方法时确定的
  * @return
  */
 public <E> E getProduct(ArrayList<E> list) {
  return list.get(random.nextInt(list.size()));
 }

 public T getProduct() {
  return list.get(random.nextInt(list.size()));
 }

 @Override
 public String toString() {
  return "ProductSetter{" +
    "product=" + product +
    '}';
 }
}

测试:

public static void main(String[] args) {
 ProductSetter<String> productSetter = new ProductSetter<>();
 String[] products1 = {"华为手机", "苹果手机", "扫地机器人", "微波炉"};
 for (int i = 0; i < products1.length; i++) {
  productSetter.addProduct(products1[i]);
 }
 System.out.println(productSetter.getProduct());

 ArrayList<String> list1 = new ArrayList<>();
 list1.add("华硕电脑");
 list1.add("苹果电脑");
 list1.add("华为电脑");
 String product1 = productSetter.getProduct(list1);
 System.out.println(product1 + "\t" + product1.getClass().getSimpleName());
 // 华为电脑 String
 ArrayList<Integer> list2 = new ArrayList<>();
 list2.add(1);
 list2.add(2);
 list2.add(3);

 Integer product2 = productSetter.getProduct(list2);
 System.out.println(product2 + "\t" + product2.getClass().getSimpleName());
 // 2 Integer
}

静态泛型方法

public static <T, E, K> void pringType(T k1, E k2, K k3) {
 System.out.println(k1 + "\t" + k1.getClass().getSimpleName());
 System.out.println(k2 + "\t" + k2.getClass().getSimpleName());
 System.out.println(k3 + "\t" + k3.getClass().getSimpleName());
}
// 方法的调用
ProductSetter.pringType(1, "hello", false);

// 输出结果
1 Integer
hello String
false Boolean

注意:

// 在泛型类中无法添加静态的 带有泛型成员方法,但可以添加静态的 泛型方法
public class Test<T> {
 
 // 带有泛型的成员方法
	// 错误
	public static T getKey(T key) {
	 return key;
	}
 
 // 泛型方法
	// 正确
	public static <E> E getKey(E key) {
	 return key;
	}
}

泛型方法中的可变参数

public class MyTest {
 public static void main(String[] args) {
  MyTest.print(1, 2, 3);
 }

 /**
  * 泛型方法中的可变长参数
  * @param value
  * @param <E>
  */
 public static <E> void print(E ... value) {
  for (int i = 0; i < value.length; i++) {
   System.out.println(value[i]);
  }
 }
}

总结:

泛型方法能使方法独立于类而产生变化。

如果 static 方法要使用泛型能力,就必须使其成为泛型方法。

类型通配符

类型通配符一般是使用 ? 代替具体的类型实参。

类型通配符是类型实参,而不是类型形参。

我们先来定义一个简单的泛型类:

public class Box<T> {
 private T width;
 public static void showBox(Box<Number> box) {
  Number width = box.getWidth();
  System.out.println(width);
 }

 public T getWidth() {
  return width;
 }

 public void setWidth(T width) {
  this.width = width;
 }
}

main方法:

public static void main(String[] args) {
 Box<Number> box1 = new Box<Number>();
 box1.setWidth(100);
 showBox(box1);
}

当我们在 main 方法中增加这一段代码时,就会报错

Box<Integer> box2 = new Box<>();
box2.setWidth(200);
showBox(box2);

虽然 Integer 类继承自 Number 类,但在类型通配符中不存在继承这一概念!

也许你会使用方法的重载,但是 在同一个泛型类中,根据不同数据类型创建的对象,本质上是同一类型,公用同一个类模板,所以无法通过方法的重载,传递不同的泛型类型。

这时可以使用类型通配符 ?,来代表具体的类型实参!

public static void showBox(Box<?> box) {
 Object width = box.getWidth();
 System.out.println(width);
}

类型通配符的上限

在我们上面的showBox()代码中,发现 box.getWidth()得到的还是Object类型,这和我们不使用类型通配符,得到的结果是一样的。这时我们可以使用类型通配符的上限。

语法:

类/接口 <? entends 实参类型> 

要求该泛型的类型,只能是实参类型,或者是实参类型的子类类型。

public static void showBox(Box<? extends Number> box) {
 Number width = box.getWidth();
 System.out.println(width);
}

public static void main(String[] args) {
 Box<Integer> box2 = new Box<>();
 box2.setWidth(200);
 showBox(box2);
}

使用类型通配符的下限,无法得知该类型具体是指定的类型,还是该类型的子类类型,因此无法在 List 集合中执行添加该类或者该类子类的操作!

public static void showAnimal(List<? extends Cat> list) {
  // 错误
  list.add(new Cat());
 	 list.add(new MiniCat());
}

类型通配符的下限

语法

类/接口 <? super 实参类型> 

要求该泛型的类型,只能是实参类型,或者是实参类型的父类类型。

下面通过 TreeSet 集合中的一个构造方法来进一步理解 类型通配符的下限

public TreeSet(Comparator<? super E> comparator) {
 this(new TreeMap<>(comparator));
}

首先是一个Animal类,只有一个 name 属性

public class Animal {
 private String name;

 public Animal(String name) {
  this.name = name;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 @Override
 public String toString() {
  return "Animal{" +
    "name='" + name + '\'' +
    '}';
 }
}

然后它的一个子类,Cat添加一个属性:age

public class Cat extends Animal {
 private int age;

 public Cat(String name, int age) {
  super(name);
  this.age = age;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 @Override
 public String toString() {
  return "Cat{" +
    "age=" + age +
    '}';
 }
}

最后是 Cat 的子类,MiniCat,再添加一个属性 level

public class MiniCat extends Cat {
 private int level;

 public MiniCat(String name, int age, int level) {
  super(name, age);
  this.level = level;
 }

 public int getLevel() {
  return level;
 }

 public void setLevel(int level) {
  this.level = level;
 }

 @Override
 public String toString() {
  return "MiniCat{" +
    "level=" + level +
    '}';
 }
}

测试,首先我们要在MyTest类通过静态内部类的方式,实现比较的接口,在构造TreeSet时,传递比较器

public class MyTest {
 public static void main(String[] args) {
  	// 正常
  // TreeSet<Cat> animals = new TreeSet<Cat>(new Comparator1());
  // 正常
  TreeSet<Cat> animals = new TreeSet<Cat>(new Comparator2()); 
  	// 报错
				// TreeSet<Cat> animals = new TreeSet<Cat>(new Comparator3()); 
  List<Cat> list = Arrays.asList(new Cat("a", 12), new Cat("c", 9), new Cat("b", 20));
  animals.addAll(list);

  animals.forEach(System.out::println);

 }

 public static class Comparator1 implements Comparator<Animal> {

  @Override
  public int compare(Animal o1, Animal o2) {
   return o1.getName().compareTo(o2.getName());
  }
 }

 public static class Comparator2 implements Comparator<Cat> {

  @Override
  public int compare(Cat o1, Cat o2) {
   return o1.getAge() - o2.getAge();
  }
 }

 public static class Comparator3 implements Comparator<MiniCat> {

  @Override
  public int compare(MiniCat o1, MiniCat o2) {
   return o1.getLevel() - o2.getLevel();
  }
 }
}

结论:

通过以上的比较,我们可以看出,类型通配符的下限,只能传递实参类型的或者实参类型的父类类型。

我们每次比较使用的都是 Cat 类型,但在 Comparator1比较的是 Animal 中的 name 属性,这是因为 我们在初始化 Cat 对象的时候,一定会先初始化 Animal 对象,也就是创建子类对象的时候,一定会先创建父类对象,所以才可以进行比较。

如果是使用 类型通配符的上限,在创建对象时,比较的是该类的子类对象中的属性,就会造成空指针异常!也就是Comparator3无法使用的原因, 所以在 TreeSet 中才会使用 <? super E> ,类型通配符的下限。

类型擦除

泛型是Java 1.5 引进的概念,在这之前是没有泛型的,但是,泛型代码能够很好地和之前的代码兼容。那是因为,泛型信息只存在编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,我们称之为——类型擦除

无限类型擦除

先定义一个泛型类:

public class Erasure<T> {
 private T key;

 public T getKey() {
 return key;
 }

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

输出结构:

public static void main(String[] args) {
 Erasure<Integer> erasure = new Erasure<>();
 Class<? extends Erasure> cls = erasure.getClass();
 Field[] fields = cls.getDeclaredFields();
 for (Field field : fields) {
 System.out.println(field.getName() + ":" + field.getType().getSimpleName()); // key:Object
 }
}

可以发现在编译完成后的字节码文件中,T --> Object 类型

有限类型擦除

还是刚才的泛型类,只不过加了泛型的上限

public class Erasure<T extends Number> {// ...}

测试不变,输出结果:

key:Number

当我们指定了泛型的上限时,它会将我们的泛型擦除为上限类型

同样对泛型方法,也是一样的道理

// 泛型方法
public <E extends List> E test(E t) {
 return t;
}
Method[] methods = cls.getDeclaredMethods();
for (Method method : methods) {
 System.out.println(method.getName() + ":" + method.getReturnType().getSimpleName());
}

// 输出结果
// getKey:Number
// test:List
// setKey:void

桥接方法

泛型接口

public interface Info<T> {

 T test(T value);
}

泛型接口的实现类

public class InfoImpl implements Info<Integer> {
 @Override
 public Integer test(Integer value) {
  return value;
 }
}

测试

public static void main(String[] args) {
 Class cls = InfoImpl.class;
 Method[] methods = cls.getDeclaredMethods();
 for (Method method : methods) {
  System.out.println(method.getName() + ":" + method.getReturnType().getSimpleName());
 }
}

// 输出结果:
// test:Integer
// test:Object

原本 InfoImpl 中只是实现了 Info 接口中的一个方法,但通过反射却拿到了两个方法。其中返回值为 Object 的方法就是桥接方法。

在编译完成后,类型擦除的结果是这样的:

public interface Info {

 Object test(Object value);
}
public class InfoImpl implements Info {

 public Integer test(Integer value) {
  return value;
 }
	
 	// 桥接方法:保持接口和类的实现关系
 @Override
 public Object test(Object value) {
  return (Integer)value;
 }
}

泛型数组

开发中,一般常用的是泛型集合

泛型数组的创建:

可以声明带泛型的数组引用,但是不能直接创建带泛型数组对象。

可以通过 java.lang.reflect.Array newInstance(Class<T>, int)创建 T[ ] 数组。

// 可以创建带泛型的数组引用
ArrayList<String>[] arrayLists1 = new ArrayList[3];
// 无法创建带泛型的数组对象
ArrayList<String>[] arrayLists2 = new ArrayList<String>[3];

简单使用 java.lang.reflect.Array newInstance(Class<T>, int)创建 T[ ] 数组。 封装一个泛型数组

public class GenericArray<T> {
 private T[] array;

 public GenericArray(Class cls, int length) {
  this.array = (T[]) Array.newInstance(cls, length);
 }

 public void put(int index, T item) {
  this.array[index] = item;
 }

 public T get(int index) {
  return this.array[index];
 }

 public T[] getArray() {
  return this.array;
 }

 public static void main(String[] args) {
  GenericArray<String> ga = new GenericArray<>(String.class, 3);
  ga.put(0, "白虎");
  ga.put(1, "青龙");
  ga.put(2, "朱雀");

  System.out.println(Arrays.toString(ga.getArray()));

 }
}

泛型和反射

反射常用的泛型类:

Class

Constructor

通过反射创建对象,带泛型和不带泛型

Class<Cat> catClass1 = Cat.class;
try {
 Constructor<Cat> c1 = catClass1.getConstructor();
 Cat cat = c1.newInstance();
} catch (Exception e) {
 e.printStackTrace();
}

Class catClass2 = Cat.class;
try {
 Constructor c2 = catClass2.getConstructor();
 Object cat2 = c2.newInstance();
} catch (Exception e) {
 e.printStackTrace();
}

以上就是深入了解JAVA泛型的详细内容,更多关于JAVA泛型的资料请关注自学编程网其它相关文章!

编程技巧