方法屏蔽之传统方式

一时失言乱红尘 2022-11-03 11:45 154阅读 0赞

/**
     * 传统方式隐藏类中的method
     */
    public class MethodHide {
    
        // 这个接口职责不分明
        interface Management {
            void read();
    
            void write();
    
            String state();
    
            void stop();
        }
        
        // ====================拆分成下面两个接口
    
        // 操作
        interface Opt {
            void read();
    
            void write();
        }
        // 控制
        interface Ctl {
            String state();
    
            void stop();
        }
    
        // 实现上面两个接口
        static class Impl implements Opt, Ctl {
    
            @Override
            public void read() {
    
            }
    
            @Override
            public void write() {
    
            }
    
            @Override
            public String state() {
                return null;
            }
    
            @Override
            public void stop() {
    
            }
        }
    
        static class Readable {
            private final Opt opt;
    
            Readable(Opt opt) {
                this.opt = opt;
            }
    
            // 通过Opt接口，相当于把另外两个方法屏蔽了
            // 只能看到read/write方法
            // 这样职责清晰了
            public void delegateRead() {
                opt.read();
            }
        }
    
        public static void main(String[] args) {
            Impl management = new Impl();
            new Readable(management);
        }
    
    }

或者采用包装类，比如

Executors.newSingleThreadExecutor()

的源码

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

就是使用了 FinalizableDelegatedExecutorService包装类，其目的是：

是一个包装类，仅仅只暴露 ExecutorService 的一个实现类的方法.