设计模式

新设计模式（4个）

1.对象池模式（资源频繁分配、释放所造成成本高昂的对象）

2.规约模式 父类依赖子类、实现了对象筛选性能

//使用
       ISpecification spec1 = new BizSpecification("a");
        ISpecification spec2 = new BizSpecification("b");
        //规格调用
        for (Object o : list) {
            if(spec1.and(spec2).isSatisfiedBy(o)){  //如果o满足spec1 && spec2
                System.out.println(o);
            }
        }  
//定义规格书
interface ISpecification {
        //候选者是否满足条件
        boolean isSatisfiedBy (Object candidate) ;
        //and操作
        ISpecification and (ISpecification spec);
        //or操作
        ISpecification or (ISpecification spec);
        //not操作
        ISpecification not ();
    }
//组合规格书
 static abstract class CompositeSpecification implements ISpecification {
        //是否满足条件由子类实现
        public abstract boolean isSatisfiedBy (Object candidate) ;
        //and操作
        public ISpecification and (ISpecification spec) {
            return new AndSpecification(this, spec);
        }
        //or操作
        public ISpecification or(ISpecification spec) {
            return new OrSpecification(this, spec);
        }
        //not操作
        public ISpecification not() {
            return new NotSpecification(this);
        }
    }

//与规格书
    static class AndSpecification extends CompositeSpecification {
        //传递两个规格书进行and操作
        private ISpecification left;
        private ISpecification right;

        public AndSpecification(ISpecification left, ISpecification right) {
            this.left = left;
            this.right = right;
        }
        
        //进行and运算
        public boolean isSatisfiedBy(Object candidate) {
            return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
        }
    }
static class OrSpecification extends CompositeSpecification {
        //传递两个规格书进行or操作
        private ISpecification left;
        private ISpecification right;

        public OrSpecification(ISpecification left, ISpecification right) {
            this.left= left;
            this.right = right;
        }

        //进行or运算
        public boolean isSatisfiedBy(Object candidate) {
            return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
        }
    }

    static class NotSpecification extends CompositeSpecification {
        //传递两个规格书进行非操作
        private ISpecification spec;

        public NotSpecification(ISpecification spec) {
            this.spec = spec;
        }

        //进行not运算
        public boolean isSatisfiedBy(Object candidate) {
            return !spec.isSatisfiedBy(candidate);
        }
    }

    //业务规格书
    static class BizSpecification extends CompositeSpecification {
        //基准对象，如姓名等，也能够是int等类型
        private String obj;
        public BizSpecification(String obj) {
            this.obj = obj;
        }
        //判断是否满足要求
        public boolean isSatisfiedBy(Object candidate){
            //依据基准对象判断是否合乎
            return true;
        }
    }

　　3.空对象模式  定义一个空对象，当存在就返回真实对象，不存在就返回空对象

       4.雇工模式   形象服务提供者（接口）、实际服务提供者（实现类）、雇工（调用接口服务）

 七大架构设计原则

1.开闭原则  对扩展开放，对修改关闭。用抽象构建框架，用扩展实现细节。

2.依赖倒转(倒置)原则  高层模块依赖低层模块，两者都依赖抽象  特别类似依赖注入 。

原理a.一个接口多个实现类实现不同活动;b.定义实体对象在构造器中传入接口；c.构造器中实现其活动。

3.单一职责原则   不同功能的分类做解耦，防止一个功能改动影响到其他功能

4.接口隔离原则  类依赖应该建立在最小接口原则上，建立单一接口，不要臃肿庞大           实现低耦合高内聚思想，可读性、可扩展性、可维护性

这个功能实现要求每个实现类里边没有多余的接口，实现类了都是自己需要使用的

5.迪米特法则  降低类与类耦合，尽量在自己方法内完成自己的事情。不和陌生人说话，强调和朋友交流

6.里式替换原则（加强程序健壮性，可扩展、可维护、降低需求引入风险）   父子类子类适用父类的逻辑

7.合成复用原则  尽量使用对象组合（has-a）/聚合（contains-a）而不是继承。继承也叫做白箱复用把实现让实现类去做，而组合/聚合叫黑箱复用，类以外的对象无法获取实现细节