七大软件设计原则

七大软件设计原则

一、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();
}
}

类图

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

• 点赞
• 收藏
• 分享
• 文章举报