By

Contents
  1. 1. 六大原则
    1. 1.1. 解释

六大原则

  • 开闭原则：对扩展开放，对修改关闭。比如工厂方法模式，新增类型就新增工厂实现类，这样实现了对扩展开放。

  • 依赖倒转原则：（接口实现）针对接口编程（因为接口没有任何具体实现），依赖于抽象而不依赖于具体。这是开闭原则的基础，因为依赖的是接口，所以才能做到扩展不同的子类都适用，例如工厂方法模式里factory.product()，这里的factory是一个接口，无论

  • 里氏代换原则：（类的继承）子类可以扩展但不能重写父类的方法，不能影响原有功能的实现，否则就不能代换。反之，父类出现的任何地方，都可以用任意一个子类去替换。(实际开发中经常重写，容易出错）。

  • 接口隔离原则: 客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。这样调用者只能访问它自己的方法,屏蔽不需要的方法（比如实现权限管理）

  • 迪米特法则: 最少知道原则，设计模式的门面模式（Facade）和中介模式（Mediator），都是迪米特法则应用的例子。？

  • 合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。(has - a ,而不是 is -a，和里氏代换原则相反) ？

解释

  1. 依赖倒转原则：让行为去依赖抽象，让调用者动态的去实现具体的细节.这样才可以实现对扩展开放，如果依赖的是具体的话，则无法扩展。
    例如司机开车:如果依赖于具体的某种车型的车，则无法扩展，每次新增加一种车，都要修改Driver类，添加新车的开法。如果依赖Car抽象类的话，就可以动态扩展了，不管给任何Car的实现类，都可以run()

    public class Dirver{
        public void driveBMW(BMW bmw){
            bmw.run();
        }
        public void driveBenz(Benz benz){
            benz.run();
        }
        public void driveCar(Car car){
            car.run();
        }
    }

  2. 接口隔离原则

    使用场合,提供调用者需要的方法,屏蔽不需要的方法.满足接口隔离原则.比如说电子商务的系统,有订单这个类,有三个地方会使用到,
    一个是门户,只能有查询方法。
    一个是外部系统,有添加订单的方法,
    一个是管理后台,添加删除修改查询都要用到.
    //门户查询
    interface IOrderForPortal{
        String getOrder();
    }
    //外部系统 查看和新增
    interface IOrderForOtherSys{
        String insertOrder();
        String getOrder();
    }
    //管理员系统 增删改查
    interface IOrderForAdmin{ //extendsIOrderForPortal,IOrderForOtherSys
        String deleteOrder();
        String updateOrder();
        String insertOrder();
        String getOrder();
    }
    class Order implements IOrderForPortal,IOrderForOtherSys,IOrderForAdmin{
        private Order(){
            //--什么都不干,就是为了不让直接 new,防止客户端直接New,然后访问它不需要的方法.
        }
        //返回给Portal
        public static IOrderForPortal getOrderForPortal(){
            return (IOrderForPortal)new Order();
        }
        //返回给OtherSys
        public static IOrderForOtherSys getOrderForOtherSys(){
            return (IOrderForOtherSys)new Order();
        }
        //返回给Admin
        public static IOrderForAdmin getOrderForAdmin(){
            return (IOrderForAdmin)new Order();
        }
        //--下面是接口方法的实现.只是返回了一个String用于演示
        public String getOrder(){
            return "implemented getOrder";
        }
        public String insertOrder(){
            return "implementedinsertOrder";
        }
        public String updateOrder(){
            return "implementedupdateOrder";
        }
        public String deleteOrder(){
            return "implementeddeleteOrder";
        }
    }
    public class TestCreateLimit{
        public static void main(String[] args){
            IOrderForPortal orderForPortal =Order.getOrderForPortal();
            IOrderForOtherSys orderForOtherSys =Order.getOrderForOtherSys();
            IOrderForAdmin orderForAdmin = Order.getOrderForAdmin();
            System.out.println("Portal门户调用方法:"+orderForPortal.getOrder());
            System.out.println("OtherSys外部系统调用方法:"+orderForOtherSys.insertOrder());
            System.out.println("Admin管理后台调用方法:"+orderForAdmin.getOrder()+";"+orderForAdmin.insertOrder()+";"+orderForAdmin.updateOrder()+";"+orderForAdmin.deleteOrder());
        }
    }

  3. 里氏代换原则
    比如计算器父类，有加减乘除的功能。现在有Deli牌计算器，提供相加后翻倍的功能， (A+B)*2，这个时候实现这个功能不能去重写add()方法，而是扩展一个 addAndDouble()的方法，这样别人在调用的时候，习惯了add就是相加，如果要相加后加倍就调用addAndDouble()。
    好处是：任何一个会使用计算器的人，不管使用什么牌子的计算器，点 add（）键，相加的逻辑都不会变。

Contents
  1. 1. 六大原则
    1. 1.1. 解释