Java基础13：反射详解
更多内容请关注微信公众号【Java技术江湖】html
这是一位阿里 Java 工程师的技术小站，做者黄小斜，专一 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！（关注公众号后回复”资料“便可领取 3T 免费技术学习资源以及我我原创的程序员校招指南、Java学习指南等资源）java
**
本节主要介绍Java反射的原理，使用方法以及相关的技术细节，而且介绍了关于Class类，注解等内容。git
具体代码在个人GitHub中能够找到程序员
https://github.com/h2pl/MyTech
文章首发于个人我的博客：github
https://h2pl.github.io/2018/0...
更多关于Java后端学习的内容请到个人CSDN博客上查看：数据库
https://blog.csdn.net/a724888
回顾：什么是反射？
反射(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，好比：
<action name="login"
class="org.ScZyhSoft.test.action.SimpleLoginAction"
method="execute">
<result>/shop/shop-index.jsp</result>
<result name="error">login.jsp</result>
</action>
配置文件与Action创建了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，而后StrutsPrepareAndExecuteFilter会去动态地建立Action实例。
——好比咱们请求login.action，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，检索action中name为login的Action，并根据class属性建立SimpleLoginAction实例，并用invoke方法来调用execute方法，这个过程离不开反射。
对与框架开发人员来讲，反射虽小但做用很是大，它是各类容器实现的核心。而对于通常的开发者来讲，不深刻框架开发则用反射用的就会少一点，不过了解一下框架的底层机制有助于丰富本身的编程思想，也是颇有益的。
反射的基础：关于Class类
更多关于Class类和Object类的原理和介绍请见上一节
一、Class是一个类，一个描述类的类（也就是描述类自己），封装了描述方法的Method，描述字段的Filed，描述构造器的Constructor等属性
二、对象照镜子后（反射）能够获得的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。
三、对于每一个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个Class对象包含了特定某个类的有关信息。
四、Class 对象只能由系统创建对象
五、一个类在 JVM 中只会有一个Class实例
//总结一下就是，JDK有一个类叫作Class，这个类用来封装全部Java类型，包括这些类的全部信息，JVM中类信息是放在方法区的。
//全部类在加载后，JVM会为其在堆中建立一个Class<类名称>的对象，而且每一个类只会有一个Class对象，这个类的全部对象都要经过Class<类名称>来进行实例化。
//上面说的是JVM进行实例化的原理，固然实际上在Java写代码时只须要用 类名称就能够进行实例化了。
public final class Class<T> implements java.io.Serializable,
GenericDeclaration,
Type,
AnnotatedElement {
虚拟机会保持惟一一
//经过类名.class得到惟一的Class对象。
Class<UserBean> cls = UserBean.class;
//经过integer.TYPEl来获取Class对象
Class<Integer> inti = Integer.TYPE;
//接口本质也是一个类，同样能够经过.class获取
Class<User> userClass = User.class;
反射的基本运用
上面咱们提到了反射能够用于判断任意对象所属的类，得到Class对象，构造任意一个对象以及调用一个对象。这里咱们介绍一下基本反射功能的实现(反射相关的类通常都在java.lang.relfect包里)。
一、得到Class对象方法有三种
(1)使用Class类的forName静态方法:
public static Class<?> forName(String className) ``` 在JDBC开发中经常使用此方法加载数据库驱动: 要使用全类名来加载这个类，通常数据库驱动的配置信息会写在配置文件中。加载这个驱动前要先导入jar包 ```java Class.forName(driver);
(2)直接获取某一个对象的class，好比:
//Class<?>是一个泛型表示，用于获取一个类的类型。 Class<?> klass = int.class; Class<?> classInt = Integer.TYPE;
(3)调用某个对象的getClass()方法,好比:
StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();
判断是否为某个类的实例
通常地，咱们用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();
（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);
获取方法
获取某个Class对象的方法集合，主要有如下几个方法：
getDeclaredMethods()方法返回类或接口声明的全部方法，==包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法==。
public Method[] getDeclaredMethods() throws SecurityException
getMethods()方法返回某个类的全部公用（public）方法，==包括其继承类的公用方法。==
public Method[] getMethods() throws SecurityException
getMethod方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象
public Method getMethod(String name, Class<?>... parameterTypes)
只是这样描述的话可能难以理解，咱们用例子来理解这三个方法：
本文中的例子用到了如下这些类，用于反射的测试。
//注解类，可可用于表示方法，能够经过反射获取注解的内容。
//Java注解的实现是不少注框架实现注解配置的基础
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Invoke {
}
userbean的父类personbean
public class PersonBean {
private String name;
int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
接口user
public interface User {
public void login ();
}
userBean实现user接口，继承personbean
public class UserBean extends PersonBean implements User{
@Override
public 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;
}
@Invoke
public static void staticMethod(String devName,int a) {
System.out.printf("Hi %s, I'm a static method", devName);
}
@Invoke
public void publicMethod() {
System.out.println("I'm a public method");
}
@Invoke
private void privateMethod() {
System.out.println("I'm a private method");
}
}
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();
}
}
}
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 static
methodString += method.getReturnType().getSimpleName() + " "; // void
methodString += method.getName() + "("; // staticMethod
Class[] 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()*/
}
}
获取构造器信息
获取类构造器的用法与上述获取方法的用法相似。主要是经过Class类的getConstructor方法获得Constructor类的一个实例，而Constructor类有一个newInstance方法能够建立一个对象实例:
public class 打印构造方法 {
public static void main(String[] args) {
// constructors
Class<?> 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, )
}
}
}
获取类的成员变量（字段）信息
主要是这几个方法，在此再也不赘述：
getFiled: 访问公有的成员变量
getDeclaredField：全部已声明的成员变量。但不能获得其父类的成员变量
getFileds和getDeclaredFields用法同上（参照Method）
public class 打印成员变量 {
public static void main(String[] args) {
Class userBeanClass = UserBean.class;
//得到该类的全部成员变量，包括static private
Field[] 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;
}
}
}
调用方法
当咱们从类中获取了一个方法后，咱们就能够用invoke()方法来调用这个方法。invoke方法的原型为:
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
public 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 修饰
//判断方法的修饰符是是static
if (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); // 利用构造函数进行实例化，获得 Object
if (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，无须参数
}
}
}
}
}
利用反射建立数组
数组在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
}
}
其中的Array类为java.lang.reflect.Array类。咱们经过Array.newInstance()建立数组对象，它的原型是:
public static Object newInstance(Class<?> componentType, int length)
throws NegativeArraySizeException {
return newArray(componentType, length);
}
而newArray()方法是一个Native方法，它在Hotspot JVM里的具体实现咱们后边再研究，这里先把源码贴出来
private static native Object newArray(Class<?> componentType, int length)
throws NegativeArraySizeException;
阿丙的博客园
把每一件简单的事情作好，就是不简单；把每一件平凡的事情作好，就是不平凡！相信本身，创造奇迹~~
博客园首页联系管理
随笔 - 441 文章 - 0 评论 - 53
注解Annotation实现原理与自定义注解例子
什么是注解？
对于不少初次接触的开发者来讲应该都有这个疑问？Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的相似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，而且供指定的工具或框架使用。Annontation像一种修饰符同样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的做用。包含在 java.lang.annotation 包中。
注解的用处：
一、生成文档。这是最多见的，也是java 最先提供的注解。经常使用的有@param @return 等 二、跟踪代码依赖性，实现替代配置文件功能。好比Dagger 2依赖注入，将来java开发，将大量注解配置，具备很大用处; 三、在编译时进行格式检查。如@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);
}
}
}
}
按 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/...
[2]http://www.cnblogs.com/whoisl...
[3]http://blog.csdn.net/lylwo317...
- 1. Java基础之反射机制详解
- 2. Java基础篇：反射机制详解
- 3. Java基础-反射基础
- 4. 【Java 反射学习】Java 反射基础
- 5. java 反射基础
- 6. java基础-反射
- 7. 【Java 基础】反射
- 8. JAVA 反射基础
- 9. Java基础(反射)
- 10. Java—反射基础
- 更多相关文章...
- • C# 反射（Reflection） - C#教程
- • *.hbm.xml映射文件详解 - Hibernate教程
- • Flink 数据传输及反压详解
- • ☆基于Java Instrument的Agent实现
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java基础之反射机制详解
- 2. Java基础篇：反射机制详解
- 3. Java基础-反射基础
- 4. 【Java 反射学习】Java 反射基础
- 5. java 反射基础
- 6. java基础-反射
- 7. 【Java 基础】反射
- 8. JAVA 反射基础
- 9. Java基础(反射)
- 10. Java—反射基础