七大软件设计原则

七大软件设计原则

开闭原则；
依赖倒置原则；
单一职责原则；
接口隔离原则；
迪米特法则；
里式替换原则；
合成复用原则；

一、Open-Closed Principle 开闭原则
定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。用抽象构建框架，用实现扩展细节。
优点：提高软件系统的可复用性及可维护性。
样例代码：

package com.lt.designpattern.openclose;

public interface ICourse
{
    Integer getId();
    String getName();
    Double getPrice();
}

public class JavaCourse implements ICourse
{
    private Integer id;
    private String name;
    private Double price;

    public JavaCourse(Integer id, String name, Double price)
    {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return this.id;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }
}

public class JavaDiscountCourse extends JavaCourse
{
    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getDiscountPrice()
    {
        return super.getPrice() * 0.6;
    }
}

public class CourseTest
{
    public static void main(String[] args)
    {
        ICourse course = new JavaDiscountCourse(1, "java架构", 9800D);
        System.out.println("课程号:" + course.getId() + "\n"
                + "课程名：" + course.getName() + "\n"
                + "价格：" + course.getPrice() + "\n"
                + "打折后价格：" + ((JavaDiscountCourse) course).getDiscountPrice());
    }
}

类图：

二、Dependence Inversion Principle 依赖倒置原则
定义： 高层模块不应该依赖低层模块，二者都应该依赖抽象。
抽象不应该依赖细节，细节应该依赖抽象。
针对接口编程，不要针对实现编程。
优点： 可以减少类之间的耦合性，提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。
样例代码：

public class JavaCourse implements ICourse {
    @Override
    public void study()
    {
        System.out.println("Tom 正在学习Java课程");
    }
}

public class PythonCourse implements ICourse  {
    @Override
    public void study() {
        System.out.println("Tom 正在学习Python课程");
    }
}

public class Tom
{
    //v1
    /*public void studyJavaCourse()
    {
        System.out.println("Tom 正在学习Java课程");
    }

    public void studyPythonCourse()
    {
        System.out.println("Tom 正在学习Python课程");
    }*/

    //V2
    /*public void study(ICourse course)
    {
        course.study();
    }*/

    private ICourse course;

    //v3
    /*public Tom(ICourse course) {
        this.course = course;
    }*/

    //v4
    public void setCourse(ICourse course) {
        this.course = course;
    }

    public void study()
    {
        course.study();
    }
}

public class Test
{
    public static void main(String[] args) {
        //V1
        /*Tom tom = new Tom();
        tom.studyJavaCourse();
        tom.studyPythonCourse();*/

        //V2
        /*Tom tom = new Tom();
        tom.study(new JavaCourse());
        tom.study(new PythonCourse());*/

        //v3
        /*Tom tom = new Tom(new JavaCourse());
        tom.study();*/

        //v4
        Tom tom = new Tom();
        tom.setCourse(new JavaCourse());
        tom.study();
    }
}

三、Simple Responsibility Principle 单一职责原则
定义： 不要存在多于一个导致类变更的原因。
一个类、接口、方法只负责一项职责。
优点：
降低类的复杂度
提高类的可读性
提供系统的可维护性
降低变更引起的风险
四、Interface Segregation Principle接口隔离原则
定义： 用多个专门的接口，而不是使用单一的总接口，客户端不应该依赖他不需要的接口。
注意：一个类的依赖应该建立在最小的接口上
尽量细化接口，接口中的方法尽量少
注意适度原则，一定要适度

优点： 符合我们常说的高内聚、低耦合的设计思想
从而使得类具有很好的可读性，可扩展性和可维护性。

样例代码：

public interface IAnimal {
}

public interface IEatAnimal extends IAnimal
{
    void eat();
}

public interface IFlyAnimal extends IAnimal
{
    void fly();
}

public class Dog implements IEatAnimal, ISwimAnimal {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }

    @Override
    public void swim() {
        System.out.println("狗会游泳");
    }
}

public class Test
{
    public static void main(String[] args) {
        IAnimal dog = new Dog();
        ((Dog) dog).eat();
        ((Dog) dog).swim();

        IAnimal bird = new Bird();
        ((Bird) bird).eat();
        ((Bird) bird).fly();
    }
}

五、Law of Demeter 迪米特法则
定义： 一个对象应该对其他对象保持最少的了解。又叫最少知道原则。
尽量降低类与类之间的耦合
优点： 降低类之间的耦合

六、Liskov Substitution Principle 里式替换原则
定义： 里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。程序逻辑不变。
优点： 约束继承泛滥，开闭原则的一种体现；加强程序的健壮性，同时变更时也可以做到非常好的兼容性。提高程序的维护性、扩展性。降低需求变更时引入的风险。

七、Composite Reuse Principle 合成复用原则
定义： 尽量使用对象组合、聚合而不是继承关系达到软件复用的目的。
聚合 has-a和组合contains-a，继承 is-a
优点： 可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较小。
样例代码：

public interface DBConnection
{
    String getConnection();
}

public class MySqlConnection implements DBConnection {
    @Override
    public String getConnection() {
        return "返回mysql数据库连接";
    }
}

public class OracleConnection implements DBConnection {
    @Override
    public String getConnection() {
        return "返回Oracle数据库连接";
    }
}

聚合DBConnection

public class ProductDao
{
    private DBConnection connection;

    public void setConnection(DBConnection connection) {
        this.connection = connection;
    }

    public void add()
    {
        String conn = connection.getConnection();
        System.out.println(conn);
    }
}

public class CopTest
{
    public static void main(String[] args) {
        ProductDao dao = new ProductDao();
        dao.setConnection(new MySqlConnection());
        dao.add();

        dao.setConnection(new OracleConnection());
        dao.add();
    }
}

类图

后话：设计原则只是一种标准，并不一定要严格遵守，视情况而定。