java 反射和泛型

Posted huangzp1104

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 反射和泛型相关的知识,希望对你有一定的参考价值。

反射

计算机科学中,反射是指计算机程序运行时Run time)可以访问、检测和修改它本身状态或行为的一种能力。[1]用比喻来说,反射就是程序在运行的时候能够“观察”并且修改自己的行为。

要注意术语“反射”和“内省”(type introspection)的关系。内省(或称“自省”)机制仅指程序在运行时对自身信息(称为元数据)的检测;反射机制不仅包括要能在运行时对程序自身信息进行检测,还要求程序能进一步根据这些信息改变程序状态或结构。--------wiki中文

java 的反射:

1、获得Class对象

方法有三种
(1)使用Class类的forName静态方法:

1
2
3
4
5
public static Class<?> forName(String className)
```
在JDBC开发中常用此方法加载数据库驱动:
```java
Class.forName(driver);

 

(2)直接获取某一个对象的class,比如:

1
2
Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

 

(3)调用某个对象的getClass()方法,比如:

1
2
StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

 

2、判断是否为某个类的实例

一般地,我们用instanceof关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的isInstance()方法来判断是否为某个类的实例,它是一个Native方法:

1
public native boolean isInstance(Object obj);

 

3、创建实例

通过反射来生成对象主要有两种方式。
(1)使用Class对象的newInstance()方法来创建Class对象对应类的实例。

1
2
Class<?> c = String.class;
Object str = c.newInstance();

 

(2)先通过Class对象获取指定的Constructor对象,再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例。

1
2
3
4
5
6
7
//获取String所对应的Class对象
Class<?> c = String.class;
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);
//根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

 

4、获取方法

获取某个Class对象的方法集合,主要有以下几个方法:
getDeclaredMethods()方法返回类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。

1
public Method[] getDeclaredMethods() throws SecurityException

 

getMethods()方法返回某个类的所有公用(public)方法,包括其继承类的公用方法。

1
public Method[] getMethods() throws SecurityException

 

getMethod方法返回一个特定的方法,其中第一个参数为方法名称,后面的参数为方法的参数对应Class的对象

1
public Method getMethod(String name, Class<?>... parameterTypes)

 

只是这样描述的话可能难以理解,我们用例子来理解这三个方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package org.ScZyhSoft.common;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class test1 {
public static void test() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> c = methodClass.class;
Object object = c.newInstance();
Method[] methods = c.getMethods();
Method[] declaredMethods = c.getDeclaredMethods();
//获取methodClass类的add方法
Method method = c.getMethod("add", int.class, int.class);
//getMethods()方法获取的所有方法
System.out.println("getMethods获取的方法:");
for(Method m:methods)
System.out.println(m);
//getDeclaredMethods()方法获取的所有方法
System.out.println("getDeclaredMethods获取的方法:");
for(Method m:declaredMethods)
System.out.println(m);
}
}
class methodClass {
 
public final int fuck = 3;
public int add(int a,int b) {
return a+b;
}
public int sub(int a,int b) {
return a+b;
}
}

 

程序运行的结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
getMethods获取的方法:
public int org.ScZyhSoft.common.methodClass.add(int,int)
public int org.ScZyhSoft.common.methodClass.sub(int,int)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
getDeclaredMethods获取的方法:
public int org.ScZyhSoft.common.methodClass.add(int,int)
public int org.ScZyhSoft.common.methodClass.sub(int,int)

 

可以看到,通过getMethods()获取的方法可以获取到父类的方法,比如java.lang.Object下定义的各个方法。

5、获取构造器信息

获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的一个实例,而Constructor类有一个newInstance方法可以创建一个对象实例:

1
public T newInstance(Object ... initargs)

 

此方法可以根据传入的参数来调用对应的Constructor创建对象实例~

6、获取类的成员变量(字段)信息

主要是这几个方法,在此不再赘述:
getFiled: 访问公有的成员变量
getDeclaredField:所有已声明的成员变量。但不能得到其父类的成员变量
getFileds和getDeclaredFields用法同上(参照Method)

7、调用方法

当我们从类中获取了一个方法后,我们就可以用invoke()方法来调用这个方法。invoke方法的原型为:

1
2
3
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException

 

下面是一个实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class test1 {
 
public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> klass = methodClass.class;
//创建methodClass的实例
Object obj = klass.newInstance();
//获取methodClass类的add方法
Method method = klass.getMethod("add",int.class,int.class);
//调用method对应的方法 => add(1,4)
Object result = method.invoke(obj,1,4);
System.out.println(result);
}
 
}
 
class methodClass {
 
public final int fuck = 3;
public int add(int a,int b) {
return a+b;
}
public int sub(int a,int b) {
return a+b;
}
}

 

