Java基础13：反射详解

回顾：什么是反射？
反射(Reflection)是Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。
Oracle官方对反射的解释是

Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts, within security restrictions.

The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class. It also allows programs to suppress default reflective access control.

简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。

程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。

反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。

Java反射框架主要提供以下功能：

1.在运行时判断任意一个对象所属的类；

2.在运行时构造任意一个类的对象；

3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；

4.在运行时调用任意一个对象的方法

重点：是运行时而不是编译时

反射的主要用途
很多人都认为反射在实际的Java开发应用中并不广泛，其实不然。

当我们在使用IDE(如Eclipse，IDEA)时，当我们输入一个对象或类并想调用它的属性或方法时，一按点号，编译器就会自动列出它的属性或方法，这里就会用到反射。

反射最重要的用途就是开发各种通用框架。

很多框架（比如Spring）都是配置化的（比如通过XML文件配置JavaBean,Action之类的），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。

举一个例子，在运用Struts 2框架的开发中我们一般会在struts.xml里去配置Action，比如：

/shop/shop-index.jsp
login.jsp

1
2
3
4
5
6
配置文件与Action建立了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，然后StrutsPrepareAndExecuteFilter会去动态地创建Action实例。

——比如我们请求login.action，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，检索action中name为login的Action，并根据class属性创建SimpleLoginAction实例，并用invoke方法来调用execute方法，这个过程离不开反射。

对与框架开发人员来说，反射虽小但作用非常大，它是各种容器实现的核心。而对于一般的开发者来说，不深入框架开发则用反射用的就会少一点，不过了解一下框架的底层机制有助于丰富自己的编程思想，也是很有益的。

反射的基础：关于Class类
更多关于Class类和Object类的原理和介绍请见上一节

1、Class是一个类，一个描述类的类（也就是描述类本身），封装了描述方法的Method，描述字段的Filed，描述构造器的Constructor等属性

2、对象照镜子后（反射）可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。

3、对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个Class对象包含了特定某个类的有关信息。

4、Class 对象只能由系统建立对象

5、一个类在 JVM 中只会有一个Class实例

//总结一下就是，JDK有一个类叫做Class，这个类用来封装所有Java类型，包括这些类的所有信息，JVM中类信息是放在方法区的。

//所有类在加载后，JVM会为其在堆中创建一个Class<类名称>的对象，并且每个类只会有一个Class对象，这个类的所有对象都要通过Class<类名称>来进行实例化。

//上面说的是JVM进行实例化的原理，当然实际上在Java写代码时只需要用类名称就可以进行实例化了。

