亲，你哪里困惑说出来啊。给你个参考，"JAVA反射机制"的百度百科。看哪里不懂。说出重点嘛。

求给黑马币，缺8个技术币就能获得7月30号培训班的资格了。。。。。:'(

这是我入学考试的一道题目，我觉得很经典，可以解释反射有什么好处。
ArrayList<Integer> list = new ArrayList<Integer>(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象。

1. public class insertStrToArray {
   
2.          public static void main(String[] args) throws Exception {
   
3.                  ArrayList<Integer> list = new ArrayList<Integer>();
   
4.                  Method methodAddString = list.getClass().getMethod("add", Object.class);
   
5.                  methodAddString.invoke(list, "abc");
   
6.                  System.out.println(list);
   
7.          }

复制代码

这个可以通过反射的方式实现，因为泛型的作用层在编译时。而反射直接获得了add方法的字节码跳过编译层在运行时直接添加。这样就骗过了编译。
这只是其中的一个作用，关于反射最重要的作用就是当你在项目后期想要往项目中增加功能但又不想改动程序的时候就可以使用反射，老师视频中举了主板的例子，你有没有视频，没有的话回复我你的QQ邮箱，我发给你。
我最近认识到的反射差不多就是这样，上面这道题是我入学考试不懂，查资料后才发现反射可以这么用的，关于反射的其他运用老师在视频中讲的很清楚，反射的方法用来用去就是forName,newInsance,constructor,getMethod,getField，getDeclaredField这几个把，你看看熟悉熟悉就行。

zzy891226 发表于 2015-7-22 18:06
你需要的话我可以把视频发给你，你给我黑马币吧，我缺黑马币

你都25个技术分 还要黑马币干嘛？

你需要的话我可以把视频发给你，你给我黑马币吧，我缺黑马币

这是我之前的总结，你看下

一，概述
反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。
简单说：反射技术可以对一个类进行解剖。
反射的好处：大大的增强了程序的扩展性。

二，反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。

三，获取Class对象
有三种方式：
1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。
2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。
前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。
3：使用的Class类中的方法，静态的forName方法。
         指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。
// 1. 根据给定的类名来获得  用于类加载
String classname = "cn.itcast.reflect.Person";// 来自配置文件
Class clazz = Class.forName(classname);// 此对象代表Person.class
// 2. 如果拿到了对象，不知道是什么类型   用于获得对象的类型
Object obj = new Person();
Class clazz1 = obj.getClass();// 获得对象具体的类型
// 3. 如果是明确地获得某个类的Class对象  主要用于传参
Class clazz2 = Person.class;       

四，反射的用法：
1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式：
        Class.forName(classname)        用于做类加载
        obj.getClass()                                用于获得对象的类型
        类名.class                            用于获得指定的类型，传参用

2)、反射类的成员方法：
        Class clazz = Person.class;
        Method method = clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2});
        method.invoke();
       
3)、反射类的构造函数：
        Constructor con = clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...})
        con.newInstance(params...)

4)、反射类的属性：
        Field field = clazz.getField(fieldName);
        field.setAccessible(true);
        field.setObject(value);
4.1创建指定类的对象：
获取了字节码文件对象后，最终都需要创建指定类的对象：
创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)：
1，调用空参数的构造函数：使用了Class类中的newInstance()方法。
2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。

综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。
// 如何生成获取到字节码文件对象的实例对象。
Class clazz = Class.forName("cn.itcast.bean.Person");//类加载
// 直接获得指定的类型
        clazz = Person.class;
// 根据对象获得类型
        Object obj = new Person("zhangsan", 19);
        clazz = obj.getClass();

        Object obj = clazz.newInstance();//该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？
        public static void method_2() throws Exception {
                Class clazz = Class.forName("cn.itcast.bean.Person");
                //既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。
                //获取一个带参数的构造器。
                Constructor constructor = clazz.getConstructor(String.class,int.class);
                //想要对对象进行初始化，使用构造器的方法newInstance();
                Object obj = constructor.newInstance("zhagnsan",30);
                //获取所有构造器。
                Constructor[] constructors = clazz.getConstructors();//只包含公共的
                constructors = clazz.getDeclaredConstructors();//包含私有的
                for(Constructor con : constructors) {
                        System.out.println(con);
                }
        }

