[转]java 通过反射获取类的全局变量、方法、构造方法


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;

    }

原文地址:https://www.cnblogs.com/2020fafa/p/11996826.html

时间: 2024-11-05 20:44:47

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

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

一:反射概念 可以通过Class类获取某个类的成员变量以及方法,并且调用之. 二:通过反射获取方法.变量.构造方法 1 @Test 2 // 通过反射获取类定义的方法 3 public void testMethod() throws Exception { 4 @SuppressWarnings("rawtypes") 5 Class clazz = Class.forName("java.lang.String"); 6 Method[] m = clazz.g

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

首先自定义三个类 package reflection1; public interface MtInterface { void info(); } package reflection1; import java.io.Serializable; public class Creature<T> implements Serializable { private char gender; public double weight; private void breath() { Syste

Java 使用反射获取类、方法、属性上的注释

有的时候我们想使用反射获取某个类的注释.方法上的注释.属性上的注释. 下面是一个简单的例子.里面包括了上面提到的三个点. package com.mine.practice.reflectfield; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Method; import javax.xml.bind.annotation.XmlAccessTy

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

using System; using System.Reflection; namespace ConsoleApp2 { class Program { static void Main(string[] args) { //反射获取 命名空间+类名 string className = "ConsoleApp2.ClassSample"; string methodName = "test1"; //传递参数 Object[] paras = new Obje

java 利用反射获取类对象中List的值

Field[] fields = Object.getClass().getDeclaredFields();//Object是已经被赋值的对象实例 for (Field field : fields) {if (!field.isAccessible()) { field.setAccessible(true); } if (List.class.isAssignableFrom(field.getType())) { Type t = field.getGenericType(); if (

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

首先说下反射是什么?反射是Sun公司推出的一组API,此组API位于Java.lang.reflect中 反射的作用是编写工具(例如eclipse),编写框架,当然对于一般的程序,我们不可能用反射来做这些事,一般反射大多是用于在构建类的实例以及调用类方法及属性. ok! 了解了反射是什么以及反射的应用领域,那么就来看看Java中是怎么实现反射的吧 Student类 public class Student {     public String name;     public String g

反射获取类的几种方法

1 public class Demo { 2 3 /** 4 * 反射:加载类,获得类的字节码 5 * @param args 6 * @throws ClassNotFoundException 7 */ 8 public static void main(String[] args) throws ClassNotFoundException { 9 10 //1 11 Class clazz = Class.forName("Person"); 12 13 //2 14 Cla

第六课 JAVA反射获取对象属性和方法(通过配置文件)

Service1.java package reflection; public class Service1 { public void doService1(){ System.out.println("业务方法1"); } } Service2.java package reflection; public class Service2 { public void doService2(){ System.out.println("业务方法1"); } } s

通过反射获取class文件中的构造方法,运行构造方法

/* * 通过反射获取class文件中的构造方法,运行构造方法 * 运行构造方法,创建对象 * 1.获取class文件对象 * 2.从class文件对象中,获取需要的成员 * * Constructor 描述构造方法对象类 */ 1.person类,用于测试获取无参的构造方法 package cn.itcast.demo1; public class Person { public String name; private int age; /*static{ System.out.printl