1、晓之以理，动之以码
学Java就是很上头哦，一来直接三连问！！！
什么是泛型？为什么要用泛型？泛型怎么用？
当然泛型在Java中有很重要的一个地位，在面向对象编程以及在各种设计模式中有非常广泛的应用~
1.1 什么是泛型？
泛型：
本意就是“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
1.2 一个栗子
一个被举烂的例子
package com.example.main; /**
* @author lin
* @version 1.0
* @date 2020/7/12 21:31
* @Description TODO
*/
public class TestTypeMain {
private static int add(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
} private static float add(float a, float b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
} private static double add(double a, double b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
} private static <T extends Number> double add(T a, T b) {
System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
return a.doubleValue() + b.doubleValue();
} public static void main(String[] args) {
System.out.println(TestTypeMain.add(1, 2));
System.out.println(TestTypeMain.add(1f, 2f));
System.out.println(TestTypeMain.add(1d, 2d));
System.out.println(TestTypeMain.add(Integer.valueOf(1), Integer.valueOf(2)));
System.out.println(TestTypeMain.add(Float.valueOf(1), Float.valueOf(2)));
System.out.println(TestTypeMain.add(Double.valueOf(1), Double.valueOf(2)));
} }
运行结果：
1+2=3
3
1.0+2.0=3.0
3.0
1.0+2.0=3.0
3.0
1+2=3.0
3.0
1.0+2.0=3.0
3.0
1.0+2.0=3.0
3.0
1.3 总结（意义）：
1：减少代码，增强可读性，代码复用性更高
2：显性指定类型，编译器会自动检查，避免运行中的一半的错误。
2、泛型如何使用？
2.1 泛型可以用到哪里？
1、泛型方法：public static < E > void printArray( E[] inputArray )
public static <T extends Comparable<T>> T maximum(T x, T y, T z)
2、泛型类：public class Box<T> { private T t; }
3、泛型接口：public interface Generator<T> { public T next(); }
4、泛型通配符：List<String> list= new ArrayList<String>();
2.2 泛型类型的变量
E：元素（Element），多用于java集合框架
K：关键字（Key）
N：数字（Number）
T：类型（Type）
V：值（Value）
2.3 泛型方法
简单的泛型方法入门可以参考上面的那个栗子. 另外通过一个例子，把泛型方法再总结一下。
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如：public <T,K> K showKeyName(Generic<T> container){
* ...
* }
*/
public <T> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
} //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
} //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
//同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
public void showKeyValue2(Generic<?> obj){
Log.d("泛型测试","key value is " + obj.getKey());
} /**
* 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
public <T> T showKeyName(Generic<E> container){
...
}
*/ /**
* 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
* 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
public void showkey(T genericObj){ }
*/
此外:
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如：public <T,K> K showKeyName(Generic<T> container){
* ...
* }
*/
public <T> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
} //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
} //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
//同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
public void showKeyValue2(Generic<?> obj){
Log.d("泛型测试","key value is " + obj.getKey());
} /**
* 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
public <T> T showKeyName(Generic<E> container){
...
}
*/ /**
* 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
* 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
public void showkey(T genericObj){ }
*/
2.4 泛型类
定义一个泛型类：public class GenericClass{}
package com.example.main; /**
* @author lin
* @version 1.0
* @date 2020/7/12 21:49
* @Description 泛型类
*/
public class GenericClass<T> {
private T data; public T getData() {
return data;
} public void setData(T data) {
this.data = data;
} public static void main(String[] args) {
GenericClass<String> genericClass = new GenericClass<>();
genericClass.setData("Generic Class");
System.out.println(genericClass.getData());
}
}
2.5 泛型接口
定义一个泛型接口：public interface GenericIntercace{}
package com.example.main; /**
* @author lin
* @version 1.0
* @date 2020/7/12 21:50
* @Description TODO
*/
public interface GenericInterface<T> {
public T getData();
}
实现泛型接口不指定类型方式一：
public class ImplGenericInterface1 implements GenericIntercace
package com.example.main; /**
* @author lin
* @version 1.0
* @date 2020/7/12 21:53
* @Description TODO
*/
public class ImplGenericInterface1<T> implements GenericInterface<T> {
private T data; private void setData(T data) {
this.data = data;
} @Override
public T getData() {
return this.data;
} public static void main(String[] args) {
ImplGenericInterface1<String> implGenericInterface1 = new ImplGenericInterface1<>();
implGenericInterface1.setData("Generic Interface1");
System.out.println(implGenericInterface1.getData());
}
}
实现泛型接口指定类型方式二:
public class ImplGenericInterface2 implements GenericIntercace<String> {}
package com.example.main; /**
* @author lin
* @version 1.0
* @date 2020/7/12 21:55
* @Description TODO
*/
public class ImplGenericInterface2 implements GenericInterface<String> {
@Override
public String getData() {
return "hello world ";
} public static void main(String[] args) {
ImplGenericInterface2 implGenericInterface2 = new ImplGenericInterface2();
System.out.println(implGenericInterface2.getData());
}
}
2.6 泛型通配符
引入通配符可以在泛型实例化时更加灵活地控制，也可以在方法中控制方法的参数。
语法如下：
泛型类名<? extends T> 或 泛型类名<? super T> 或 泛型类名<?>? extends T：表示T或T的子类
? super T：表示T或T的父类
?：表示可以是任意类型
常用的 T，E，K，V，？
本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：
2.6.1、？表示不确定的 java 类型
static int countLegs (List<? extends Animal > animals ) {
int retVal = 0;
for ( Animal animal : animals )
{
retVal += animal.countLegs();
}
return retVal;
}
static int countLegs1 (List< Animal > animals ){
int retVal = 0;
for ( Animal animal : animals )
{
retVal += animal.countLegs();
}
return retVal;
}2.6.2、T (type) 表示具体的一个java类型
下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object
在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
private <T> void test(List<? super T> dst, List<T> src){
for (T t : src) {
dst.add(t);
}
}
public static void main(String[] args) {
List<Dog> dogs = new ArrayList<>();
List<Animal> animals = new ArrayList<>();
new Test3().test(animals,dogs);
}实例：
class gent<T> {
public void test() {
System.out.println("gent");
}
}
class supC {
public String toString() {
return "supA";
}
}
public class Bc extends supC {
String b;
public Bc( String b ) {
this.b = b;
}
public String toString() {
return "subB";
}
// 指明泛型参数必须是supC或其子类
public void test( gent<? extends supC> o ) {
System.out.println("Bc");
}
public static void main( String[] args ) {
Bc bc = new Bc("test");
gent<Bc> oGent = new gent<Bc>();
bc.test(oGent); // oGent 是supC的子类对象
}
}3、泛型注意点
3.1 静态方法与泛型
静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。
public class StaticGenerator<T> {
....
....
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void show(T t){..},此时编译器会提示错误信息：
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t){
}
}3.2 泛型类型继承规则
1,对于泛型参数是继承关系的泛型类之间是没有继承关系的 2,泛型类可以继承其它泛型类，例如: public class ArrayList<E> extends AbstractList<E> 3,泛型类的继承关系在使用中同样会受到泛型类型的影响
/**
* Author：lin 2020/7/12 21:55
* <p>
* Description: 泛型继承规则测试类
*/
public class GenericInherit<T> {
private T data1;
private T data2; public T getData1() {
return data1;
} public void setData1(T data1) {
this.data1 = data1;
} public T getData2() {
return data2;
} public void setData2(T data2) {
this.data2 = data2;
} public static <V> void setData2(GenericInherit<Father> data2) { } public static void main(String[] args) {
// Son 继承自 Father
Father father = new Father();
Son son = new Son();
GenericInherit<Father> fatherGenericInherit = new GenericInherit<>();
GenericInherit<Son> sonGenericInherit = new GenericInherit<>();
SubGenericInherit<Father> fatherSubGenericInherit = new SubGenericInherit<>();
SubGenericInherit<Son> sonSubGenericInherit = new SubGenericInherit<>(); /**
* 对于传递的泛型类型是继承关系的泛型类之间是没有继承关系的
* GenericInherit<Father> 与GenericInherit<Son> 没有继承关系
* Incompatible types.
*/
father = new Son();
// fatherGenericInherit=new GenericInherit<Son>(); /**
* 泛型类可以继承其它泛型类，例如: public class ArrayList<E> extends AbstractList<E>
*/
fatherGenericInherit=new SubGenericInherit<Father>(); /**
*泛型类的继承关系在使用中同样会受到泛型类型的影响
*/
setData2(fatherGenericInherit);
// setData2(sonGenericInherit);
setData2(fatherSubGenericInherit);
// setData2(sonSubGenericInherit); } private static class SubGenericInherit<T> extends GenericInherit<T> { }
3.3 虚拟机是如何实现泛型的
Java泛型是Java1.5之后才引入的，为了向下兼容。Java采用了C++完全不同的实现思想。Java中的泛型更多的看起来像是编译期用的 Java中泛型在运行期是不可见的，会被擦除为它的上级类型。如果是没有限定的泛型参数类型，就会被替换为Object.
GenericClass<String> stringGenericClass=new GenericClass<>();
GenericClass<Integer> integerGenericClass=new GenericClass<>();
C++中GenericClass<String>和GenericClass<Integer>是两个不同的类型 Java进行了类型擦除之后统一改为GenericClass<Object>
/**
* Author：lin 2020/7/12 21:55
* <p>
* Description:泛型原理测试类
*/
public class GenericTheory {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("Key", "Value");
System.out.println(map.get("Key"));
GenericClass<String, String> genericClass = new GenericClass<>();
genericClass.put("Key", "Value");
System.out.println(genericClass.get("Key"));
} public static class GenericClass<K, V> {
private K key;
private V value; public void put(K key, V value) {
this.key = key;
this.value = value;
} public V get(V key) {
return value;
}
} /**
* 类型擦除后GenericClass2<Object>
* @param <T>
*/
private class GenericClass2<T> { } /**
* 类型擦除后GenericClass3<ArrayList>
* 当使用到Serializable时会将相应代码强制转换为Serializable
* @param <T>
*/
private class GenericClass3<T extends ArrayList & Serializable> { }
}
对应的字节码文件
public static void main(String[] args) {
Map<String, String> map = new HashMap();
map.put("Key", "Value");
System.out.println((String)map.get("Key"));
GenericTheory.GenericClass<String, String> genericClass = new GenericTheory.GenericClass();
genericClass.put("Key", "Value");
System.out.println((String)genericClass.get("Key"));
}4.学以致用
1，泛型解析JSON数据封装
api返回的json数据
{
"code":200,
"msg":"成功",
"data":{
"name":"Lin",
"email":"10086"
}
}
BaseResponse .java/**
* Author：lin 2020/7/12 21:55
* <p>
* Description: 接口数据接收基类
*/
public class BaseResponse { private int code;
private String msg; public int getCode() {
return code;
} public void setCode(int code) {
this.code = code;
} public String getMsg() {
return msg;
} public void setMsg(String msg) {
this.msg = msg;
}
}
UserResponse.java
/**
* Author：lin 2020/7/12 21:55
* <p>
* Description: 用户信息接口实体类
*/
public class UserResponse<T> extends BaseResponse {
private T data; public T getData() {
return data;
} public void setData(T data) {
this.data = data;
}
}
2，泛型+反射实现巧复用工具类
/**
* Author：lin 2020/7/12 21:55
* <p>
* Description: 泛型相关的工具类
*/
public class GenericUtils { public static class Movie {
private String name;
private Date time; public String getName() {
return name;
} public Date getTime() {
return time;
} public Movie(String name, Date time) {
this.name = name;
this.time = time;
} @Override
public String toString() {
return "Movie{" + "name='" + name + '\'' + ", time=" + time + '}';
}
} public static void main(String[] args) {
List<Movie> movieList = new ArrayList<>();
for (int i = 0; i < 5; i++) {
movieList.add(new Movie("movie" + i, new Date()));
}
System.out.println("排序前:" + movieList.toString()); GenericUtils.sortAnyList(movieList, "name", true);
System.out.println("按name正序排：" + movieList.toString()); GenericUtils.sortAnyList(movieList, "name", false);
System.out.println("按name逆序排：" + movieList.toString());
} /**
* 对任意集合的排序方法
* @param targetList 要排序的实体类List集合
* @param sortField 排序字段
* @param sortMode true正序，false逆序
*/
public static <T> void sortAnyList(List<T> targetList, final String sortField, final boolean sortMode) {
if (targetList == null || targetList.size() < 2 || sortField == null || sortField.length() == 0) {
return;
}
Collections.sort(targetList, new Comparator<Object>() {
@Override
public int compare(Object obj1, Object obj2) {
int retVal = 0;
try {
// 获取getXxx()方法名称
String methodStr = "get" + sortField.substring(0, 1).toUpperCase() + sortField.substring(1);
Method method1 = ((T) obj1).getClass().getMethod(methodStr, null);
Method method2 = ((T) obj2).getClass().getMethod(methodStr, null);
if (sortMode) {
retVal = method1.invoke(((T) obj1), null).toString().compareTo(method2.invoke(((T) obj2), null).toString());
} else {
retVal = method2.invoke(((T) obj2), null).toString().compareTo(method1.invoke(((T) obj1), null).toString());
}
} catch (Exception e) {
System.out.println("List<" + ((T) obj1).getClass().getName() + ">排序异常！");
e.printStackTrace();
}
return retVal;
}
});
}
}
3，Gson库中的泛型的使用-TypeToken
/**
* Author：Jay On 2019/5/11 22:11
* <p>
* Description: Gson库中的泛型使用
*/
public class GsonGeneric {
public static class Person {
private String name;
private int age; public Person(String name, int age) {
this.name = name;
this.age = age;
} @Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
} public static void main(String[] args) {
Gson gson = new Gson();
List<Person> personList = new ArrayList<>();
for (int i = 0; i < 5; i++) {
personList.add(new Person("name" + i, 18 + i));
}
// Serialization
String json = gson.toJson(personList);
System.out.println(json);
// Deserialization
Type personType = new TypeToken<List<Person>>() {}.getType();
List<Person> personList2 = gson.fromJson(json, personType);
System.out.println(personList2);
}
}
发哥讲
如果你觉得文章还不错，就请点击右上角选择发送给朋友或者转发到朋友圈~
● 扫码关注公众号