public final class Class implements java.io.Serializable,
GenericDeclaration,
Type,
AnnotatedElement {
虚拟机会保持唯一一
//通过类名.class获得唯一的Class对象。
Class cls = UserBean.class;
//通过integer.TYPEl来获取Class对象
Class inti = Integer.TYPE;
//接口本质也是一个类，一样可以通过.class获取
Class userClass = User.class;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
反射的基本运用
上面我们提到了反射可以用于判断任意对象所属的类，获得Class对象，构造任意一个对象以及调用一个对象。这里我们介绍一下基本反射功能的实现(反射相关的类一般都在java.lang.relfect包里)。

1、获得Class对象方法有三种

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

public static Class<?> forName(String className)

在JDBC开发中常用此方法加载数据库驱动:
要使用全类名来加载这个类，一般数据库驱动的配置信息会写在配置文件中。加载这个驱动前要先导入jar包
```javaClass.forName(driver);
1
2
3
4
5
6
(2)直接获取某一个对象的class，比如://Class<?>是一个泛型表示，用于获取一个类的类型。
Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;
1
2
3
(3)调用某个对象的getClass()方法,比如:StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();
1
2
判断是否为某个类的实例
一般地，我们用instanceof关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的isInstance()方法来判断是否为某个类的实例，它是一个Native方法：public native boolean isInstance(Object obj);创建实例
通过反射来生成对象主要有两种方式。（1）使用Class对象的newInstance()方法来创建Class对象对应类的实例。注意：利用newInstance创建对象：调用的类必须有无参的构造器//Class<?>代表任何类的一个类对象。
//使用这个类对象可以为其他类进行实例化
//因为jvm加载类以后自动在堆区生成一个对应的*.Class对象
//该对象用于让JVM对进行所有*对象实例化。
Class<?> c = String.class;//Class<?> 中的 ? 是通配符，其实就是表示任意符合泛类定义条件的类，和直接使用 Class
//效果基本一致，但是这样写更加规范，在某些类型转换时可以避免不必要的 unchecked 错误。Object str = c.newInstance();
1
2
3
4
5
6
7
8
9
10
（2）先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例。//获取String所对应的Class对象
Class<?> c = String.class;
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);
//根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);
1
2
3
4
5
6
7
获取方法
获取某个Class对象的方法集合，主要有以下几个方法：getDeclaredMethods()方法返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。public Method[] getDeclaredMethods() throws SecurityException
1
getMethods()方法返回某个类的所有公用（public）方法，包括其继承类的公用方法。public Method[] getMethods() throws SecurityException
1
getMethod方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象public Method getMethod(String name, Class<?>... parameterTypes)
1
只是这样描述的话可能难以理解，我们用例子来理解这三个方法：
本文中的例子用到了以下这些类，用于反射的测试。//注解类，可可用于表示方法，可以通过反射获取注解的内容。//Java注解的实现是很多注框架实现注解配置的基础
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Invoke {
}
1
2
3
4
5
6
userbean的父类personbeanpublic class PersonBean {
private String name;int id;public String getName() {return name;
}public void setName(String name) {this.name = name;
}
1
2
3
4
5
6
7
8
9
10
11
12
}接口userpublic interface User {public void login ();}
1
2
3
4
userBean实现user接口，继承personbeanpublic class UserBean extends PersonBean implements User{@Overridepublic void login() {}class B {}public String userName;protected int i;static int j;private int l;private long userId;public UserBean(String userName, long userId) {this.userName = userName;this.userId = userId;}public String getName() {return userName;}public long getId() {return userId;}@Invokepublic static void staticMethod(String devName,int a) {System.out.printf("Hi %s, I'm a static method", devName);}@Invokepublic void publicMethod() {System.out.println("I'm a public method");}@Invokeprivate void privateMethod() {System.out.println("I'm a private method");}
}
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
1 getMethods和getDeclaredMethods的区别public class 动态加载类的反射 {public static void main(String[] args) {try {Class clazz = Class.forName("com.javase.反射.UserBean");for (Field field : clazz.getDeclaredFields()) {
//                field.setAccessible(true);System.out.println(field);}//getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。System.out.println("------共有方法------");
//        getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
//            getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。for (Method method : clazz.getMethods()) {String name = method.getName();System.out.println(name);//打印出了UserBean.java的所有方法以及父类的方法}System.out.println("------独占方法------");for (Method method : clazz.getDeclaredMethods()) {String name = method.getName();System.out.println(name);}} catch (ClassNotFoundException e) {e.printStackTrace();}}
}
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
2 打印一个类的所有方法及详细信息：public class 打印所有方法 {public static void main(String[] args) {Class userBeanClass = UserBean.class;Field[] fields = userBeanClass.getDeclaredFields();//注意，打印方法时无法得到局部变量的名称，因为jvm只知道它的类型Method[] methods = userBeanClass.getDeclaredMethods();for (Method method : methods) {//依次获得方法的修饰符，返回类型和名称，外加方法中的参数String methodString = Modifier.toString(method.getModifiers()) + " " ; // private staticmethodString += method.getReturnType().getSimpleName() + " "; // voidmethodString += method.getName() + "("; // staticMethodClass[] parameters = method.getParameterTypes();Parameter[] p = method.getParameters();for (Class parameter : parameters) {methodString += parameter.getSimpleName() + " " ; // String}methodString += ")";System.out.println(methodString);}//注意方法只能获取到其类型，拿不到变量名
/*        public String getName()public long getId()public static void staticMethod(String int )public void publicMethod()private void privateMethod()*/}
}
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
获取构造器信息
获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例:public class 打印构造方法 {public static void main(String[] args) {// constructorsClass<?> clazz = UserBean.class;Class userBeanClass = UserBean.class;//获得所有的构造方法Constructor[] constructors = userBeanClass.getDeclaredConstructors();for (Constructor constructor : constructors) {String s = Modifier.toString(constructor.getModifiers()) + " ";s += constructor.getName() + "(";//构造方法的参数类型Class[] parameters = constructor.getParameterTypes();for (Class parameter : parameters) {s += parameter.getSimpleName() + ", ";}s += ")";System.out.println(s);//打印结果//public com.javase.反射.UserBean(String, long, )}}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
获取类的成员变量（字段）信息
主要是这几个方法，在此不再赘述：getFiled: 访问公有的成员变量
getDeclaredField：所有已声明的成员变量。但不能得到其父类的成员变量
getFileds和getDeclaredFields用法同上（参照Method）public class 打印成员变量 {public static void main(String[] args) {Class userBeanClass = UserBean.class;//获得该类的所有成员变量，包括static privateField[] fields = userBeanClass.getDeclaredFields();for(Field field : fields) {//private属性即使不用下面这个语句也可以访问
//            field.setAccessible(true);//因为类的私有域在反射中默认可访问，所以flag默认为true。String fieldString = "";fieldString += Modifier.toString(field.getModifiers()) + " "; // `private`fieldString += field.getType().getSimpleName() + " "; // `String`fieldString += field.getName(); // `userName`fieldString += ";";System.out.println(fieldString);//打印结果
//            public String userName;
//            protected int i;
//            static int j;
//            private int l;
//            private long userId;}}
}
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
调用方法
当我们从类中获取了一个方法后，我们就可以用invoke()方法来调用这个方法。invoke方法的原型为:public Object invoke(Object obj, Object... args)throws IllegalAccessException, IllegalArgumentException,InvocationTargetExceptionpublic class 使用反射调用方法 {public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException {Class userBeanClass = UserBean.class;//获取该类所有的方法，包括静态方法，实例方法。//此处也包括了私有方法，只不过私有方法在用invoke访问之前要设置访问权限//也就是使用setAccessible使方法可访问，否则会抛出异常
//       // IllegalAccessException的解释是
//        * An IllegalAccessException is thrown when an application tries
// * to reflectively create an instance (other than an array),
// * set or get a field, or invoke a method, but the currently
// * executing method does not have access to the definition of
// * the specified class, field, method or constructor.//        getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
//            getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。//就是说，当这个类，域或者方法被设为私有访问，使用反射调用但是却没有权限时会抛出异常。Method[] methods = userBeanClass.getDeclaredMethods(); // 获取所有成员方法for (Method method : methods) {//反射可以获取方法上的注解，通过注解来进行判断if (method.isAnnotationPresent(Invoke.class)) { // 判断是否被 @Invoke 修饰//判断方法的修饰符是是staticif (Modifier.isStatic(method.getModifiers())) { // 如果是 static 方法//反射调用该方法//类方法可以直接调用，不必先实例化method.invoke(null, "wingjay",2); // 直接调用，并传入需要的参数 devName} else {//如果不是类方法，需要先获得一个实例再调用方法//传入构造方法需要的变量类型Class[] params = {String.class, long.class};//获取该类指定类型的构造方法//如果没有这种类型的方法会报错Constructor constructor = userBeanClass.getDeclaredConstructor(params); // 获取参数格式为 String,long 的构造函数//通过构造方法的实例来进行实例化Object userBean = constructor.newInstance("wingjay", 11); // 利用构造函数进行实例化，得到 Objectif (Modifier.isPrivate(method.getModifiers())) {method.setAccessible(true); // 如果是 private 的方法，需要获取其调用权限
//                        Set the {@code accessible} flag for this object to
//     * the indicated boolean value.  A value of {@code true} indicates that
//     * the reflected object should suppress Java language access
//     * checking when it is used.  A value of {@code false} indicates
//                                * that the reflected object should enforce Java language access checks.//通过该方法可以设置其可见或者不可见，不仅可以用于方法//后面例子会介绍将其用于成员变量//打印结果
//            I'm a public method
// Hi wingjay, I'm a static methodI'm a private method}method.invoke(userBean); // 调用 method，无须参数}}}}
}
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
利用反射创建数组
数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference。下面我们看一看利用反射创建数组的例子：public class 用反射创建数组 {public static void main(String[] args) {Class<?> cls = null;try {cls = Class.forName("java.lang.String");} catch (ClassNotFoundException e) {e.printStackTrace();}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));//Scala}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
其中的Array类为java.lang.reflect.Array类。我们通过Array.newInstance()创建数组对象，它的原型是:public static Object newInstance(Class<?> componentType, int length)throws NegativeArraySizeException {return newArray(componentType, length);}
1
2
3
4
而newArray()方法是一个Native方法，它在Hotspot JVM里的具体实现我们后边再研究，这里先把源码贴出来private static native Object newArray(Class<?> componentType, int length)throws NegativeArraySizeException;
1
2
阿丙的博客园
把每一件简单的事情做好，就是不简单；把每一件平凡的事情做好，就是不平凡！相信自己，创造奇迹~~
博客园首页联系管理
随笔 - 441 文章 - 0 评论 - 53
注解Annotation实现原理与自定义注解例子
什么是注解？
对于很多初次接触的开发者来说应该都有这个疑问？Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。注解的用处：
1、生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等
2、跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2依赖注入，未来java开发，将大量注解配置，具有很大用处;
3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。注解的原理：注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。而memberValues的来源是Java常量池。元注解：
java.lang.annotation提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：
@Documented –注解是否将包含在JavaDoc中
@Retention –什么时候使用该注解
@Target –注解用于什么地方
@Inherited – 是否允许子类继承该注解1.）@Retention– 定义该注解的生命周期
● RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
● RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
● RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。可用的ElementType参数包括
● ElementType.CONSTRUCTOR:用于描述构造器
● ElementType.FIELD:成员变量、对象、属性（包括enum实例）
● ElementType.LOCAL_VARIABLE:用于描述局部变量
● ElementType.METHOD:用于描述方法
● ElementType.PACKAGE:用于描述包
● ElementType.PARAMETER:用于描述参数
● ElementType.TYPE:用于描述类、接口(包括注解类型) 或enum声明3.)@Documented–一个简单的Annotations标记注解，表示是否将注解信息添加在java文档中。4.)@Inherited – 定义该注释和子类的关系
@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。常见标准的Annotation：
1.）Override
java.lang.Override是一个标记类型注解，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时，java编译器将以一个编译错误来警示。
2.）Deprecated
Deprecated也是一种标记类型注解。当一个类型或者类型成员使用@Deprecated修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的“延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated，但编译器仍然要报警。
3.）SuppressWarnings
SuppressWarning不是一个标记类型注解。它有一个类型为String[]的成员，这个成员的值为被禁止的警告名。对于javac编译器来讲，被-Xlint选项有效的警告名也同样对@SuppressWarings有效，同时编译器忽略掉无法识别的警告名。@SuppressWarnings(“unchecked”)自定义注解：
自定义注解类编写的一些规则:Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
参数成员只能用public或默认(default)这两个访问权修饰
参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,因为你除此之外没有别的获取注解对象的方法
注解也可以没有定义成员, 不过这样注解就没啥用了
PS:自定义注解需要使用到元注解
自定义注解实例：
FruitName.java按 Ctrl+C 复制代码import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;/**水果名称注解
*/
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitName {
String value() default “”;
}
按 Ctrl+C 复制代码
FruitColor.java按 Ctrl+C 复制代码import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;/**水果颜色注解
/
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitColor {
/*颜色枚举
*/
public enum Color{ BLUE,RED,GREEN};
/**颜色属性
*/
Color fruitColor() default Color.GREEN;
}
按 Ctrl+C 复制代码FruitProvider.java按 Ctrl+C 复制代码import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;/**水果供应者注解
/
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitProvider {
/*供应商编号
*/
public int id() default -1;
/**供应商名称
*/
public String name() default “”;
/**供应商地址
*/
public String address() default “”;
}
按 Ctrl+C 复制代码
FruitInfoUtil.java按 Ctrl+C 复制代码import java.lang.reflect.Field;/**注解处理器
*/
public class FruitInfoUtil {
public static void getFruitInfo(Class<?> clazz){String strFruitName=" 水果名称：";String strFruitColor=" 水果颜色：";String strFruitProvicer="供应商信息：";Field[] fields = clazz.getDeclaredFields();for(Field field :fields){if(field.isAnnotationPresent(FruitName.class)){FruitName fruitName = (FruitName) field.getAnnotation(FruitName.class);strFruitName=strFruitName+fruitName.value();System.out.println(strFruitName);}else if(field.isAnnotationPresent(FruitColor.class)){FruitColor fruitColor= (FruitColor) field.getAnnotation(FruitColor.class);strFruitColor=strFruitColor+fruitColor.fruitColor().toString();System.out.println(strFruitColor);}else if(field.isAnnotationPresent(FruitProvider.class)){FruitProvider fruitProvider= (FruitProvider) field.getAnnotation(FruitProvider.class);strFruitProvicer=" 供应商编号："+fruitProvider.id()+" 供应商名称："+fruitProvider.name()+" 供应商地址："+fruitProvider.address();System.out.println(strFruitProvicer);}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
}
}
按 Ctrl+C 复制代码Apple.java按 Ctrl+C 复制代码import test.FruitColor.Color;/**注解使用
*/
public class Apple {@FruitName(“Apple”)
private String appleName;@FruitColor(fruitColor=Color.RED)
private String appleColor;@FruitProvider(id=1,name=“陕西红富士集团”,address=“陕西省西安市延安路89号红富士大厦”)
private String appleProvider;public void setAppleColor(String appleColor) {
this.appleColor = appleColor;
}
public String getAppleColor() {
return appleColor;
}public void setAppleName(String appleName) {
this.appleName = appleName;
}
public String getAppleName() {
return appleName;
}public void setAppleProvider(String appleProvider) {
this.appleProvider = appleProvider;
}
public String getAppleProvider() {
return appleProvider;
}public void displayName(){
System.out.println(“水果的名字是：苹果”);
}
}
按 Ctrl+C 复制代码FruitRun.java按 Ctrl+C 复制代码/**输出结果
*/
public class FruitRun {
public static void main(String[] args) {
FruitInfoUtil.getFruitInfo(Apple.class);
}
}
按 Ctrl+C 复制代码
运行结果是：水果名称：Apple
水果颜色：RED
供应商编号：1 供应商名称：陕西红富士集团 供应商地址：陕西省西安市延安路89号红富士大厦参考链接：
[1]http://www.cnblogs.com/peida/archive/2013/04/26/3038503.html
[2]http://www.cnblogs.com/whoislcj/p/5671622.html
[3]http://blog.csdn.net/lylwo317/article/details/52163304
————————————————
版权声明：本文为CSDN博主「黄小斜」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/a724888/article/details/80160662

Java基础13：反射详解相关推荐

Java基础：volatile详解
Java基础:volatile详解 1.volatile保证可见性 1.1.什么是JMM模型? 1.2.volatile保证可见性的代码验证 1.2.1.无可见性代码验证 1.2.1.volatile ...
【JAVA基础】java基础之-泛型详解
写在前面的话脑子是个好东西,可惜的是一直没有搞懂脑子的内存删除机制是什么,所以啊,入行多年,零零散散的文章看了无数,却总是学习了很多也忘了很多. 痛定思痛的我决定从今天开始系统的梳理下知识架构,记录 ...
java中的反射详解
反射前段时间,网易面试,面试官问我关于反射方面的知识,回答的不是特别好,今天特此补充学习一下~~~ 简介反射是java语言被视为动态或者准动态语言的一个关键性质,这个机制允许程序在运行时通过Ref ...
Java基础-注解机制详解
文章目录 1. 注解基础 1.1 Java内置注解 1.1.1 内置注解 - @Override 1.1.2 内置注解 - @Deprecated 1.1.3 内置注解 - @SuppressWarn ...
java基础-泛型举例详解
泛型泛型是JDK5.0增加的新特性,泛型的本质是参数化类型,即所操作的数据类型被指定为一个参数.这种类型参数可以在类.接口.和方法的创建中,分别被称为泛型类.泛型接口.泛型方法. 一.认识泛型在没 ...
java注解和反射详解
注解什么是注解 Annotation是从JDK1.5开始引入的新技术 Annotation的作用: 不是程序本身,可以对程序做出解释可以被其他程序读取 Annotation的格式: 注解是以& ...
[读书笔记]java基础与案例详解主编徐明华
Java SE(标准版),SUN平台体系中最基础最底层的版本,它是各种应用平台的基础. Java SE包含了桌面应用API和Java EE企业级与Java ME嵌入式. Java是一种计算机编程语言: ...
Java基础---数组内容详解
数组概念:内存中开辟的一块连续的空间,用来存储有限个相同数据类型的数据定义格式:元素的数据类型[] 数组名称 = new 元素的数据类型[数组长度]简化格式:元素的数据类型[] 数组名称 ={值1, ...
Java基础--object类详解
原文链接:https://www.cnblogs.com/zhangyinhua/p/7715486.html 阅读目录(Content) 一.clone()方法 1.1.clone与copy的区别 ...
Java基础之面向对象详解
##################################### 基本概念类与对象构造方法及其重载 static修饰符封装继承抽象 final修饰符多态 instanceof运算 ...

Java基础13：反射详解

Java基础13：反射详解相关推荐

最新文章

热门文章