反射指定类中的方法：
        //获取类中所有的方法。
        public static void method_1() throws Exception {
                Class clazz = Class.forName("cn.itcast.bean.Person");
                Method[] methods = clazz.getMethods();//获取的是该类中的公有方法和父类中的公有方法。
                methods = clazz.getDeclaredMethods();//获取本类中的方法，包含私有方法。
                for(Method method : methods) {
                        System.out.println(method);
                }
        }
        //获取指定方法；
        public static void method_2() throws Exception {
                Class clazz = Class.forName("cn.itcast.bean.Person");
                //获取指定名称的方法。
                Method method = clazz.getMethod("show", int.class,String.class);
                //想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。
                Object obj = clazz.newInstance();
                method.invoke(obj, 39,"hehehe");//执行一个方法
        }
        //想要运行私有方法。
        public static void method_3() throws Exception {
                Class clazz = Class.forName("cn.itcast.bean.Person");
                //想要获取私有方法。必须用getDeclearMethod();
                Method method = clazz.getDeclaredMethod("method", null);
                // 私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。
                method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。
        }
        //反射静态方法。
        public static void method_4() throws Exception {
                Class clazz = Class.forName("cn.itcast.bean.Person");
                Method method = clazz.getMethod("function",null);
                method.invoke(null,null);
        }

反射我都还没有学到呢，正在努力ing.

兄弟，可以的  我懂你

我也不懂发射哈，同求！

反射其实也挺简单的，只需要看懂前两个视频入门。它就是类中的字段，方法，构造方法封装成了反射的类。通过反射类中的方法获取一个类中的成员，包括任何权限的成员。耐心点，其实不难的

亲，你哪里困惑说出来啊。给你个参考，"JAVA反射机制"的百度百科。看哪里不懂。说出重点嘛。

段燚涛 发表于 2015-7-18 14:07
谢谢！技术分怎么赚？？

我也正苦恼这个呢。。。呵呵

xiaoshaoye 发表于 2015-7-18 09:06
楼上不要打击人啊。。楼主不要着急，慢慢看，不要急，一点一点的扣，不懂得地方就baidu下看看是怎么解释的 ...

谢谢！技术分怎么赚？？

楼上不要打击人啊。。楼主不要着急，慢慢看，不要急，一点一点的扣，不懂得地方就baidu下看看是怎么解释的。肯定很快就好了。

反射式个简单到不行的东西

Java的反射体制，是指在JVM运行环境下，对类进行动态讲解的一种方式。和我们常规的new对象不同；new Object属于硬编码，而反射更像是一种在运行时动态编写的代码块。

可参考：通过Java反射机制，动态给对象属性赋值，并获取属性值

1. package com.matol;
   
2. 
   
3. import java.lang.reflect.Field;
   
4. import java.lang.reflect.Method;
   
5. import java.text.SimpleDateFormat;
   
6. import java.util.Date;
   
7. import java.util.HashMap;
   
8. import java.util.Locale;
   
9. import java.util.Map;
   
10. import java.util.Map.Entry;
    
11. 
    
12. /*
    
13. * 通过Java反射机制，动态给对象属性赋值，并获取属性值
    
14. */
    