关于invoke()方法的详解,后面我会专门写一篇文章来深入解析invoke的过程。

8、利用反射创建数组

数组在Java里是比较特殊的一种类型,它可以赋值给一个Object Reference。下面我们看一看利用反射创建数组的例子:

1
2
3
4
5
6
7
8
9
10
11
12
public static void testArray() throws ClassNotFoundException {
Class<?> cls = Class.forName("java.lang.String");
Object array = Array.newInstance(cls,25);
//往数组里添加内容
Array.set(array,0,"hello");
Array.set(array,1,"Java");
Array.set(array,2,"fuck");
Array.set(array,3,"Scala");
Array.set(array,4,"Clojure");
//获取某一项的内容
System.out.println(Array.get(array,3));
}

 

其中的Array类为java.lang.reflect.Array类。我们通过Array.newInstance()创建数组对象,它的原型是:

1
2
3
4
public static Object newInstance(Class<?> componentType, int length)
throws NegativeArraySizeException {
return newArray(componentType, length);
}

 

而newArray()方法是一个Native方法,它在Hotspot JVM里的具体实现我们后边再研究,这里先把源码贴出来

1
2
private static native Object newArray(Class<?> componentType, int length)
throws NegativeArraySizeException;

 

源码目录:openjdkhotspotsrcsharevm untime eflection.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
if (element_mirror == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
if (length < 0) {
THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
}
if (java_lang_Class::is_primitive(element_mirror)) {
Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
} else {
Klass* k = java_lang_Class::as_Klass(element_mirror);
if (k->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
return oopFactory::new_objArray(k, length, THREAD);
}
}

 

另外,Array类的set()和get()方法都为Native方法,在HotSpot JVM里分别对应Reflection::array_set和Reflection::array_get方法,这里就不详细解析了。

详见:极客学院wiki

http://wiki.jikexueyuan.com/project/java-reflection/

 

泛型

泛型程序设计(generic programming)是程序设计语言的一种风格或范式。泛型允许程序员强类型程序设计语言中编写代码时使用一些以后才指定的类型,在实例化时作为参数指明这些类型。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。 -------------------wiki中文


(转自https://blog.csdn.net/qq_27093465/article/details/73229016)

1、泛型类定义及使用

我们先看看泛型的类是怎么定义的:

 

 

[java] view plain copy
 
 
  1. //定义  
  2. class Point<T>{// 此处可以随便写标识符号   
  3.     private T x ;        
  4.     private T y ;        
  5.     public void setX(T x){//作为参数  
  6.         this.x = x ;  
  7.     }  
  8.     public void setY(T y){  
  9.         this.y = y ;  
  10.     }  
  11.     public T getX(){//作为返回值  
  12.         return this.x ;  
  13.     }  
  14.     public T getY(){  
  15.         return this.y ;  
  16.     }  
  17. };  
  18. //IntegerPoint使用  
  19. Point<Integer> p = new Point<Integer>() ;   
  20. p.setX(new Integer(100)) ;   
  21. System.out.println(p.getX());    
  22.   
  23. //FloatPoint使用  
  24. Point<Float> p = new Point<Float>() ;   
  25. p.setX(new Float(100.12f)) ;   
  26. System.out.println(p.getX());    

先看看运行结果:
技术分享图片

 

从结果中可以看到,我们实现了开篇中IntegerPoint类和FloatPoint类的效果。下面来看看泛型是怎么定义及使用的吧。

(1)、定义泛型:Point<T>
首先,大家可以看到Point<T>,即在类名后面加一个尖括号,括号里是一个大写字母。这里写的是T,其实这个字母可以是任何大写字母,大家这里先记着,可以是任何大写字母,意义是相同的。
(2)类中使用泛型
这个T表示派生自Object类的任何类,比如String,Integer,Double等等。这里要注意的是,T一定是派生于Object类的。为方便起见,大家可以在这里把T当成String,即String在类中怎么用,那T在类中就可以怎么用!所以下面的:定义变量,作为返回值,作为参数传入的定义就很容易理解了。

 

[java] view plain copy
 
 
  1. //定义变量  
  2. private T x ;   
  3. //作为返回值  
  4. public T getX(){   
  5.     return x ;    
  6. }    
  7. //作为参数  
  8. public void setX(T x){    
  9.     this.x = x ;    
  10. }   

(3)使用泛型类
下面是泛型类的用法:

[java] view plain copy
 
 
  1. //IntegerPoint使用  
  2. Point<Integer> p = new Point<Integer>() ;   
  3. p.setX(new Integer(100)) ;   
  4. System.out.println(p.getX());    
  5.   
  6. //FloatPoint使用  
  7. Point<Float> p = new Point<Float>() ;   
  8. p.setX(new Float(100.12f)) ;   
  9. System.out.println(p.getX());    

首先,是构造一个实例:

[java] view plain copy
 
 
  1. Point<String> p = new Point<String>() ;   

这里与普通构造类实例的不同之点在于,普通类构造函数是这样的:Point p = new Point() ; 
而泛型类的构造则需要在类名后添加上<String>,即一对尖括号,中间写上要传入的类型。
因为我们构造时,是这样的:class Point<T>,所以在使用的时候也要在Point后加上类型来定义T代表的意义。
然后在getVar()和setVar()时就没有什么特殊的了,直接调用即可。
从上面的使用时,明显可以看出泛型的作用,在构造泛型类的实例的时候:

[java] view plain copy
 
 
  1. //IntegerPoint使用  
  2. Point<Integer> p = new Point<Integer>() ;   
  3. //FloatPoint使用  
  4. Point<Float> p = new Point<Float>() ;   

尖括号中,你传进去的是什么,T就代表什么类型。这就是泛型的最大作用,我们只需要考虑逻辑实现,就能拿给各种类来用。
前面我们提到ArrayList也是泛型,我们顺便它的实现:

[java] view plain copy
 
 
  1. public class ArrayList<E>{  
  2.     …………  
  3. }  

看到了吧,跟我们的Point实现是一样的,这也就是为什么ArrayList能够盛装各种类型的主要原因。
(4)使用泛型实现的优势
相比我们开篇时使用Object的方式,有两个优点:
(1)、不用强制转换

 

 

[java] view plain copy
 
 
  1. //使用Object作为返回值,要强制转换成指定类型  
  2. Float floatX = (Float)floatPoint.getX();  
  3. //使用泛型时,不用强制转换,直接出来就是String  
  4. System.out.println(p.getVar());   

(2)、在settVar()时如果传入类型不对,编译时会报错
技术分享图片

 

可以看到,当我们构造时使用的是String,而在setVar时,传进去Integer类型时,就会报错。而不是像Object实现方式一样,在运行时才会报强制转换错误。

 

2、多泛型变量定义及字母规范

(1)、多泛型变量定义
上在我们只定义了一个泛型变量T,那如果我们需要传进去多个泛型要怎么办呢?
只需要在类似下面这样就可以了:

 

[java] view plain copy
 
 
  1. class MorePoint<T,U>{  
  2. }  

也就是在原来的T后面用逗号隔开,写上其它的任意大写字母即可。想加几个就加几个,比如我们想加五个泛型变量,那应该是这样的:

 

 

[java] view plain copy
 
 
  1. class MorePoint<T,U,A,B,C>{  
  2. }  

举个粟子,我们在Point上再另加一个字段name,也用泛型来表示,那要怎么做?代码如下:

[java] view plain copy
 
 
  1. class MorePoint<T,U> {  
  2.     private T x;  
  3.     private T y;         
  4.   
  5.     private U name;  
  6.   
  7.     public void setX(T x) {  
  8.         this.x = x;  
  9.     }  
  10.     public T getX() {  
  11.         return this.x;  
  12.     }  
  13.     …………  
  14.     public void setName(U name){  
  15.         this.name = name;  
  16.     }  
  17.   
  18.     public U getName() {  
  19.         return this.name;  
  20.     }  
  21. }  
  22. //使用  
  23. MorePoint<Integer,String> morePoint = new MorePoint<Integer, String>();  
  24. morePoint.setName("harvic");  
  25. Log.d(TAG, "morPont.getName:" + morePoint.getName());  

从上面的代码中,可以明显看出,就是在新添加的泛型变量U用法与T是一样的。
(2)、字母规范
在定义泛型类时,我们已经提到用于指定泛型的变量是一个大写字母:

[java] view plain copy
 
 
  1. class Point<T>{  
  2.  …………  
  3. }  

当然不是的!!!!任意一个大写字母都可以。他们的意义是完全相同的,但为了提高可读性,大家还是用有意义的字母比较好,一般来讲,在不同的情境下使用的字母意义如下:

  •  E — Element,常用在java Collection里,如:List<E>,Iterator<E>,Set<E>
  •  K,V — Key,Value,代表Map的键值对
  •  N — Number,数字
  •  T — Type,类型,如String,Integer等等

如果这些还不够用,那就自己随便取吧,反正26个英文字母呢。
再重复一遍,使用哪个字母是没有特定意义的!只是为了提高可读性!!!!

3、泛型接口定义及使用

在接口上定义泛型与在类中定义泛型是一样的,代码如下:

 

[java] view plain copy
 
 
  1. interface Info<T>{        // 在接口上定义泛型    
  2.     public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型    
  3.     public void setVar(T x);  
  4. }    

 

与泛型类的定义一样,也是在接口名后加尖括号;
(1)、使用方法一:非泛型类
但是在使用的时候,就出现问题了,我们先看看下面这个使用方法:

 

[java] view plain copy
 
 
  1. class InfoImpl implements Info<String>{   // 定义泛型接口的子类  
  2.     private String var ;                // 定义属性  
  3.     public InfoImpl(String var){        // 通过构造方法设置属性内容  
  4.         this.setVar(var) ;  
  5.     }  
  6.     @Override  
  7.     public void setVar(String var){  
  8.         this.var = var ;  
  9.     }  
  10.     @Override  
  11.     public String getVar(){  
  12.         return this.var ;  
  13.     }  
  14. }  
  15.   
  16. public class GenericsDemo24{  
  17.     public  void main(String arsg[]){  
  18.         InfoImpl i = new InfoImpl("harvic");  
  19.         System.out.println(i.getVar()) ;  
  20.     }  
  21. };  

首先,先看InfoImpl的定义:

[java] view plain copy
 
 
  1. class InfoImpl implements Info<String>{     
  2.  …………  
  3. }  

要清楚的一点是InfoImpl不是一个泛型类!因为他类名后没有<T>!
然后在在这里我们将Info<String>中的泛型变量T定义填充为了String类型。所以在重写时setVar()和getVar()时,IDE会也我们直接生成String类型的重写函数。
最后在使用时,没什么难度,传进去String类型的字符串来构造InfoImpl实例,然后调用它的函数即可。

[java] view plain copy
 
 
  1. public class GenericsDemo24{  
  2.     public  void main(String arsg[]){  
  3.         InfoImpl i = new InfoImpl("harvic");  
  4.         System.out.println(i.getVar()) ;  
  5.     }  
  6. };  

(2)、使用方法二:泛型类

在方法一中,我们在类中直接把Info<T>接口给填充好了,但我们的类,是可以构造成泛型类的,那我们利用泛型类来构造填充泛型接口会是怎样呢?

 

[java] view plain copy
 
 
  1. interface Info<T>{        // 在接口上定义泛型  
  2.     public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型  
  3.     public void setVar(T var);  
  4. }  
  5. class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
  6.     private T var ;             // 定义属性  
  7.     public InfoImpl(T var){     // 通过构造方法设置属性内容  
  8.         this.setVar(var) ;    
  9.     }  
  10.     public void setVar(T var){  
  11.         this.var = var ;  
  12.     }  
  13.     public T getVar(){  
  14.         return this.var ;  
  15.     }  
  16. }  
  17. public class GenericsDemo24{  
  18.     public static void main(String arsg[]){  
  19.         InfoImpl<String> i = new InfoImpl<String>("harvic");  
  20.         System.out.println(i.getVar()) ;  
  21.     }  
  22. };  

 

最关键的是构造泛型类的过程:

[java] view plain copy
 
 
  1. class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
  2.     private T var ;             // 定义属性  
  3.     public InfoImpl(T var){     // 通过构造方法设置属性内容  
  4.         this.setVar(var) ;    
  5.     }  
  6.     public void setVar(T var){  
  7.         this.var = var ;  
  8.     }  
  9.     public T getVar(){  
  10.         return this.var ;  
  11.     }  
  12. }  

