设计模式——搓澡模板

            1
            public
            class
             Bath {

            2
            public
            void
             bathing(){

            3         System.out.println("入浴：更衣解带，进入浴房");
4         System.out.println("洗头：一盆顶水湿全身，先抹飘油洗秃顶。。。");
5         System.out.println("洗身：浴球在手，全身都有——左刷刷，右刷刷，前刷刷，后刷刷，上刷刷，下刷刷。。。");
6         System.out.println("出浴：洗罢冲净，盛装出浴");
7    }
8 }

            public
            class
             Bath {
    
            public
            void
             bathing(){
        
            this
            .enterTheBathroom();
        
            this
            .washThehair();
        
            this
            .washTheBody();
        
            this
            .outTheBathroom();
    }


    
            private
            void
             enterTheBathroom(){
        System.out.println("其实，对于我等屌丝来说，宽衣解带？不存在的。经常是一条裤子一挎，就已经是裸体状态了。。。（此处有1万字）");
    }

    privatevoid washThehair(){
        System.out.println("我不经意间摸到了自己不再茂盛的秀发，不觉有些感伤，想到自己撸码不过几年光景，头发就如秋风一扫，簌簌直掉。。。（此处有1万字）");
    }


    privatevoid washTheBody(){
        System.out.println("其实自己喜欢舒肤佳多一点，喜欢香皂在自己肌肤上滑过的细腻感。不过因为太滑，香皂总掉旁边的茅坑里，即使侥幸没掉坑里，也总怕谁冷不丁的在背后替我将肥皂捡起。。。（此处有1万字）");
    }

    privatevoid outTheBathroom(){
        System.out.println("洗完澡我才猛然发现，根本就没带衣服进来。。。（此处有1万字）");
    }
}

            public
            interface
             BathStep {

    
            void
             enterTheBathroom();

    
            void
             washThehair();

    
            void
             washTheBody();

    
            void
             outTheBathroom();
}



            public
            class MyBath implements BathStep{

    publicvoid bathing(){
        this.enterTheBathroom();
        this.washThehair();
        this.washTheBody();
        this.outTheBathroom();
    }

    @Override
    publicvoid enterTheBathroom(){
        System.out.println("其实，对于我等屌丝来说，宽衣解带？不存在的。经常是一条裤子一挎，就已经是裸体状态了。。。（此处有1万字）");
    }

    @Override
    publicvoid washThehair(){
        System.out.println("我不经意间摸到了自己不再茂盛的秀发，不觉有些感伤，想到自己撸码不过几年光景，头发就如秋风一扫，簌簌直掉。。。（此处有1万字）");
    }

    @Override
    publicvoid washTheBody(){
        System.out.println("其实自己喜欢舒肤佳多一点，喜欢香皂在自己肌肤上滑过的细腻感。不过因为太滑，香皂总掉旁边的茅坑里，即使侥幸没掉坑里，也总怕谁冷不丁的在背后替我将肥皂捡起。。。（此处有1万字）");
    }
    @Override
    publicvoid outTheBathroom(){
        System.out.println("洗完澡我才猛然发现，根本就没带衣服进来。。。（此处有1万字）");
    }
}

            public
            abstract
            class
             Bath {
    
    
            public
            final
            void
             bathing(){
        
            this
            .enterTheBathroom();
        
            this
            .washThehair();
        
            this
            .washTheBody();
        
            this
            .outTheBathroom();
    }

    
            //
             需要子类具体实现的步骤
            abstract
            void
             enterTheBathroom();
    
    
            //
             需要子类具体实现的步骤
            abstract
            void
             washThehair();

    
            public
            void
             washTheBody(){
        System.out.println("其实自己喜欢舒肤佳多一点，喜欢香皂在自己肌肤上滑过的细腻感。不过因为太滑，香皂总掉旁边的茅坑里，即使侥幸没掉坑里，也总怕谁冷不丁的在背后替我将肥皂捡起。。。（此处有1万字）");
    }
    
    publicvoid outTheBathroom(){
        System.out.println("洗完澡我才猛然发现，根本就没带衣服进来。。。（此处有1万字）");
    }
}

            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) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.                destroyBeans();

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

                // Propagate exception to caller.throw ex;
            }

            finally {
                // Reset common introspection caches in Spring‘s core, since we
                // might not ever need metadata for singleton beans anymore...                resetCommonCaches();
            }
        }
    }