1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.str;
 
public class ZiFuChuan {
     
    public static String ss = "全局变量!!!!!!";
    String s2 = null;
    public int aa = 1 ;
    int aa2;
    double dou = 1.1;
    Double d = new Double(1.1);
    public static void main(String[] args) {}
     
    public ZiFuChuan(){}
     
    public ZiFuChuan(String st){}
     
    public ZiFuChuan(int orgInt,String orgString){}
 
    public static void tmpArr(int a[],String s,StringBuffer s2){}
}
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
package com.fanshe;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
 
import com.str.ZiFuChuan;
 
public class GetClass {
 
    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InstantiationException {
        // TODO Auto-generated method stub
        Class classS = ZiFuChuan.class;
         
        //获取包
        Package classPackage = classS.getPackage();
        System.out.println("package "+classPackage.getName());
        //获取类的修饰符
        int mod = classS.getModifiers();
        String classModifier = Modifier.toString(mod);
        System.out.println(classModifier + " class ZiFuChuan {");
        //调用全局变量方法
        getFieldContent(classS);
        //调用构造方法
        getConstructorContent(classS);
        //调用其他方法
        getMethodContent(classS);
        System.out.println("}");
    }
     
    /**
     * 获取所有全局变量
     * @param classS
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InstantiationException
     */
    public static void getFieldContent(Class classS) throws IllegalArgumentException, IllegalAccessException, InstantiationException{
         
        String typeName = "";
        Field[] field =  classS.getDeclaredFields();
         
         for(Field fi : field){
              
             typeName = fi.getType().getName();
             String xsfTmp = Modifier.toString(fi.getModifiers()) ;
              
             //全局变量有修饰符的在变量前加修饰符并且修饰符和数据类型之间用空格分隔,否则不需要加空格
             String xiushifu = xsfTmp.length() == 0 ? "" : xsfTmp + " ";
             String value = getValue(typeName,fi,classS);
              
             if("null".equals(value)||value == null||"null;".equals(value)){
                 System.out.println("    "+xiushifu+typeName+" "+fi.getName()+"; ");
             }else{
                 System.out.println("    "+xiushifu+typeName+" "+fi.getName()+" = " + getValue(typeName,fi,classS));
             }
              
         }
    }
     
    public static void getConstructorContent(Class classS){
         
        Constructor[] con = classS.getConstructors();
        for(Constructor c : con){
            int mod = c.getModifiers();
            String ConstructorModifier = Modifier.toString(mod);
            String constructorParameter = getConstructorParameter(c);
            System.out.println("    "+ConstructorModifier+" " + c.getName() + "("+constructorParameter+"){");
            System.out.println("    }");
        }
         
    }
     
    /**
     * 获取构造方法中的参数
     * @param c
     * @return
     */
    public static String getConstructorParameter(Constructor c){
        String qxTemp = "";
        String qx = "";
        int con = 0;
        Class[] parameterTypeArr = c.getParameterTypes();
         
        //获取构造方法中的参数
        for(Class clas : parameterTypeArr){
             
            qxTemp += clas.getTypeName() + " org"+con+",";
            con++;
             
        }
         
        int qxTempLength = qxTemp.length();
         
        //去掉空参的构造方法
        if(qxTempLength > 0){
            qx = qxTemp.substring(0, qxTempLength-1);
        }
         
        return qx;
    }
     
    /**
     * 获取除构造方法外其他的方法的逻辑
     * @param classS
     */
    public static void getMethodContent(Class classS){
        Method[] method = classS.getDeclaredMethods();
        for(Method m : method){
             
            int mod = m.getModifiers();
            String methodModifier = Modifier.toString(mod);
            //获取方法返回值类型
            Type type = m.getGenericReturnType();
            String methodParameter = getMethodParameter(m);
            System.out.println("    "+methodModifier +" "+ type.getTypeName() +" " + m.getName() + "("+methodParameter+"){");
            System.out.println("    }");
        }
         
    }
     