在这个类中,我们构造了一个泛型类InfoImpl<T>,然后把泛型变量T传给了Info<T>,这说明接口和泛型类使用的都是同一个泛型变量。
然后在使用时,就是构造一个泛型类的实例的过程,使用过程也不变。

[java] view plain copy
 
 
  1. public class GenericsDemo24{  
  2.     public static void main(String arsg[]){  
  3.         Info<String> i = new InfoImpl<String>("harvic");  
  4.         System.out.println(i.getVar()) ;  
  5.     }  
  6. };  

使用泛型类来继承泛型接口的作用就是让用户来定义接口所使用的变量类型,而不是像方法一那样,在类中写死。
那我们稍微加深点难度,构造一个多个泛型变量的类,并继承自Info接口:

[java] view plain copy
 
 
  1. class InfoImpl<T,K,U> implements Info<U>{   // 定义泛型接口的子类  
  2.      private U var ;      
  3.      private T x;  
  4.      private K y;  
  5.      public InfoImpl(U var){        // 通过构造方法设置属性内容  
  6.          this.setVar(var) ;  
  7.      }  
  8.      public void setVar(U var){  
  9.          this.var = var ;  
  10.      }  
  11.      public U getVar(){  
  12.          return this.var ;  
  13.      }  
  14.  }  

