java设计模式--六大设计原则

在武林之中，江湖之上，有一种说法，说是武学的最高境界，是无招胜有招。各门各派练一门功夫分为内功和外功。外功好比招式，就是所谓的23种设计模式。而内功呢，就是心法和内力，那就是这6种法则。光会外功那是花拳绣腿，内功修为才是境界。如此众多的设计模式，学完2遍，3遍可能也会忘的只记得单例和工厂模式。但是只要原则记住，在以后的设计中，有意无意就会用的设计模式的精髓。

六种设计原则

单一职责原则：

不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。
问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。
一句话总结：不能为图代码量少，把牛头马嘴一起往一个类塞  

里氏替换原则：

1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
2.子类中可以增加自己特有的方法。
3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。
一句话总结：尽量不要重写父类的已经实现了的方法，可以用接口等其他方法绕过

接口隔离原则：

客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
问题由来：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。
一句话总结：就好比鱼和人两个类，鱼是游泳和腮呼吸两个动作，人是走路和吃饭两个动作，这些动作不能写在一个接口里面，把这四个动作都包含。

要拆成专门对鱼和人的两个接口才行。

开闭原则

这个很简单，不多说了：尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

依赖倒置原则：

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。        

这个比较难以理解，我会结合下面的迪米特原则，写个代码例子，看看我们的糟糕的代码，是如何通过一步一步的演进，成为优秀代码的。

迪米特法则：

迪米特法则又叫最少知道原则，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量

的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。

例：

有Someone、Friend和Stranger三个类。

如果代码按照如下设计，则Someone通过Friend直接跟Stranger产生了联系，明显是违反迪米特法则的

Someone.java

public class Someone
{
    public void operation1( Friend friend )
    {
        Stranger stranger = friend.provide() ;
        stranger.operation3() ;
    }
}

Friend.java

public class Friend
{
    private Stranger stranger = new Stranger() ;
    public void operation2(){}
    public Stranger provide()
    {
        return stranger ;
    }
}

Stranger.java

public class Stranger
{
    public void operation3() {}
}

在这里，Someone类和Stranger类不是朋友类，但Someone类却通过Friend类知道了Stranger类的存在，这显然违反迪米特法则。现在，我们对Someone和Friend类进行重构，重构后代码如下：

Someone.java

public class Someone
{
    public void operation1( Friend friend )
    {
        friend.forward() ;
    }
}

Friend.java

package after;

public class Friend
{
    private Stranger stranger = new Stranger() ;
    public void operation2(){}
    public void forward()
    {
        stranger.operation3() ;
    }
}

Stranger.java

public class Stranger
{
    public void operation3() {}
}

现在Someone对Stranger的依赖完全通过Friend隔离，这样的结构已经符合狭义迪米特法则了。
但是仔细观察上述结构，会发现狭义迪米特法则一个明显的缺点：会在系统里造出大量的小方法，散落在系统的各个角落。这些方法仅仅是传递间接的调用，因此与系统的商务逻辑无关，当设计师试图从一张类图看出总体的框架时，这些小的方法会造成迷惑和困扰。遵循迪米特法则会使一个系统的局部设计简化，因为每一个局部都不会和远距离的对象有直接关联。但是，这也会造成系统的不同模块之间的通信效率降低，也会使系统的不同模块之间不容易协调。
结合依赖倒转原则，我们对代码进行如下重构来解决这个问题，首先添加一个抽象的Stranger类，使Someone依赖于抽象的“Stranger”角色，而不是具体实现，重构后代码如下：

AbstractStranger.java

public abstract class AbstractStranger
{
    abstract void operation3() ;
}

Stranget.java

public class Stranger extends AbstractStranger
{
    public void operation3() {}
}

Friend.java

public class Friend
{
    private Stranger stranger = new Stranger() ;
    public void operation2(){}
    public AbstractStranger provide()
    {
        return stranger ;
    }
}

Someone.java

public class Someone
{
    public void operation1( Friend friend )
    {
        AbstractStranger stranger = friend.provide() ;
        stranger.operation3() ;
    }
}

现在，AbstractStranger成为Someone的朋友类，而Friend类可以随时替换掉AbstractStranger的实现类，Someone不再需要了解Stranger的内部实现细节。下图是重构后的UML类图：