15. public class ClassRefUtil {
    
16. 
    
17.     /**
    
18.      * @param args
    
19.      */
    
20.     public static void main(String[] args) {
    
21.         Map<String, String> valMap = new HashMap<String, String>();  
    
22.         valMap.put("userName", "michael");  
    
23.         valMap.put("age", "27");  
    
24.         valMap.put("height", "173.5");  
    
25.         valMap.put("date", "2010-10-24");  
    
26.         valMap.put("times", "1287932898276");  
    
27.         valMap.put("flag", "false");  
    
28.    
    
29.         ChildInfo rl = new ChildInfo();
    
30.         System.out.println("通过反射赋值.");  
    
31.         PublicUtil.setFieldValue(rl, valMap);  
    
32.    
    
33.         System.out.println("通过反射取值:");  
    
34.         int i = 0;
    
35.         Map<String, String> fieldValMap = PublicUtil.getFieldValueMap(rl);
    
36.         for (Entry<String, String> entry : fieldValMap.entrySet()) {  
    
37.             i++;
    
38.             System.out.println("[字段 "+i+"] ["+entry.getKey()+"]   ---   [" + entry.getValue()+"]");  
    
39.         }  
    
40.     }
    
41.      
    
42.      
    
43.     /**
    
44.      * 取Bean的属性和值对应关系的MAP
    
45.      * @param bean
    
46.      * @return Map
    
47.      */
    
48.     public static Map<String, String> getFieldValueMap(Object bean) {  
    
49.         Class<?> cls = bean.getClass();  
    
50.         Map<String, String> valueMap = new HashMap<String, String>();  
    
51.         // 取出bean里的所有方法  
    
52.         Method[] methods = cls.getDeclaredMethods();  
    
53.         Field[] fields = cls.getDeclaredFields();  
    
54.    
    
55.         for (Field field : fields) {  
    
56.             try {  
    
57.                 String fieldType = field.getType().getSimpleName();  
    
58.                 String fieldGetName = parGetName(field.getName());  
    
59.                 if (!checkGetMet(methods, fieldGetName)) {  
    
60.                     continue;  
    
61.                 }  
    
62.                 Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});  
    
63.                 Object fieldVal = fieldGetMet.invoke(bean, new Object[] {});  
    
64.                 String result = null;  
    
65.                 if ("Date".equals(fieldType)) {  
    
66.                     result = fmtDate((Date) fieldVal);  
    
67.                 } else {  
    
68.                     if (null != fieldVal) {  
    
69.                         result = String.valueOf(fieldVal);  
    
70.                     }  
    
71.                 }  
    
72.                 valueMap.put(field.getName(), result);  
    
73.             } catch (Exception e) {  
    
74.                 continue;  
    
75.             }  
    
76.         }  
    
77.         return valueMap;  
    
78.    
    
79.     }  
    
80.    
    
81.     /**
    
82.      * set属性的值到Bean
    
83.      * @param bean
    
84.      * @param valMap
    
85.      */
    
86.     public static void setFieldValue(Object bean, Map<String, String> valMap) {  
    
87.         Class<?> cls = bean.getClass();  
    
88.         // 取出bean里的所有方法  
    
89.         Method[] methods = cls.getDeclaredMethods();  
    
90.         Field[] fields = cls.getDeclaredFields();  
    
91.    
    
92.         for (Field field : fields) {  
    
93.             try {  
    
94.                 String fieldSetName = parSetName(field.getName());  
    
95.                 if (!checkSetMet(methods, fieldSetName)) {  
    
96.                     continue;  
    
97.                 }  
    
98.                 Method fieldSetMet = cls.getMethod(fieldSetName, field.getType());  
    
99.                 String value = valMap.get(field.getName());  
    
100.                 if (null != value && !"".equals(value)) {  
     
101.                     String fieldType = field.getType().getSimpleName();  
     
102.                     if ("String".equals(fieldType)) {  
     
103.                         fieldSetMet.invoke(bean, value);  
     
104.                     } else if ("Date".equals(fieldType)) {  
     
105.                         Date temp = parseDate(value);  
     
106.                         fieldSetMet.invoke(bean, temp);  
     
107.                     } else if ("Integer".equals(fieldType) || "int".equals(fieldType)) {  
     
108.                         Integer intval = Integer.parseInt(value);  
     
109.                         fieldSetMet.invoke(bean, intval);  
     
110.                     } else if ("Long".equalsIgnoreCase(fieldType)) {  
     
111.                         Long temp = Long.parseLong(value);  
     
112.                         fieldSetMet.invoke(bean, temp);  
     
113.                     } else if ("Double".equalsIgnoreCase(fieldType)) {  
     
114.                         Double temp = Double.parseDouble(value);  
     
115.                         fieldSetMet.invoke(bean, temp);  
     
116.                     } else if ("Boolean".equalsIgnoreCase(fieldType)) {  
     
117.                         Boolean temp = Boolean.parseBoolean(value);  
     
118.                         fieldSetMet.invoke(bean, temp);  
     
119.                     } else {  
     
120.                         System.out.println("not supper type" + fieldType);  
     
121.                     }  
     
122.                 }  
     
123.             } catch (Exception e) {  
     
124.                 continue;  
     
125.             }  
     
126.         }  
     
127.    
     
128.     }  
     