在这个例子中,我们在泛型类中定义三个泛型变量T,K,U并且把第三个泛型变量U用来填充接口Info。所以在这个例子中Info所使用的类型就是由U来决定的。
使用时是这样的:泛型类的基本用法,不再多讲,代码如下:

[java] view plain copy
 
 
  1. public class GenericsDemo24{  
  2.     public  void main(String arsg[]){  
  3.         InfoImpl<Integer,Double,String> i = new InfoImpl<Integer,Double,String>("harvic");  
  4.         System.out.println(i.getVar()) ;  
  5.     }  
  6. }  

4、泛型函数定义及使用

上面我们讲解了类和接口的泛型使用,下面我们再说说,怎么单独在一个函数里使用泛型。比如我们在新建一个普通的类StaticFans,然后在其中定义了两个泛型函数:

[java] view plain copy
 
 
  1. public class StaticFans {  
  2.     //静态函数  
  3.     public static  <T> void StaticMethod(T a){  
  4.         Log.d("harvic","StaticMethod: "+a.toString());  
  5.     }  
  6.     //普通函数  
  7.     public  <T> void OtherMethod(T a){  
  8.         Log.d("harvic","OtherMethod: "+a.toString());  
  9.     }  
  10. }  

上面分别是静态泛型函数和常规泛型函数的定义方法,与以往方法的唯一不同点就是在返回值前加上<T>来表示泛型变量。其它没什么区别。
使用方法如下:

[java] view plain copy
 
 
  1. //静态方法  
  2. StaticFans.StaticMethod("adfdsa");//使用方法一  
  3. StaticFans.<String>StaticMethod("adfdsa");//使用方法二  
  4.   
  5. //常规方法  
  6. StaticFans staticFans = new StaticFans();  
  7. staticFans.OtherMethod(new Integer(123));//使用方法一  
  8. staticFans.<Integer>OtherMethod(new Integer(123));//使用方法二  

结果如下:
技术分享图片

 

首先,我们看静态泛型函数的使用方法:

 

[java] view plain copy
 
 
  1. StaticFans.StaticMethod("adfdsa");//使用方法一  
  2. StaticFans.<String>StaticMethod("adfdsa");//使用方法二  

从结果中我们可以看到,这两种方法的结果是完全一样的,但他们还有些区别的,区别如下:
方法一,可以像普通方法一样,直接传值,任何值都可以(但必须是派生自Object类的类型,比如String,Integer等),函数会在内部根据传进去的参数来识别当前T的类别。但尽量不要使用这种隐式的传递方式,代码不利于阅读和维护。因为从外观根本看不出来你调用的是一个泛型函数。
方法二,与方法一不同的地方在于,在调用方法前加了一个<String>来指定传给<T>的值,如果加了这个<String>来指定参数的值的话,那StaticMethod()函数里所有用到的T类型也就是强制指定了是String类型。这是我们建议使用的方式。
同样,常规泛型函数的使用也有这两种方式:

[java] view plain copy
 
 
  1. StaticFans staticFans = new StaticFans();  
  2. staticFans.OtherMethod(new Integer(123));//使用方法一  
  3. staticFans.<Integer>OtherMethod(new Integer(123));//使用方法二  

可以看到,与平常一样,先创建类的实例,然后调用泛型函数。
方法一,隐式传递了T的类型,与上面一样,不建议这么做。
方法二,显示将T赋值为Integer类型,这样OtherMethod(T a)传递过来的参数如果不是Integer那么编译器就会报错。

进阶:返回值中存在泛型
上面我们的函数中,返回值都是void,但现实中不可能都是void,有时,我们需要将泛型变量返回,比如下面这个函数:

[java] view plain copy
 
 
  1. public static <T> List<T> parseArray(String response,Class<T> object){  
  2.     List<T> modelList = JSON.parseArray(response, object);  
  3.     return modelList;  
  4. }  

函数返回值是List<T>类型。至于传入参数Class<T> object的意义,我们下面会讲。这里也就是想通过这个例子来告诉大家,泛型变量其实跟String,Integer,Double等等的类的使用上没有任何区别,T只是一个符号,可以代表String,Integer,Double……这些类的符号,在泛型函数使用时,直接把T看到String,Integer,Double……中的任一个来写代码就可以了。唯一不同的是,要在函数定义的中在返回值前加上<T>标识泛型;

5、其它用法:Class<T>类传递及泛型数组

(1)、使用Class<T>传递泛型类Class对象
有时,我们会遇到一个情况,比如,我们在使用JSON解析字符串的时候,代码一般是这样的

 

 

[java] view plain copy
 
 
  1. public static List<SuccessModel> parseArray(String response){  
  2.     List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);  
  3.     return modelList;  
  4. }  

其中SuccessModel是自定义的解析类,代码如下,其实大家不用管SuccessModel的定义,只考虑上面的那段代码就行了。写出来SuccessModel的代码,只是不想大家感到迷惑,其实,这里只是fastJson的基本用法而已。
这段代码的意义就是根据SuccessModel解析出List<SuccessModel>的数组。

