1. import java.beans.IntrospectionException;
   
2. import java.beans.PropertyDescriptor;
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.lang.reflect.Method;
   
5. 
   
6. public class IntroSspectorTest {
   
7. 
   
8. public static void main(String[] args) throws Exception {
   
9. 
   
10. ReflectPoint pt1 = new ReflectPoint(3,6);
    
11. 
    
12. String propertyName = "x";
    
13. 
    
14. Object retVal = getProperty(pt1, propertyName);//此处抽取代码的作用和意义是什么？
    
15. System.out.println(retVal);
    
16. 
    
17. int value = 9 ;
    
18. setProperty(pt1, propertyName, value);//还有此处
    
19. 
    
20. System.out.println(pt1.getX());
    
21. 
    
22. 
    
23. }
    
24. 
    
25. private static void setProperty(Object pt1, String propertyName,
    
26. int value) throws IntrospectionException, IllegalAccessException,
    
27. InvocationTargetException {
    
28. PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass() );
    
29. Method methodSetX = pd2.getWriteMethod();
    
30. methodSetX.invoke(pt1, value);
    
31. }
    
32. 
    
33. private static Object getProperty(Object pt1, String propertyName)
    
34. throws IntrospectionException, IllegalAccessException,
    
35. InvocationTargetException {
    
36. PropertyDescriptor pd1 = new PropertyDescriptor(propertyName,pt1.getClass() );
    
37. Method methodGetX = pd1.getReadMethod();
    
38. Object retVal = methodGetX.invoke(pt1);
    
39. return retVal;
    
40. }
    
41. 
    
42. }
    

复制代码

代码抽取之后和不抽取运行结果一样，好像并没简化书写，那么抽取代码的意义是什么呢？望指点

目测楼主还没有领悟到小函数的魅力~ 你这里代码不够长~~还不够晕~

从Spring找了一个经典的函数来展示一下小函数的魅力~这个函数的作用是什么不需要知道，Spring IOC容器初始化时调用的刷新函数，如果把这些小函数的代码全部丢到这里面，会给读者带来很大的麻烦，维护的时候也很有困难~

把代码分成一个个的小函数，每个函数从名字就可以看出作用是什么，思路很清晰

public void refresh() throws BeansException, IllegalStateException {
                synchronized (this.startupShutdownMonitor) {
                        // Prepare this context for refreshing.
                        prepareRefresh();

                        // Tell the subclass to refresh the internal bean factory.
                        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

                        // Prepare the bean factory for use in this context.
                        prepareBeanFactory(beanFactory);

                        try {
                                // Allows post-processing of the bean factory in context subclasses.
                                postProcessBeanFactory(beanFactory);

                                // Invoke factory processors registered as beans in the context.
                                invokeBeanFactoryPostProcessors(beanFactory);

                                // Register bean processors that intercept bean creation.
                                registerBeanPostProcessors(beanFactory);

                                // Initialize message source for this context.
                                initMessageSource();

                                // Initialize event multicaster for this context.
                                initApplicationEventMulticaster();

                                // Initialize other special beans in specific context subclasses.
                                onRefresh();

                                // Check for listener beans and register them.
                                registerListeners();

                                // Instantiate all remaining (non-lazy-init) singletons.
                                finishBeanFactoryInitialization(beanFactory);

                                // Last step: publish corresponding event.
                                finishRefresh();
                        }

                        catch (BeansException ex) {
                                // Destroy already created singletons to avoid dangling resources.
                                beanFactory.destroySingletons();

                                // Reset 'active' flag.
                                cancelRefresh(ex);

                                // Propagate exception to caller.
                                throw ex;
                        }
                }


抽取方法（extract method）是重构的主要方法之一

在这里抽取代码主要是便于后期阅读与维护，也可以方便他人阅读。还有就是可以提高代码的重用性。例如多个地方都用到了作用相同的多行代码，就可以将这些代码抽取到方法里面，供多个地方调用

"Object retVal = getProperty(pt1, propertyName);// 此处抽取代码的作用和意义是什么？"

1. PropertyDescriptor pd1 = new PropertyDescriptor(propertyName,
   
2.                                 pt1.getClass());
   
3.                 Method methodGetX = pd1.getReadMethod();
   
4.                 Object retVal = methodGetX.invoke(pt1);
   
5.                 return retVal;

复制代码

将以上代码封装在getProperty()方法里不是增加了代码的重用性,并且精简了代码么,这就是抽取代码的作用和意义.



"setProperty(pt1, propertyName, value);// 还有此处"

理由同上.