    /**
     * 获取其他方法的参数
     * @param m
     * @return
     */
    public static String getMethodParameter(Method m){
        String qxTemp = "";
        String qx = "";
        int con = 0;
        Class[] parameterTypeArr = m.getParameterTypes();
         
        //获取构造方法中的参数
        for(Class clas : parameterTypeArr){
             
            qxTemp += clas.getTypeName()+" org"+con+",";
            con++;
             
        }
         
        int qxTempLength = qxTemp.length();
         
        //去掉空参的构造方法
        if(qxTempLength > 0){
            qx = qxTemp.substring(0, qxTempLength-1);
        }
         
        return qx;
         
    }
    /**
     * 全局变量初始化值
     * @param typeName
     * @param fi
     * @param classS
     * @return
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static String getValue(String typeName,Field fi,Class classS) throws IllegalArgumentException, IllegalAccessException, InstantiationException{
        String value = "";
         
        Object obj = classS.newInstance();
        fi.setAccessible(true);
         
        String[] types = {"java.lang.Integer",
                "java.lang.Double",
                "java.lang.Float",
                "java.lang.Long",
                "java.lang.Short",
                "java.lang.Byte",
                "java.lang.Boolean",
                "java.lang.Character",
                "int","double","long","short","byte","boolean","char","float"};
         
        for(String str : types) {
             
            if(fi.getType().getName().equals("java.lang.String")){
                Object fiObj = fi.get(obj);
                //判断变量是否初始化
                if(fiObj != null){
                    //String 类型参数需要用双引号扩上
                    value = "\""+fiObj.toString()+"\";";
                }else{
                    value = null;
                }
            }else if(fi.getType().getName().equals(str)){
                 value = fi.get(obj).toString()+";";
            }
             
        }      
         
        return value;
    }

[转]java 通过反射获取类的全局变量、方法、构造方法的更多相关文章

  1. java利用反射获取类的属性及类型

    java利用反射获取类的属性及类型. import java.lang.reflect.Field; import java.math.BigDecimal; import java.util.Map ...

  2. java通过反射获取调用变量以及方法

    一:反射概念 可以通过Class类获取某个类的成员变量以及方法,并且调用之. 二:通过反射获取方法.变量.构造方法 @Test // 通过反射获取类定义的方法 public void testMeth ...

  3. java 通过反射获取类属性结构,类方法,类父类及其泛型,类,接口和包

    首先自定义三个类 package reflection1; public interface MtInterface { void info(); } package reflection1; imp ...

  4. java利用反射调用类的某个方法

    java利用反射机制 可以动态调用某个类的某个方法,在 扩展系统功能或提供对外接口时经常用的到. 代码如下: 打印类Print.java package com.test.reflct; /** * ...

  5. C#通过反射获取类中的方法和参数个数,反射调用方法带参数

    using System; using System.Reflection; namespace ConsoleApp2 { class Program { static void Main(stri ...

  6. Java反射学习-1 - 反射获取类的属性,方法,构造器

    新建一个Person类 package cn.tx.reflect; /** * 注解初步了解 * @author Administrator * */ public class Person { p ...

  7. java 通过反射获取调用类方法及属性

    首先说下反射是什么?反射是Sun公司推出的一组API,此组API位于Java.lang.reflect中 反射的作用是编写工具(例如eclipse),编写框架,当然对于一般的程序,我们不可能用反射来做 ...

  8. java利用反射获取对象前后修改的内容(用于日志记录)

    import java.beans.PropertyDescriptor; import java.lang.reflect.Field; import java.lang.reflect.Metho ...

  9. Java利用反射取得类的所有信息

    Java中可以利用反射获取类的名称.构造函数.属性.方法.也就是说可以通过反射可以取得类的所有信息(不管该成员是否封装为private). 如有下面的Dept类定义: package org.lyk. ...

随机推荐

  1. Mysql的安装、配置、优化

    Mysql的安装.配置.优化 安装步骤 1.先单击中的安装文件,如果是win7系统,请选择以管理员的方式运行. 2.大概需要30秒的时间,开始进入安装界面.请先把标红的打勾,好进行下一步的动作. 3. ...

  2. 利用WPF生成Q币充值二维码——扫码登录篇

    一.前言 虽然腾讯官方不支持使用二维码充值Q币,但对于喜欢钻研的人来说这不是问题,本文利用WPF技术讲解从扫码登录到生成Q币充值二维码的一整套解决方案. 因为充值Q币需要先用QQ号登录官网.所以我们首 ...

  3. Java描述设计模式(14):解释器模式

    本文源码:GitHub·点这里 || GitEE·点这里 一.解释器模式 1.基础概念 解释器模式是对象的行为模式.给定一个语言之后,解释器模式可以定义出其文法的一种表示,并同时提供一个解释器.客户端 ...

  4. Java题库——Chapter16 JavaFX UI组件和多媒体

    Chapter 16 JavaFX UI Controls and Multimedia Section 16.2 Labeled and Label1. To create a label with ...

  5. WebShell代码分析溯源(九)

    WebShell代码分析溯源(九) 一.一句话变形马样本 <?php $e = $_REQUEST['e'];$arr = array($_POST['pass'] => '|.*|e', ...

  6. 关于c# winform 键盘响应右边键盘消息响应事件的上下左右方向键没有反应

    原文作者:aircraft 原文链接:https://www.cnblogs.com/DOMLX/p/11835642.html 记录一下这个小坑,c# winform 键盘响应右边键盘的上下左右方向 ...

  7. 如何正确使用 Spring Cloud?【下】

    5. Spring Cloud 如何融合 DevOps? 接下来,我们来了解一下 Spring Cloud 在与 DevOps 融合方面可以做哪些事情,它是如何让应用持续交付更加快捷的?我们都知道,D ...

  8. Hibernate 框架入门

    接着上一篇的 Hibernate 框架的了解,我们就继续学习 Hibernate 框架.这次就进入 Hibernate 框架的入门学习. 首先在学习 Hibernate 框架之前,我们要准备好我们需要 ...

  9. [css display],table待续

    昨天复习了flex布局,今天打算继续,才发现有display:table,今天有的点,别的先写上,其他的后补吧 css display // none 此元素不会被显示. // block 此元素将显 ...

  10. css里的背景属性有哪些,如何去使用哪些属性

    分类:纯色背景    背景图像 1.背景颜色 background-color : 任意合法的颜色 和 transparent 2.背景图像 background-image : url(想要加载的图 ...