[java] view plain copy
 
 
  1. public class SuccessModel {  
  2.     private boolean success;  
  3.       
  4.     public boolean isSuccess() {  
  5.         return success;  
  6.     }  
  7.   
  8.     public void setSuccess(boolean success) {  
  9.         this.success = success;  
  10.     }  
  11. }   

那现在,我们把下面这句组装成一个泛型函数要怎么来做呢?

[java] view plain copy
 
 
  1. public static List<SuccessModel> parseArray(String response){  
  2.     List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);  
  3.     return modelList;  
  4. }  

首先,我们应该把SuccessModel单独抽出来做为泛型变量,但parseArray()中用到的SuccessModel.class要怎么弄呢?
先来看代码:

[java] view plain copy
 
 
  1. public static <T> List<T> parseArray(String response,Class<T> object){  
  2.     List<T> modelList = JSON.parseArray(response, object);  
  3.     return modelList;  
  4. }  

注意到,我们用的Class<T> object来传递类的class对象,即我们上面提到的SuccessModel.class。
这是因为Class<T>也是一泛型,它是传来用来装载类的class对象的,它的定义如下:

[java] view plain copy
 
 
  1. public final class Class<T> implements Serializable {  
  2.     …………  
  3. }  

通过Class<T>来加载泛型的Class对象的问题就讲完了,下面来看看泛型数组的使用方法吧。
(2)、定义泛型数组
在写程序时,大家可能会遇到类似String[] list = new String[8];的需求,这里可以定义String数组,当然我们也可以定义泛型数组,泛型数组的定义方法为 T[],与String[]是一致的,下面看看用法:

 

[java] view plain copy
 
 
  1. //定义  
  2. public static <T> T[] fun1(T...arg){  // 接收可变参数    
  3.        return arg ;            // 返回泛型数组    
  4. }    
  5. //使用  
  6. public static void main(String args[]){    
  7.        Integer i[] = fun1(1,2,3,4,5,6) ;  
  8.        Integer[] result = fun1(i) ;  
  9. }    

我们先看看 定义时的代码:

[java] view plain copy
 
 
  1. public static <T> T[] fun1(T...arg){  // 接收可变参数    
  2.        return arg ;            // 返回泛型数组    
  3. }    

首先,定义了一个静态函数,然后定义返回值为T[],参数为接收的T类型的可变长参数。如果有同学对T...arg的用法不了解,可以去找下JAVA 可变长参数方面的知识。
由于可变长参数在输入后,会保存在arg这个数组中,所以,我们直接把数组返回即可。

 

转自:http://blog.csdn.net/harvic880925/article/details/49872903

 

 

下面是我自己实际使用泛型的几个实例。

希望看完上面的文章之后,再看实际使用的例子,可以更好的理解和使用和实际使用。

 

 

关于泛型类的使用实例

 

  1.  
    import lombok.Data;
  2.  
     
  3.  
    @Data
  4.  
    public class MultiObject<T> {
  5.  
     
  6.  
    /**
  7.  
    * 成功状态
  8.  
    */
  9.  
    private boolean success;
  10.  
     
  11.  
    /**
  12.  
    * 异常
  13.  
    */
  14.  
    private Exception ex;
  15.  
     
  16.  
    /**
  17.  
    * 数据
  18.  
    */
  19.  
    private T obj;
  20.  
     
  21.  
    public MultiObject() {
  22.  
    }
  23.  
     
  24.  
    /**
  25.  
    * 注意:当传入的泛型是Boolean时,就和第三个构造函数冲突了。
  26.  
    */
  27.  
    public MultiObject(boolean success) {
  28.  
    this.success = success;
  29.  
    }
  30.  
     
  31.  
    public MultiObject(Exception ex) {
  32.  
    this.success = false;
  33.  
    this.ex = ex;
  34.  
    }
  35.  
     
  36.  
    public MultiObject(T value) {
  37.  
    this.success = true;
  38.  
    this.obj = value;
  39.  
    }
  40.  
    }


简单解释下这个model。
在实际业务代码里面,可能有很多种操作,然后我们关心这个操作的执行结果,主要有几点。
1,成功与否。对应属性success。
2,异常信息。对应属性ex。若是操作正常执行,则就不在意这个属性的值。
3,我们操作的最终目的对象。对应属性obj。

 


泛型牛逼的地方就是在这个地方。
如果你不用泛型,而使用Object类型,那么每次执行完之后,我们即使得到这个结果,还得类型转换一下,那么这下就像文章上面描述的那样。分分钟出现castfailexception。也就是类型转换异常啦。
但是,若是使用了这个泛型之后,那么我们的某个操作所需要的返回结果是什么类型,就可以 传入什么类型,而且在实际取得返回结果的时候,就不需要使用类型转换,这样就很好的达到了目的。
这个主要是代码设计层次的提高。写再多的业务代码,要是不提高,那么写的都是渣。