129.    
     
130.     /**
     
131.      * 格式化string为Date
     
132.      * @param datestr
     
133.      * @return date
     
134.      */
     
135.     private static Date parseDate(String datestr) {  
     
136.         if (null == datestr || "".equals(datestr)) {  
     
137.             return null;  
     
138.         }  
     
139.         try {  
     
140.             String fmtstr = null;  
     
141.             if (datestr.indexOf(':') > 0) {  
     
142.                 fmtstr = "yyyy-MM-dd HH:mm:ss";  
     
143.             } else {  
     
144.                 fmtstr = "yyyy-MM-dd";  
     
145.             }  
     
146.             SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK);  
     
147.             return sdf.parse(datestr);  
     
148.         } catch (Exception e) {  
     
149.             return null;  
     
150.         }  
     
151.     }  
     
152.     /**
     
153.      * 日期转化为String
     
154.      * @param date
     
155.      * @return date string
     
156.      */
     
157.     private static String fmtDate(Date date) {  
     
158.         if (null == date) {  
     
159.             return null;  
     
160.         }  
     
161.         try {  
     
162.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);  
     
163.             return sdf.format(date);  
     
164.         } catch (Exception e) {  
     
165.             return null;  
     
166.         }  
     
167.     }  
     
168.    
     
169.     /**
     
170.      * 判断是否存在某属性的 set方法
     
171.      * @param methods
     
172.      * @param fieldSetMet
     
173.      * @return boolean
     
174.      */
     
175.     private static boolean checkSetMet(Method[] methods, String fieldSetMet) {  
     
176.         for (Method met : methods) {  
     
177.             if (fieldSetMet.equals(met.getName())) {  
     
178.                 return true;  
     
179.             }  
     
180.         }  
     
181.         return false;  
     
182.     }  
     
183.     /**
     
184.      * 判断是否存在某属性的 get方法
     
185.      * @param methods
     
186.      * @param fieldGetMet
     
187.      * @return boolean
     
188.      */
     
189.     private static boolean checkGetMet(Method[] methods, String fieldGetMet) {  
     
190.         for (Method met : methods) {  
     
191.             if (fieldGetMet.equals(met.getName())) {  
     
192.                 return true;  
     
193.             }  
     
194.         }  
     
195.         return false;  
     
196.     }  
     
197.    
     
198.     /**
     
199.      * 拼接某属性的 get方法
     
200.      * @param fieldName
     
201.      * @return String
     
202.      */
     
203.     private static String parGetName(String fieldName) {  
     
204.         if (null == fieldName || "".equals(fieldName)) {  
     
205.             return null;  
     
206.         }  
     
207.         return "get" + fieldName.substring(0, 1).toUpperCase()  
     
208.                 + fieldName.substring(1);  
     
209.     }  
     
210.     /**
     
211.      * 拼接在某属性的 set方法
     
212.      * @param fieldName
     
213.      * @return String
     
214.      */
     
215.     private static String parSetName(String fieldName) {  
     
216.         if (null == fieldName || "".equals(fieldName)) {  
     
217.             return null;  
     
218.         }  
     
219.         return "set" + fieldName.substring(0, 1).toUpperCase()  
     
220.                 + fieldName.substring(1);  
     
221.     }
     
222. 
     
223. }

复制代码