java编程思想中的设计模式

• 动态代理模式

　　　　在任何时刻，只要你想将额外的操作分离到不同的地方，特别是希望额外的操作不影响原来的操作方法时，代理模式就显得非常有用

• 适配器模式

　　　　demo
　　　　产生适配foreach的反向迭代器Iterator:

　　　　

　　　　

/**
 * @author Ldl 
 * @since 1.0.0
 */
public class Adapter {

    class ReversibleArrayList<T> extends ArrayList<T> {
        protected ReversibleArrayList(Collection<T> c) {
            super(c);
        }

        protected Iterable<T> reversed() {
            return new Iterable<T>() {

                @Override
                public Iterator<T> iterator() {
                    return new Iterator<T>() {
                        int current = size() - 1;

                        public boolean hasNext() {
                            return current > -1;
                        }

                        public T next() {
                            return get(current--);
                        }

                        public void remove() {
                            try {
                                throw new Exception("不支持的操作");
                            } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                    };
                }
                
            };
        }
    }
    

    


    /**
     * Adapter.main()
     * @Author Ldl
     * @Date 2017年3月16日
     * @since 1.0.0
     * @param args
     */
    public static void main(String[] args) {
        Adapter a = new Adapter();
        Adapter.ReversibleArrayList<String> ral = new Adapter().new ReversibleArrayList<>(
                Arrays.asList("To be or not to be".split(" ")));

        for (String fs : ral) {
            System.out.println(fs + "-- ");
        }

        for (String bs : ral.reversed()) {
            System.out.println(bs + "-- ");
        }

    }

•  策略模式　　

　　　把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口，然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。

　　　比如定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换，使得算法可独立于使用它的客户而变化。这就是策略模式。

　　　当一个应用程序需要实现一种特定的服务或者功能，而且该程序有多种实现方式时使用。

　　　

/**
 * @author Ldl 
 * @since 1.0.0
 */
public class DirFilter implements FilenameFilter {

    private Pattern pattern;

    /**
     * 构造函数
     */
    public DirFilter(String regex) {
        pattern = Pattern.compile(regex);
    }

    /**
     * @Author Ldl
     * @Date 2017年3月28日
     * @since 1.0.0
     * @param dir
     * @param name
     * @return
     * @see java.io.FilenameFilter#accept(java.io.File, java.lang.String)
     */
    @Override
    public boolean accept(File dir, String name) {
        return pattern.matcher(name).matches();
    }

}


   public static void main(String[] args) {
        File path = new File(".");
        String[] list;
        if (args.length == 0) {
            list = path.list();
        } else {
            list = path.list(new DirFilter(args[0]));
        }
        Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);
        for (String dirItem : list) {
            System.out.println(dirItem);
        }

    }

　　DirFilter这个类存在的唯一原因就是调用accept()方法.创建这个类的目的在于把accept()方法提供给list()使用，使list()可以回调accept(),进而以决定 哪些文件包含在列表中。

　　因此这种结构也常常被称为回调。因为list()实现了基本功能，而且按照FileNameFilter的形式提供了这个策略,以便完善list()在提供服务时所需的算法。因为ist()接受FilenameFilter对象作为参数，

　　这意味着我们可以传递实现了FilenameFilter接口的任何类的对象，用以选择(甚至在运行时)list()方法的行为方式，策略的目的就是提供了代码行为的灵活性.