泛型是什么
将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形 参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说 在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、 泛型方法。
为什么我们需要泛型
示例一：如果我们需要一个功能，如果参数类型每改变一次，就要再重新写一遍方法，那么代码就会产生冗余。
public class NonGeneric {
public int addInt(int a, int b) {
return a + b;
}
public Float addFloat(float a, float b) {
return a + b;
}
public static void main(String[] args) {
NonGeneric nonGeneric = new NonGeneric();
System.out.println(nonGeneric.addInt(1, 2));
System.out.println(nonGeneric.addFloat(1f, 2f));
}
}
示例二：
ArrayList list = new ArrayList();
list.add("cycy");
list.add(1);
for (int i=0;i<list.size();i++) {
String name = list.get(i);
System.out.println(name);
}
这里程序会报错：兼容的类型: Object无法转换为String。list默认的类型会是Object类型，如果不会String类型，那么转为String类型就会报错。
那么泛型就能解决如上两种情况的问题，使用泛型可以使多种数据类型使用同一段代码，泛型能在编译期校验出不合法的类型。
泛型类，泛型接口，泛型方法的定义
定义泛型类，如T就能代表一个任意的类型。
class NormalGeneric<T> {
private T data;
public NormalGeneric(T data) {
this.data = data;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public static void main(String[] args) {
NormalGeneric normalGeneric = new NormalGeneric<String>("data");
System.out.println(normalGeneric.getData());
}
}
泛型类型个数可以不定：
class BaseResponse<T, K> {
protected int code;
protected T data;
protected K msg;
}
泛型类型的继承规则
定义泛型接口，这里再使用泛型类去实现，对于泛型类型的继承，可以继续使用泛型类型，也可以在继承中去指定具体类型。
interface Generitor<T> {
T next();
}
public class Generitorimpl<T> implements Generitor<T> {
@Override
public T next() {
return null;
}
}
public class Generitorimpl<T> implements Generitor<String> {
@Override
public String next() {
return null;
}
}
定义泛型方法并使用：
class GenericMethod {
public <T> T genericMethod(T ...a) {
return a[a.length-1];
}
public static void main(String[] args) {
//声明调用genericMethod方法的泛型为String类型
String name = new GenericMethod().<String>genericMethod("xiaoming", "xiaohong", "xiaowang");
int num = new GenericMethod().genericMethod(1, 2, 3);
System.out.println(name);
System.out.println(num);
}
}
限定类型变量
在泛型中，我们要求泛型类型有一定的特征，我们就要对泛型类型做某种限定：
在方法中使用泛型限定：
class GetMaxValue {
/**
* 限定T需要实现Comparable接口，才能对T类型进行比较
* extends继承的可以是类，也可以是接口
*/
public static <T extends Comparable> T max(T a, T b) {
if (a.compareTo(b) > 0) {
return a;
} else {
return b;
}
}
public static void main(String[] args) {
System.out.println(max(2,5));
}
}
在类中使用泛型限定：
class GetMaxValue2<T extends Comparable> {
private T data;
public GetMaxValue2(T data) {
this.data = data;
}
public T getData() {
return data;
}
public T max(T other) {
if (data.compareTo(other) > 0) {
return data;
} else {
return other;
}
}
public static void main(String[] args) {
GetMaxValue2 getMaxValue2 = new GetMaxValue2("A");
System.out.println(getMaxValue2.max("B"));
}
}
通配符类型
常用的通配符有常用的 T，E，K，V，？
T (type) 表示具体的一个java类型
K V (key value) 分别代表java键值中的Key Value
E (element) 代表Element
？ 表示不确定的 java 类型
上界通配符 < ? extends E>
在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类。
下界通配符 < ? super E>
在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
？和 T 的区别
？和 T 都表示不确定的类型，区别在于我们可以对 T 进行操作，但是对 ？不行，比如如下这种 ：
// 可以
T t = operate();
// 不可以
？car = operate();
泛型中的约束和局限性
如下3中使用泛型方式都是错误的：
class GenericLimit<T> {
private T data;
public GenericLimit() {
data = new T(); //1.泛型类型不能直接创建对象
}
private static T instance; //2.静态变量不能用泛型类型声明
private void createInstance() {
GenericLimit<double> instance = new GenericLimit<double>(); //3.基本数据类型不能用作泛型变量
}
}
虚拟机是如何实现泛型的
Java 语言中的泛型，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（RawType，也称为裸类 型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的 Java 语言来说，ArrayList＜int＞与 ArrayList＜String＞就是同一 个类，所以泛型技术实际上是 Java 语言的一颗语法糖，Java 语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。
网友评论