Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？
答案是可以使用 Java 泛型。
使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。
代码示例：
import java.util.ArrayList;
/**
* java泛型
*/
public class Generics {
public static void main(String[] args) {
// 使用java泛型对数据类型做限制
// 限制添加的类型必须为Dog
ArrayList<Dog> arrayList = new ArrayList<Dog>();
arrayList.add(new Dog("康康",12));
arrayList.add(new Dog("旺旺",6));
System.out.println(arrayList);
}
}
class Dog {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
使用泛型，可以直接对于数据进行遍历，无需进行额外的类型强转，这增大了代码的效率：🎶
for (Dog dog : arrayList) {
System.out.println(dog.getName());
System.out.println(dog.getAge());
}
我们来创建一个类：
该类的一个属性为泛型，可以是任意的数据类型，在编译期间，确定E是什么类型
// 泛型类
class Person<E> {
E s; // 在编译期间，确定E是什么类型
public Person(E s) { // E可以是参数类型
this.s = s;
}
public E f() { // E也可以是返回类型
return s;
}
@Override
public String toString() {
return "Person{" +
"s=" + s +
'}';
}
}
那么我们在创建对象的时候，就可以传入不同的数据类型的数据，这很方便：😋
例如：
Person<String> stringPerson = new Person<String>("www");
System.out.println(stringPerson);
Person<Integer> integerPerson = new Person<Integer>(521);
System.out.println(integerPerson);
-------------------------------
输出：
Person{s=www}
Person{s=521}
泛型的<>里面只能是引用类型，不可以为基本数据类型🤪
在给泛型指定具体类型后，可以传入该类型或者该类型的子类型
在实际的开发中，我们一般采用简写的泛型语法（去掉后面<>里面的内容），例如：
Person<Double> doublePerson = new Person<>(13.14);
如果不给泛型指定具体的数据类型，默认为Object类型✨
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
接下来，我们看一个自定义泛型类的例子：
/**
* 自定义泛型类
*/
class Tiger<T,R,M> {
String name;
R r;
M m;
T t;
public Tiger(String name, R r, M m, T t) {
this.name = name;
this.r = r;
this.m = m;
this.t = t;
}
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;
}
}
Object类型自定义泛型接口的例子：
/**
* 自定义泛型接口
*/
interface IUsb<U, R> {
R get(U u);
void hi(R r);
void run(R r1, R r2, U u1, U u2);
default R method(U u) {
return null;
}
}
这个自定义泛型的接口，如果有接口想要继承他，可以在继承接口时指定泛型接口的类型：
/**
* 继承接口时指定泛型接口的类型
*/
interface IA extends IUsb<String,Double>{
}
现在当我们实现IA接口时，会用String和Double类型替换我们接口原有的U和R类型：
例如：
/**
* 实现自定义的泛型接口
*/
class TTT implements IA {
@Override
public Double get(String s) {
return null;
}
@Override
public void hi(Double aDouble) {
}
@Override
public void run(Double r1, Double r2, String u1, String u2) {
}
}
当然，我们也可以在实现接口的同时指定接口的数据类型，例如：
/**
* 实现IUsb接口
*/
class III implements IUsb<Integer,String> {
@Override
public String get(Integer integer) {
return null;
}
@Override
public void hi(String s) {
}
@Override
public void run(String r1, String r2, Integer u1, Integer u2) {
}
}
使用代码示例：
public class AdvancedGenerics {
public static void main(String[] args) {
fly("保密",521);
fly(12,true);
}
/**
* 自定义泛型方法
*/
static public <T, R> void fly(T t, R r) {
System.out.println(t);
System.out.println(r);
}
}
---------------------------
输出：
保密
521
12
true
泛型不具备继承性
类型通配符一般是使用 ? 代替具体的类型参数。例如 List 在逻辑上是List等所有 List<具体类型实参> 的父类
/**
* 任意泛型类型
*/
public static void printCollection(List<?> c){
for (Object o : c) {
System.out.println(o);
}
}
表示该通配符所代表的类型是T类型的子类。
表示该通配符所代表的类型是T类型的父类。
/**
* ? extends 表示上限，如下代表可以接受AA或者AA的子类
*/
public static void printCollection2(List<? extends AA>c){
for (AA aa : c) {
System.out.println(aa);
}
}
/**
* ? super 表示下限，如下表示支持AA类以及AA类的父类，不限于直接父类
*/
public static void printCollection3(List<? super AA>c) {
for (Object o : c) {
System.out.println(o);
}
}
知识给人重量，成就给人光彩，大多数人只是看到了光彩，而不去称量重量。🍳