java设计模型原则（上）

java设计模型原则

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)。
设计模式常用的七大原则有:

1. 单一职责原则
2. 接口隔离原则
3. 依赖倒转(倒置)原则
4. 里氏替换原则
5. 开闭原则
6. 迪米特法则
7. 合成复用原则

单一职责原则

在java开发过程中，我们经常看到最顶层的类一般都是接口，接口按照职责进行分类，每个接口只负责一个职责，而具体的实现都在下层的实现类中。遵循的就是单一职责原则。
实例如下：

public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("汽车");
        vehicle.run("飞机");
    }
}

/**
 * 交通工具类
 */
class Vehicle{

    /**
     * run方法违反了单一职责原则
     * 解决方案：
     *  根据交通工具运行方法不同，分解成不同类即可，
     * @param vehicle
     */
    public  void run(String vehicle){
        System.out.println("vehicle "+"在公路上运行.........");
    }
}

解决方法：

public class SingleResponsibility2 {
    public static void main(String[] args) {
        RoadVehicle vehicle = new RoadVehicle();
        vehicle.run("摩托车");
        vehicle.run("汽车");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }
}
/**
 * 交通工具类
 * 这样方式修改，改动的比较大
 * 改进的方式，直接修改Vehicle类
 */

class RoadVehicle{

    /**
     * run方法违反了单一职责原则
     * 解决方案：
     *  根据交通工具运行方法不同，分解成不同类即可
     * @param vehicle
     */
    public  void run(String vehicle){
        System.out.println(vehicle +"在公路上运行.........");
    }
}

class AirVehicle{
    public  void run(String vehicle){
        System.out.println(vehicle +"在天空上运行.........");
    }
}

class WaterVehicle{
    public  void run(String vehicle){
        System.out.println(vehicle +"在水里上运行.........");
    }
}

单一职责原则注意事项和细节

1. 降低类的复杂度，一个类只负责一项职责。
2. 提高类的可读性，可维护性
3. 降低变更引起的风险
4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违
   反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

接口隔离原则（Interface Segregation Principle）

基本介绍

简单来说就是：客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
代码示例：
传统方式

package com.danir.segregation;

public class Segregation1 {
    public static void main(String[] args) {

    }
}

/**
 * 接口
 */
interface interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}

class B implements interface1{

    public void operation1() {
        System.out.println("B----operation1");
    }

    public void operation2() {
        System.out.println("B----operation2");
    }

    public void operation3() {
        System.out.println("B----operation3");
    }

    public void operation4() {
        System.out.println("B----operation4");
    }

    public void operation5() {
        System.out.println("B----operation5");
    }
}

class D implements interface1{

    public void operation1() {
        System.out.println("D----operation1");
    }

    public void operation2() {
        System.out.println("D----operation2");
    }

    public void operation3() {
        System.out.println("D----operation3");
    }

    public void operation4() {
        System.out.println("D----operation4");
    }

    public void operation5() {
        System.out.println("D----operation5");
    }
}

/**
 * A 类通过接口interface1依赖（使用）B类，但是只会用到1 2 3方法
 */
class A{
    public void depend1(interface1 interface1){
        interface1.operation1();
    }
    public void depend2(interface1 interface1){
        interface1.operation2();
    }
    public void depend3(interface1 interface1){
        interface1.operation3();
    }
}
/**
 * C 类通过接口interface1依赖（使用）B类，但是只会用到1 4 5方法
 */
class C{
    public void depend1(interface1 interface1){
        interface1.operation1();
    }
    public void depend4(interface1 interface1){
        interface1.operation4();
    }
    public void depend5(interface1 interface1){
        interface1.operation5();
    }
}

public class Segregation1 {
    public static void main(String[] args) {
    //实体测试
        A a = new A();
        a.depend1(new B()); //A类通过接口去依赖B类
        a.depend2(new B()); //A类通过接口去依赖B类
        a.depend2(new B()); //A类通过接口去依赖B类

        C c = new C();
        c.depend1(new D()); //C类通过接口去依赖D 类
        c.depend4(new D());
        c.depend5(new D());
    }
}

/**
 * 接口
 */
interface interface1{
    void operation1();
}
interface interface2{

    void operation2();
    void operation3();
}
interface interface3{
    void operation4();
    void operation5();
}
class B implements interface1,interface2{

    public void operation1() {
        System.out.println("B----operation1");
    }

    public void operation2() {
        System.out.println("B----operation2");
    }

    public void operation3() {
        System.out.println("B----operation3");
    }

}

class D implements interface1,interface3{

    public void operation1() {
        System.out.println("D----operation1");
    }
    public void operation4() {
        System.out.println("D----operation4");
    }

    public void operation5() {
        System.out.println("D----operation5");
    }
}

/**
 * A 类通过接口interface1 interface2依赖（使用）B类，但是只会用到1 2 3方法
 */
class A{
    public void depend1(interface1 interface1){
        interface1.operation1();
    }
    public void depend2(interface2 interface1){
        interface1.operation2();
    }
    public void depend3(interface2 interface1){
        interface1.operation3();
    }
}

/**
 * C 类通过接口interface1依赖（使用）B类，但是只会用到1 4 5方法
 */
class C{
    public void depend1(interface1 interface1){
        interface1.operation1();
    }
    public void depend4(interface3 interface1){
        interface1.operation4();
    }
    public void depend5(interface3 interface1){
        interface1.operation5();
    }
}