在Java语言中，为了方便接收参数类型的统一，提供了核心类Object，利用此类对象可以接收所有类型的数据（包括基本数据类型和引用数据类型）。但是由于其所描述的数据范围过大，所以在实际使用中就会出现传入数据类型错误，从而引发异常（主要是强制向下转型引发）。如果想要解决项目中可能出现的这种异常情况，最为核心的方案就是避免强制性地进行对象向下转型操作。所以泛型设计的核心思想在于：类中的属性或方法的参数与返回值的类型采用动态标志，在对象实例化的时候动态配置要使用的数据类型。
class Point<T> {
private T x;
private T y;
public void setX(T x) {
this.x = x;
}
public void setY(T y) {
this.y = y;
}
public T getX() {
return this.x;
}
public T getY() {
return this.y;
}
}class JavaDemo {
public static void main(String[] args) {
// 设置int类型
Point<Integer> p = new Point<Integer>();
p.setX(120);
p.setT(100);
int x = p.getX();
int y = p.getY();
System.out.println("x坐标：" + x + "，y坐标：" + y);
// 设置String类型
Point<String> p2 = new Point<String>();
p2.setX('x坐标：100');
p2.setY('y坐标：120');
String m = p2.getX();
String n = p2.getY();
System.out.println(m + '，' + n);
}
}泛型在类上标志出现后，需要通过实例化对象进行类型的设置，而所设置的类型只能是引用数据类型。如果要设置基本数据类型，则必须采用包装类的形式。
泛型通配符
利用泛型类在实例化对象时进行的动态类型匹配，虽然可以有效地解决对象向下转型的安全隐患，但是在程序中实例化泛型类对象时，不同泛型类型的对象之间彼此是无法进行引用传递的，所以在进行泛型类型的引用对象时，为了可以适应所有本类的实例化对象，则可以在接受时使用【“?”】作为泛型通配符使用，利用【“?”】表示的泛型类型只允许从对象中获取数据，而不允许修改数据。
class Message<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return this.content;
}
}class JavaDemo {
public static void main(String[] args) {
Message<String> msg = new Message<String>();
msg.setContent('www.uihtml.cn');
printMsg(msg);
}
public static void printMsg(Message<?> msg) {
System.out.println(msg.getContent());
}
}本程序在printMsg()方法的参数上使用Message<?>接收Message类的引用对象，由于通配符【“?”】的作用，所以该方法可以匹配任意的泛型类型（Message<String>或Message<Integer>等都可以）。
通配符【“?”】除了可以匹配任意的泛型类型外，也可以通过泛型上限和下限的配置实现更加严格的类范围定义。
- 【类和方法】设置泛型的上限【? extends 类】：只能使用当前类或当前类的子类设置泛型类型。
- 【方法】设置泛型的下限【? super 类】：只能设置指定的类或指定类的父类。
设置泛型上限
class Message<T extends Number> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return this.content;
}
}可以设置Number类或Number的子类（Integer、Double）
class JavaDemo {
public static void main(String[] args) {
Message<Integer> msg = new Message<Integer>();
msg.setContent(100);
printMsg(msg);
Message<Double> msg1 = new Message<Double>();
msg1.setContent(99.5);
printMsg(msg1);
}
public static printMsg(Message<? extends Number> msg) {
System.out.println('期末考试成绩为：' + msg.getContent());
}
}设置泛型下限
class Message<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return this.content;
}
} class JavaDemo {
public static void main(String[] args) {
Message<String> msg = new Message<String>();
msg.setContent('最好的程序员学习平台：www.uihtml.cn');
printMsg(msg);
}
public static void PrintMsg(Message<? super String> msg) {
System.out.println(msg.getContent());
}
}泛型接口
定义泛型接口子类，在子类中继续声明泛型
interface IMessage<T> {
public String echo(T msg);
}class MessageImpl implements IMessage<S> {
@Override
public String echo(S t) {
return '【ECHO】' + t;
}
}class JavaDemo {
public static void main(String[] args) {
IMessage<String> msg = new MessageImpl<String>();
System.out.println(msg.echo('www.uihtml.cn'));
}
}本程序定义MessageImpl子类时继续声明了一个泛型标记S，并且实例化MessageImpl子类对象时设置的泛型类型也会传递到IMessage接口中。
定义子类，在子类中设置泛型类型
interface IMessage<T> {
public String echo(T msg);
}class MessageImpl implements IMessage<String> {
public String echo(String t) {
return '【ECHO】' + t;
}
}class JavaDemo {
public static void main(String[] args) {
IMessage<String> msg = new MessageImpl();
System.out.println(msg.echo('www.uihtml.cn'));
}
}本程序在定义MessageImpl子类时没有定义泛型标记，而是为父接口设置泛型类型为String，所以在覆写echo()方法时参数的类型就是String。
泛型方法
对于泛型，除了可以定义在类上之外，也可以在方法上进行定义，而在方法上定义泛型的时候，这个方法不一定非要在泛型类型定义。
class JavaDemo {
public static void main(String[] args) {
Integer num[] = fun(1,2,3,4,5);
for (int temp : num) {
System.out.println(temp + '、');
}
}
public static <T> T[] fun(T... args) {
return args;
}
}由于此时是在一个没有泛型声明的类中定义了泛型方法，所以在fun()方法声明处就必须单独定义泛型标记，此时的泛型类型将由传入的参数类型来决定。
原创文章，作者：ZERO，如若转载，请注明出处：https://www.edu24.cn/course/java/java-genericity.html
微信扫一扫 
支付宝扫一扫 
