代码中存在很多结构相似的枚举，需要分别调用其方法名称相同的方法，所以选择使用反射调用

枚举代码如下：

package com.ruisitech.bi.enums.bireport;
 * @author：mazhen
 * @date：2018/9/13 11:46:
 * @description:用户类型枚举
public enum UserTypeEnum {
    Geek("0","geek"),Boss("1","boss"),Other("2","other-userType");
    String value;
    String meaning;
    UserTypeEnum(String value,String meaning){
        this.value=value;
        this.meaning=meaning;
    public static String getMeaning(String value){
        for(UserTypeEnum userType : UserTypeEnum.values()){
            if(userType.value.equals(value)){
                return userType.meaning;
        return ErrorConstant.errorMessage;
反射方式调用getMeaning方法如下：
 
    static void inovkeEnum() throws NoSuchMethodException, ClassNotFoundException, InvocationTargetException, IllegalAccessException, InstantiationException {
        // 这里是 包路径+枚举名称
        Class<?> aClass = Class.forName("com.ruisitech.bi.enums.bireport.UserTypeEnum");
        Method getMeaning = aClass.getDeclaredMethod("getMeaning", String.class);
        // 错误的方式，枚举对应的class没有newInstance方法，会报NoSuchMethodException，应该使用getEnumConstants方法
        //Object o = aClass.newInstance();NoSuchMethodException
        Object[] oo = aClass.getEnumConstants();
        Object invoke = getMeaning.invoke(oo[0],"0");
枚举实体类的获取：枚举对应的class没有newInstance方法，会报NoSuchMethodException，应该使用getEnumConstants方法获取实体类
 
上面为什么不是直接调用枚举呢？因为一个枚举很简单，如果是有十几个类似UserTypeEnum的枚举呢？此时就会很麻烦，不如类似下面代码，直接获取枚举名称，然后通过反射来调用，代码会简化很多
 
for(Map.Entry<String,String> entry : rhQueryConditionMap.entrySet()){
                if(!StringUtils.isEmpty(entry.getValue()) ){
                    try {
                        aClass = Class.forName("com.ruisitech.bi.enums.bireport."+entry.getKey()+"Enum");
                    } catch (ClassNotFoundException e) {
                        logger.error("com.ruisitech.bi.enums.bireport."+entry.getKey()+"Enum获取反射异常:"+e);
                        continue;
                    split = entry.getValue().split(",");
                    getMeaning = aClass.getDeclaredMethod("getMeaning", String.class);
                    enumConstants = aClass.getEnumConstants();
                    for(String str:split){
                        buffer.append((String)getMeaning.invoke(enumConstants[0],str)).append(",");
                    // 此处的处理，为了在查询的时候可以直接使用in语法，而不用转为list使用in
                    rhQueryConditionMap.put(entry.getKey(),"("+entry.getValue()+")");
                    代码中存在很多结构相似的枚举，需要分别调用其方法名称相同的方法，所以选择使用反射调用枚举代码如下：package com.ruisitech.bi.enums.bireport;/** * @author：mazhen * @date：2018/9/13 11:46: * @description:用户类型枚举 */public enum UserTypeEnum {  ...
				
两个现实中的例子：
1、B超：大家体检的时候大概都做过B超吧，B超可以透过肚皮探测到你内脏的生理情况。这是如何做到的呢？B超是B型超声波，它可以透过肚皮通过向你体内发射B型超声波，当超声波遇到内脏壁的时候就会产生一定的“回音”反射，然后把“回音”进行处理就可以显示出内脏的情况了（我不是医生也不是声学专家，不知说得是否准确^_^）。
2、地球内部结构：地球的内部结构大体可以分为三层：地壳、地幔和地核。地壳是固体，地核是液体，地幔则是半液半固的结构（中学地理的内容，大家还记得吧？）。如何在地球表面不用深入地球内部就知道其内部的构造呢？对，向地球发射“地震波”，“地震波”分两种一种是“横波”，另一种是“纵波”。“横波”只能穿透固体，而“纵波”既可穿透固体又可以穿透液体。通过在地面对纵波和横波的反回情况，我们就可以大体断定地球内部的构造了。
大家注意到这两个例子的共同特点，就是从一个对象的外部去了解对象内部的构造，而且都是利用了波的反射功能。在.NET中的反射也可以实现从对象的外部来了解对象（或程序集）内部结构的功能，哪怕你不知道这个对象（或程序集）是个什么东西，另外.NET中的反射还可以运态创建出对象并执行它其中的方法。
反射是.NET中的重要机制，通过反射，可以在运行时获得程序或程序集中每一个类型（包括类、结构、委托、接口和枚举等）的成员和成员的信息。有了反射，即可对每一个类型了如指掌。另外我还可以直接创建对象，即使这个对象的类型在编译时还不知道。
反射的用途：
    （1）使用Assembly定义和加载程序集，加载在程序集清单中列出模块，以及从此程序集中查找类型并创建该类型的实例。
    （2）使用Module了解包含模块的程序集以及模块中的类等，还可以获取在模块上定义的所有全局方法或其他特定的非全局方法。
    （3）使用ConstructorInfo了解构造函数的名称、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等。
    （4）使用MethodInfo了解方法的名称、返回类型、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等。
    （5）使用FiedInfo了解字段的名称、访问修饰符（如public或private）和实现详细信息（如static）等，并获取或设置字段值。
    （6）使用EventInfo了解事件的名称、事件处理程序数据类型、自定义属性、声明类型和反射类型等，添加或移除事件处理程序。
    （7）使用PropertyInfo了解属性的名称、数据类型、声明类型、反射类型和只读或可写状态等，获取或设置属性值。
    （8）使用ParameterInfo了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法签名中的位置等。
反射用到的命名空间：
    System.Reflection
    System.Type
    System.Reflection.Assembly
反射用到的主要类：
    System.Type 类－－通过这个类可以访问任何给定数据类型的信息。
    System.Reflection.Assembly类－－它可以用于访问给定程序集的信息，或者把这个程序集加载到程序中。
System.Type类：
    System.Type 类对于反射起着核心的作用。但它是一个抽象的基类，Type有与每种数据类型对应的派生类，我们使用这个派生类的对象的方法、字段、属性来查找有关该类型的所有信息。
    获取给定类型的Type引用有3种常用方式：
    ●使用 C# typeof 运算符。
        Type t = typeof(string);
    ●使用对象GetType()方法。
        string s = "grayworm";
        Type t = s.GetType();
    ●还可以调用Type类的静态方法GetType()。
        Type t = Type.GetType("System.String");
    上面这三类代码都是获取string类型的Type，在取出string类型的Type引用t后，我们就可以通过t来探测string类型的结构了。
            string n = "grayworm";
            Type t = n.GetType();
            foreach (MemberInfo mi in t.GetMembers())
                Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name);
    Type类的属性：
        Name 数据类型名
        FullName 数据类型的完全限定名(包括命名空间名)
        Namespace 定义数据类型的命名空间名
        IsAbstract 指示该类型是否是抽象类型
        IsArray   指示该类型是否是数组
        IsClass   指示该类型是否是类
        IsEnum   指示该类型是否是枚举
        IsInterface    指示该类型是否是接口
        IsPublic 指示该类型是否是公有的
        IsSealed 指示该类型是否是密封类
        IsValueType 指示该类型是否是值类型
    Type类的方法：
        GetConstructor(), GetConstructors()：返回ConstructorInfo类型，用于取得该类的构造函数的信息
        GetEvent(), GetEvents()：返回EventInfo类型，用于取得该类的事件的信息
        GetField(), GetFields()：返回FieldInfo类型，用于取得该类的字段（成员变量）的信息
        GetInterface(), GetInterfaces()：返回InterfaceInfo类型，用于取得该类实现的接口的信息
        GetMember(), GetMembers()：返回MemberInfo类型，用于取得该类的所有成员的信息
        GetMethod(), GetMethods()：返回MethodInfo类型，用于取得该类的方法的信息
        GetProperty(), GetProperties()：返回PropertyInfo类型，用于取得该类的属性的信息
    可以调用这些成员，其方式是调用Type的InvokeMember()方法，或者调用MethodInfo, PropertyInfo和其他类的Invoke()方法。
    查看类中的构造方法：
        NewClassw nc = new NewClassw();
        Type t = nc.GetType();
        ConstructorInfo[] ci = t.GetConstructors();    //获取类的所有构造函数
        foreach (ConstructorInfo c in ci) //遍历每一个构造函数
            ParameterInfo[] ps = c.GetParameters();    //取出每个构造函数的所有参数
            foreach (ParameterInfo pi in ps)   //遍历并打印所该构造函数的所有参数
                Console.Write(pi.ParameterType.ToString()+" "+pi.Name+",");
            Console.WriteLine();
让我们看一些代码。 您可以这样声明一个枚举：
 // Equivalent to enum Color {GREEN = 2, RED};
WISE_ENUM (Color, (GREEN, 2 ), RED)
 您还可以声明一个枚举类而不是一个枚举，显式指定存储，声明一个嵌套在一个类内的枚举，甚至改编一个已经声明的枚举：
 // Equivalent to enum class MoreColor : int64_t {BLUE, BLACK = 1
		Class 类的实例表示正在运行的 Java 应用程序中的类和接口；
		枚举是一种类，注解(指的是注解Annotation)是一种接口；
		每个数组都是 Class字节码类中的一个具体 对象
		基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象；
		1、 Class类 和它的实例的产生： Class的对象是已经存在的类型，
			所以不能够直接new一个Class对象出来，是通过Class类中的一个方法获取到的。
			例如：通过全限定路径类名
		2、同一种类型不管通过什么方式得到Class的实例都是相等的；一个类型的字节码对象只有一份，在元空间。
		3、Class的实例就看成是Java中我们学过的所有的数据类型在JVM中存在的一种状态（字节码对象）
		String.class   int.class  List.class  int[].class
 		1.概念：通过一个全限定类名，获取字节码文件
		2.作用：
			1. 提高开发灵活度，提高程序的扩展性
			2. 框架（提高开发效率的别人封装好的代码）底层都是使用反射技术。例如：Tomcat、Spring...
			3. 缺点：破坏封装性，性能低下（以后，能不用反射技术就不用）
		3. 使用：(重点)
			1. 获取字节码文件
					1.1 Class clazz  = Class.forName(全限定路径名) (最多使用)默认就是调用下面的方法
					1.2 static 类<?> forName(String name, boolean initialize, ClassLoader loader)  
							name:全限定路径名
							initialize:表示是否初始化，默认是false
							loader：可以指定一个类加载器加载字节码文件
				2. 全限定类名.class
				3. 对象名.getClass()
				Class类中方法newInstance()：创建当前字节码对象（只能调用无参且是public修饰的构造方法）
			2. 根据字节码文件获取构造方法、普通方法、字段等
				构造方法
				Constructor[] constructors = clazz.getConstructors() 获取public修饰的构造方法数组
				Constructor[] constructors = clazz.getDeclaredConstructors() 获取任意权限的所有造方法数组
				Constructor constructor = clazz.getConstructor(Class 参数字节码）根据参数类型获取public修饰的指定的的构造方法
				Constructor constructor = clazz.getDeclearConstructor(Class  参数字节码) 获取任意访问权限指定的构造方法
				//通过构造方法对象去用构造方法创建对象 => 相当于new 一个对象
				Object instance  = constructor.newInstance(Object 实参);//可以创建任意访问权限的有参或者无参构造
				普通方法
				Method[] methods = clazz.getMethods() 获取public修饰的构造方法数组,有父类中的方法
				Method[] methods = clazz.getDeclaredMethods() 获取任意访问权限所有造方法数组，并且都是自己的方法
				Method method = clazz.getMethod(String methodName,Class... 参数字节码）根据方法名和参数类型获取指定的的方法
					methodName:方法名
					Class：形参类型。如果方法没有形参，则Class可变参数不用写
				Method method = clazz.getDeclaredMethod(String methodName,Class... 参数字节码）根据方法名和参数类型获取指定的的方法
					methodName:方法名
					Class：形参类型。如果方法没有形参，则Class可变参数不用写
				//通过普通方法对象调用执行方法
				method.invoke(Object obj，Object... args);
					obj：对象。如果是对象的方法，就传入一个当前字节码创建的对象，如果是static方法，则写null
					args：就是具体实参
					Field[] fields = clazz.getFields() 获取public修饰的字段
					Field[] fields = clazz.getDeclaredFields() 获取任意权限所有字段
					Field field = clazz.getDeclaredField(String fieldName) 根据字段名获取任意访问权限的指定字段
					Field field = clazz.Field(String fieldName）根据字段名获取public的指定字段
				//通过当前的字段对象，给某一个字段赋值取值
				  	field.get(Object obj);//如果是属于非static，就传入一个对象，如果是静态的，就传入null
				  		obj：对象
					field.set(Object obj, Object value);//如果是属于非static，就传入一个对象，如果是静态的，就传入null
				  		obj：对象
						value：值
 			String getName()  获取全限定类名（全限定，包含包名）	Class类中方法
 			String getSimpleName()   获取类名简称			Class类中方法
 			Package getPackage()   获取包名				Class类中方法
 			T newInstance()  根据当前字节码创建对应的对象		Class类中方法
 			1. Class类中方法newInstance()：创建当前字节码对象（只能调用无参且是public修饰的构造方法）
 			2. Constructor类中方法newInstance(Object 实参);//可以创建任意访问权限的有参或者无参构造
 			3. 私有化方法、字段、构造方法都必须破坏封装才能使用：
 				public void setAccessible(boolean flag) true表示破坏封装，false是不破坏
 				是哪个private修饰的方法、字段、构造方法需要执行，就需要用这个对象破坏哪一个的封装
 					//获取cn.itsource.reflect.User字节码文件
 					Class<?> clazz = Class.forName("cn.itsource.reflect.User");
 					//获取User的有String参构造
 					Constructor<?> constructor = clazz.getConstructor(String.class);
 					//调用有参String构造，创建一个User对象
					Object newInstance = constructor.newInstance("某文");
					//获取private修饰的方法：testPrivate
					Method method2 = clazz.getDeclaredMethod("testPrivate");
					method2.setAccessible(true);//破坏普通方法Method封装
					//破坏封装后就可以执行了
					Object invoke2 = method2.invoke(newInstance);//没有形参就不用写
					System.out.println(invoke2);
 			4. 调用static方法、字段：
 					Field field = clazz.getDeclaredField("country");//获取任意访问权限静态变量country
					field.set(null, "中国");//因为字段country是static修饰，所以不用对象调用，就传入null。字段country赋值：中文
					Object object = field.get(null);//字段country取值
					System.out.println(object);	
2. 注解：
 		1.概念： 就是一个标签，有标签后，就具有某一些标签的特性。
 				本质就是跟类、接口、枚举平级的新结构
 		2.作用：
 			1. 帮助程序员校验代码
 			2. 可以提高开发效率和程序的扩展性
 				@Test
 				@Before
 				@After
 			3. 可以生成文档说明 api
 				操作步骤：
 					1．选中项目/代码，右键选中Export
					2．输入Javadoc
					3．第一个next（可以设置生成文档注释的目录），第二个next，设置字符集
						如果是UTF-8编码，且有中文，请输入-encoding UTF-8 -charset UTF-8   
 					4. 勾选一个生成完毕后，直接通过浏览器打开的选项
 					5. finish
 		3.使用：(重点)
 			1. 使用jdk或者别人定义好的标签
 				@ + 注解的名称  -- 比如@Override ->注解
 			2. 使用自定义的标签
 					1.JDK的元注解：就是专门用来声明其他注解的注解
 						作用：通过元注解了解其他注解的使用特点，还可以自定义注解
 					2.元注解： 
 						@Target
						@Target 作用
							用来限制被修饰注解的使用范围，即注解可以在类的哪些成员上使用
						@Target 取值使用ElementType.（）
							1.	CONSTRUCTOR:可以在构造器上使用注解
							2.	FIELD:可以在字段上使用注解
							3.	LOCAL_VARIABLE:可以在局部变量上使用注解
							4.	METHOD:可以在普通方法上使用注解
							5.	PACKAGE:可以在包上使用注解
							6.	PARAMETER:可以在参数列表上使用注解
							7.	TYPE:可以在类、接口(包括注解类型) 或enum上使用注解
							例如：@Target(ElementType.METHOD)//意味着@Override只能在普通方法上使用
								public @interface Override {
						@Retention
命名空间Namespace一般与程序集Assembly名称一致。
一个程序集Assembly由多个类型Type【interface,class,struct,enum,delegate】组成。
一个类型Type由方法Method，字段Field，属性Property，事件Event等成员等组成。
一个属性Property可能含有特性Attribute。
一个方法Method有返回类型，方法名，参数列表，是否是静态等组成
方法的参数Parameter有类型，参数名，默认值，是否引用参数ref，是否输出参数out
        AllowNestedDocks = 0x02,
        AllowTabbedDocks = 0x04,
        ForceTabbedDocks = 0x08,  // implies AllowTabbedDocks, !AllowNestedDocks
        VerticalTabs = 0x10,      // implies AllowTabbed...
  // 把一个字符串的第一个字母大写、效率是最高的、  
109     private static String getMethodName(String fildeName) throws Exception{  
110         ...
				
你可以在一个类中定义一个 `enum`，然后在另一个类中使用它。只需要在使用 `enum` 的类中包含定义 `enum` 的类的头文件即可。例如，假设你有以下的 `enum` 定义：
```c++
enum Color {
    GREEN,
如果你想在另一个类中使用这个 `enum`，你需要在该类的头文件中包含这个 `enum` 的定义。例如：
```c++
#include "Color.h"
class Shape {
public:
    // 构造函数
    Shape(Color color) : m_color(color) {}
private:
    Color m_color;
在上面的例子中，`Shape` 类的构造函数接受一个 `Color` 参数，并将其存储在 `m_color` 成员变量中。 `Color.h` 文件包含了 `Color` `enum` 的定义。