关于,这个model代码里面为啥没有getter和setter,都是因为使用@Data这个注解,可以自动填充这个getter和setter。所以。就表在意这个问题啦。在其他地方可以正常使用各个属性getter和setter方法,虽然这些方法,你暂时看不见。有兴趣的可以了解下lombok。

 

 

关于泛型方法的使用实例

这个地方就有2个,但是上面文章也都讲到啦。
1,一个是泛型表示某一个类型的参数。为的传递某一类的参数对象
2,另一个则是传递的不是参数,而是代表Class,某一个类。

 

恰巧我都使用过,就正好记录一下实际使用实例。

 

  1.  
    /**
  2.  
    * 将Json字符串信息转换成对应的Java对象
  3.  
    *
  4.  
    * @param json json字符串对象
  5.  
    * @param c 对应的类型
  6.  
    */
  7.  
    public static <T> T parseJsonToObj(String json, Class<T> c) {
  8.  
    try {
  9.  
    JSONObject jsonObject = JSONObject.parseObject(json);
  10.  
    return JSON.toJavaObject(jsonObject, c);
  11.  
    } catch (Exception e) {
  12.  
    LOG.error(e.getMessage());
  13.  
    }
  14.  
    return null;
  15.  
    }

然后是具体调用的地方的代码。

 

 

  1.  
    Collector collectorObj = JSONUtils.parseJsonToObj(collector, Collector.class);
  2.  
    Flume flume = JSONUtils.parseJsonToObj(flumeJson, Flume.class);
  3.  
    Probe probe = JSONUtils.parseJsonToObj(probeJson, Probe.class);

可以看到,真的只是因为传入的参数类型不一样,但若你不知道泛型的话,那你就得没遇到一个类型的转换,你就得写一个这么个方法。

 

 

  1.  
    /**
  2.  
    * @param dest 目的集合
  3.  
    * @param source 源集合
  4.  
    * @param <T> 集合参数的类型
  5.  
    */
  6.  
    private static <T> void listAddAllAvoidNPE(List<T> dest, List<T> source) {
  7.  
    if (source == null) {
  8.  
    return;
  9.  
    }
  10.  
    dest.addAll(source);
  11.  
    }
  12.  
     
  13.  
    private static <T> void listAddAvoidNull(List<T> dest, T source) {
  14.  
    if (source == null) {
  15.  
    return;
  16.  
    }
  17.  
    dest.add(source);
  18.  
    }


这个就是传入的参数为某一类的参数,主要是要使用参数对象,而不是上面的那个使用的参数的类Class

 

我这方法提出来,主要是因为,直接使用list类的addAll()方法,如果添加的是null,那么就会抛异常。但是总不能我在所有使用的地方,都判断一下我要添加的参数是不是null,然后再调用list的addAll()方法吧。那样的话,这样的判断代码会啰嗦的海了去了。所以,就这么提出来了。

 

这个时候,这个T,使用起来就像使用我们常用的一般对象一样,我这的参数是个List类型,当然也可是其他类型的,姿势都一样。

然后是具体调用的地方的代码

 

  1.  
    List<ProbeObject> list = Lists.newArrayList();
  2.  
    listAddAllAvoidNPE(list, decoder.getProperties());

这个方法的第二个参数的返回值可能是null,所以,直接调用addAll(),就会抛空指针异常。所以,就如上,那么一提取。就好多啦。

详见http://wiki.jikexueyuan.com/project/java/generics.html

 

 

4.3 泛型类

泛型类型用于类的定义中,被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类,如:List、Set、Map。

泛型类的最基本写法(这么看可能会有点晕,会在下面的例子中详解):

class 类名称 <泛型标识:可以随便写任意标识号,标识指定的泛型的类型>{
  private 泛型标识 /*(成员变量类型)*/ var; 
  .....

  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

一个最普通的泛型类:

//此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时,必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T,T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定
        return key;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
//泛型的类型参数只能是类类型(包括自定义类),不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同,即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同,即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
12-27 09:20:04.432 13063-13063/? D/泛型测试: key is 123456
12-27 09:20:04.432 13063-13063/? D/泛型测试: key is key_vlaue
  • 1
  • 2

定义的泛型类,就一定要传入泛型类型实参么?并不是这样,在使用泛型的时候如果传入泛型实参,则会根据传入的泛型实参做相应的限制,此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话,在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

看一个例子:

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

Log.d("泛型测试","key is " + generic.getKey());
Log.d("泛型测试","key is " + generic1.getKey());
Log.d("泛型测试","key is " + generic2.getKey());
Log.d("泛型测试","key is " + generic3.getKey());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
D/泛型测试: key is 111111
D/泛型测试: key is 4444
D/泛型测试: key is 55.55
D/泛型测试: key is false
  • 1
  • 2
  • 3
  • 4

注意:

    1. 泛型的类型参数只能是类类型,不能是简单类型。
    1. 不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的,编译时会出错。

      if(ex_num instanceof Generic<Number>){   
      } 
      • 1
      • 2

4.4 泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中,可以看一个例子:

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}
  • 1
  • 2
  • 3
  • 4

当实现泛型接口的类,未传入泛型实参时:

/**
 * 未传入泛型实参时,与泛型类的定义相同,在声明类的时候,需将泛型的声明也一起加到类中
 * 即:class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型,如:class FruitGenerator implements Generator<T>,编译器会报错:"Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

当实现泛型接口的类,传入泛型实参时:

/**
 * 传入泛型实参时:
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参,形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时,如已将泛型类型传入实参类型,则所有使用泛型的地方都要替换成传入的实参类型
 * 即:Generator<T>,public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

4.5 泛型通配符

我们知道IngeterNumber的一个子类,同时在特性章节中我们也验证过Generic<Ingeter>Generic<Number>实际上是相同的一种基本类型。那么问题来了,在使用Generic<Number>作为形参的方法中,能否使用Generic<Ingeter>的实例传入呢?在逻辑上类似于Generic<Number>Generic<Ingeter>是否可以看成具有父子关系的泛型类型呢?

为了弄清楚这个问题,我们使用Generic<T>这个泛型类继续看下面的例子:

public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}
  • 1
  • 2
  • 3
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gNumber);

// showKeyValue这个方法编译器会为我们报错:Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

通过提示信息我们可以看到Generic<Integer>不能被看作为`Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的

回到上面的例子,如何解决上面的问题?总不能为了定义一个新的方法来处理Generic<Integer>类型的类,这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时Generic<Integer>Generic<Number>父类的引用类型。由此类型通配符应运而生。

我们可以将上面的方法改一下:

public void showKeyValue1(Generic<?> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}
  • 1
  • 2
  • 3

类型通配符一般是使用?代替具体的类型实参,注意了,此处’?’是类型实参,而不是类型形参 。重要说三遍!此处’?’是类型实参,而不是类型形参 ! 此处’?’是类型实参,而不是类型形参 !再直白点的意思就是,此处的?和Number、String、Integer一样都是一种实际的类型,可以把?看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候,这个通配符就是 ?  ;当操作类型时,不需要使用类型的具体功能时,只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

4.6 泛型方法

在java中,泛型类的定义非常简单,但是泛型方法就比较复杂了。

尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型,有的甚至泛型类中也包含着泛型方法,这样在初学者中非常容易将泛型方法理解错了。

泛型类,是在实例化类的时候指明泛型的具体类型;泛型方法,是在调用方法的时候指明泛型的具体类型 。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明:
 *     1)public 与 返回值中间<T>非常重要,可以理解为声明此方法为泛型方法。
 *     2)只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3)<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
 *     4)与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
Object obj = genericMethod(Class.forName("com.test.test"));
  • 1

4.6.1 泛型方法的基本用法

光看上面的例子有的同学可能依然会非常迷糊,我们再通过一个例子,把我泛型方法再总结一下。

public class GenericTest {
   //这个类是个泛型类,在上面已经介绍过
   public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想说的其实是这个,虽然在方法中使用了泛型,但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 这才是一个真正的泛型方法。
     * 首先在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 static void main(String[] args) {


    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75

4.6.2 类中的泛型方法

当然这并不是泛型方法的全部,泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的,当泛型方法出现在泛型类中时,我们再通过一个例子看一下

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法,使用泛型E,这种泛型E可以为任意类型。可以类型与T相同,也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明泛型,编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法,使用泛型T,注意这个T是一种全新的类型,可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类,所以这里可以
        generateTest.show_1(apple);
        //编译器会报错,因为泛型类型实参指定的是Fruit,而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

4.6.3 泛型方法与可变参数

再看一个泛型方法和可变参数的例子:

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型测试","t is " + t);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
printMsg("111",222,"aaaa","2323.4",55.55);
  • 1

4.6.4 静态方法与泛型

静态方法有一种情况需要注意一下,那就是在类中的静态方法使用泛型:静态方法无法访问类上定义的泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。

即:如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法 。



































































以上是关于java 反射和泛型的主要内容,如果未能解决你的问题,请参考以下文章

Day642.反射注解和泛型问题 -Java业务开发常见错误

java 反射和泛型

java核心学习(四十一) 反射和泛型

反射和泛型的复习

使用反射和泛型简化Golang查询数据库代码的方案

基于反射和泛型的编程