软件设计原则
文章目录
前言
在软件设计和实际的开发过程当中,软件设计应该秉承一些基本的原则。除了需要考虑软件开发所需的时间、成本、质量之外,还需要考虑到软件系统的稳定性、可维护性、可扩展性等。本文将对软件的7大设计原则进行一个讲解和配套以实际业务场景,便于读者更好的理解软件设计的基本原则。
另外,在软件设计中,软件设计原则不是一定要全部遵守,而是需要根据实际的业务场景需要来做一个取舍,达到一个平衡。也许这就是软件设计的艺术吧。
开闭原则
定义:一个软件实体如类、模块、函数应该对扩展开放,对修改关闭
特点:用抽象构建框架,用实现扩展细节
优点:提高软件系统的可复用性和可维护性
开闭原则是软件系统设计最基本的原则。实现开闭原则的思想就是面向抽象编程。因为一般来说,抽象是稳定的。实现的细节是不可知的。
业务场景
某培训机构分别开设java、python、php课程,每个课程都包含课程id、课程名、课程价格信息。在使用uml建模的时候,他们的类结构关系如下:
从模型中可以看出,ICourse为顶层父类,JavaCourse,PythonCourse,PhpCourse三个类为实现类。他们分别实现了父类的获取课程id、课程信息、课程价格的方法。这是最初的软件版本。随着时间的推移,培训机构为了扩展业务和吸引更多的学生来办理培训课程,需要实现能够对已有的课程进行打折活动,这个时候我们就需要对软件进行一个版本的升级。
此时我们有两种方法来实现:
第一种方法:比如是对Java课程打折。直接修改JavaCourse的源代码,在里面新增一个方法getDiscountPrice()或者使用已有的getPrice()方法进行修改获取折扣价。phthon和php课程同理。
第二种方法:采用面向抽象的方法来编程,不直接修改类代码,而是通过类继承来实现。
使用第一种方法的好处是简单、快速。但是当一个系统非常复杂和庞大的时候,越是对底层的代码进行修改就越有可能带来潜在的危机。你不能确定对类中方法的修改会不会影响到其他的方法调用,是否会带来难以想象的灾难。
使用第二种方法的坏处是可能需要多花费一点时间和精力。但是优点也是显而易见的。即不会影响原有的逻辑。在新的软件开发版本中,即扩展了功能,又不影响之前的业务逻辑。提高了系统的可维护性和可获展性。
开闭原则,就是在开发过程当中,尽量抽象出框架去进行扩展,杜绝对已有模块的修改。
依赖倒置原则
定义:高层调用不应该依赖底层模块,二者都应该依赖其抽象
特点:高层不依赖细节,细节依赖抽象
优点:模块之间彼此独立,互不影响,实现模块之间的松耦合
业务场景
还是上面的培训机构,现在小明报了三门课程,实现的类图如下
实现伪代码如下:
XiaoMing{
public void studyJavaCourse(JavaCourse java);
public void pythonJavaCourse(pythonCourse java);
public void phpJavaCourse(phpCourse java);
}
// 假设提供了带参数构造函数,参数分别为课程id,课程名称,课程单价
main{
XiaoMing xiaoMing = new XiaoMing();
xiaoMing.studyJavaCourse(new JavaCourse(1,"java",100.0));
xiaoMing.studyPhpCourse(new PhpCourse(2,"php",200.0));
xiaoMing.studyPythonCourse(new PythonCourse(3,"python",300.0));
}
这是没有用到依赖倒置原则时候的写法。在实际开发中这种写法极大的降低了代码之间的耦合度和灵活性。下面看看使用到了依赖倒置原则的写法。
这个时候,当我们需要取得学习课程信息的伪代码如下:
XiaoMing{
public void studyCouser(ICouser couser);
}
// 假设提供了带参数构造函数,参数分别为课程id,课程名称,课程单价
main{
XiaoMing xiaoMing = new XiaoMing();
xiaoMing.study(new JavaCourse(1,"java",100.0));
xiaoMing.study(new PhpCourse(2,"php",200.0));
xiaoMing.study(new PythonCourse(3,"python",300.0));
}
不知道大家看明白了没有(注意看XiaoMing对象),同样的实现功能,高层直接调用底层代码,增加了代码的复杂度。而调用底层的抽象,只提供一个对外接口就能实现功能。
单一职责原则
定义:不要存在导致类变更的多个原因。
特点:接口、类、方法负责的职责是单一的
优点:提高代码的可读性、可维护性、降低更改代码的风险
业务场景
依旧是培训机构的课程,现在要在课程的基础上新增购买课程和课程退款。接口的非单一职责伪代码如下:
public interface ICourse{
getPrice();
getCourseName();
buyCouse();
refundCourse();
}
该接口抽象出了“获取课程信息”,“课程惯例”两个职责,那么获取课程信息相关子类在实现父类的时候,也需要实现课程管理的职责相关方法,即使这完全没有必要。
我们再来看下方法的非单一职责例子,伪代码如下:
public void getIdOrName(String properties){
if(properties.equals("id")){
System.out.println("id");
}else{
System.out.println("name");
}
}
在上面的代码中,getIdOrName即能输出课程id,也能输出课程名称。当然这里代码足够简单,看不出什么。但是如果在复杂点,由于调用逻辑的不清晰,可能会导致后续开发人员的困惑。影响代码的可读性。同时,在对这一块代码进行修改的时候,出现错误的情况下可能会导致另一职能的错误。为了写出更加清晰的代码,应该写成如下方式:
public void getId(){……};
public void getName(){……};
这样,即使获取课程id的方法出错了,也不会影响到获取课程名称的相关功能。
接口隔离原则
定义:用单个专门的接口,而不是一个总的接口
特点:
1)一个类对另一个类依赖的接口尽可能简单
2)不断细化接口,但也要适度
优点:提高代码的灵活性和可读性,符合高内聚低耦合思想。
业务场景
在动物身上的行为有走、飞、游泳。设计一个顶层父类的接口,伪代码如下:
public interface Animals{
walk();
fly();
swimming();
}
现在有一只鸟和一只狗,实现了动物类
// 狗
Dog implments Animals{
walk(){
}
fly(){
}
swimming(){
}
}
// 鸟
Bird implments Animals{
walk(){
}
fly(){
}
swimming(){
}
}
可以看出,不管是狗还是鸟,都实现了动物走、飞、游泳的行为。可是狗不会飞,鸟类也不一定会游泳。有些鸟也不一定会飞。那么针对更加细化的对象来说,完全没有实现父类所有接口的必要。这个时候,我们就需要对接口进行一个细化,也就是接口隔离,增加接口的细粒度。伪代码如下:
interface Animals{
}
interface Walk implments Animals{
walk();
}
interface Fly implments Animals{
fly();
}
interface Swimging implments Animals{
swimging();
}
// 狗
Dog implments Walk,Swimging{
walk();
swimging();
}
// 鸟
Bird implments Fly,Walk{
fly();
walk();
}
这样,通过上面细化的接口,就能根据实际的需要去实现专门的接口。需要注意的是,适当的接口细化能提高代码的灵活性,但也不是越多越好,细化得越多,相应的系统复杂度也会增加。
引申:单一职责和接口隔离职责差异
单一职责强调得是类、接口、方法实现细节的功能唯一性,接口隔离是对接口的限制,是在抽象层面对接口进行的高内聚低耦合实现。
迪米特法则(最少知道原则)
定义:对一个类的了解的越少越好
特点:只对朋友交流,不和陌生人打交道
优点:降低类之间的耦合度。
这里的朋友是指具有组合、依赖关系和类。对于其他没有关系的类不要引入类中。具体详细了解请看下面的业务场景。
业务场景
老板去查看团队的员工数量。伪代码如下:
Boss{
checkTeam(Team t){
List<People> p = new ArrayList<People>();
for(int i=0;i<10;i++){
p.add(new People());
}
t.countPeople(List<People> p); // 输出团队成员人数
}
}
Team{
countPeople(List<People> p){
System.out.println(p.length());
}
}
在本例中的类关系如图:
老板和员工是依赖关系(员工类是方法的参数),但是老板的检查员工方法中却出现和老板无关的People类,这里陌生人依赖(People类)也依赖我们的老板类。这就违背了我们的最少知道原则。
按照最少知道原则,他们之间的关系应该是People类是Team类的依赖,Boss类是Team类的依赖。
伪代码如下:
Boss{
checkTeam(Team t){
t.countPeople(); // 输出团队成员人数
}
}
Team{
countPeople(List<People> p){
List<People> p = new ArrayList<People>();
for(int i=0;i<10;i++){
p.add(new People());
}
System.out.println(p.length());
}
}
最少知道原则降低了类之间的耦合度。在实际开发中,应该遵循使用。
里氏替换原则
定义:父类出现的地方,子类也可以出现,并且子类替换父类后,不会产生任何问题。
特点:里氏替换原则包含了四层含义,如下
1) 子类必须完全实现父类的方法
2)子类可以拥有自己的个性
3)覆盖或实现父类方法时,输入参数可以被放大
4)覆盖或实现父类方法时,返回结果可以被缩小
组合/复用原则
定义:在一个新的对象里使用已有对象,通过委派该对象来实现对已有功能的服用。
特点:符合 Has—A 关系
优点:提高了代码的封装性,相比较于继承,隐蔽了代码的细节。
为什么需要使用组合/复合原则?在什么情况下使用?
实现代码功能的复用,有两种方法,一种是继承,一种是组合。使用继承的时候,需要遵循里氏替换原则,我们在修改父类基类的时候,相关的子类也需要做一个修改。这无疑提高的代码的维护性。使用组合的方法,通过委派成员变量复用对象功能,该对象功能的调整,并不会影响到委托类的代码。代码可维护性更高。我们通过下面人的属性来比较以下继承和组合的差异。
作为一个社会人,有多重属性,继承伪代码如下
Person{
public Person(){}
}
Teacher extends Person{
System.out.println("teacher");
}
Student extends People{
System.out.println("student");
}
通过以上方式,可以看到,我们新创建一个Person其子类对象的时候,这个子类只能是老师或者只能是学生。但是实际生活当中,一个人的属性是多样的,所以在创建对象的时候,要能够实现他可能是老师,也有可能是学生的要求。这个时候就得用组合方式了。伪代码如下:
Person{
private Role role;
setRole(){};
getRole(){};
}
interface Role{}
Teacher implements Role{
}
Student implements Role{
}
在上面方式中,动态应用的时候,通过Person的getPerson方法调用对象身份属性。在setPerson时用的是那个对象就是哪个身份属性。那么我们如何判断在什么情况下合理使用继承或者组合呢,其实很简单,我们如果不能判定一个子类在未来是否会变成别的子类的时候,就是用组合的方式。如果一个子类的对象信息是固定不变的,就是用继承。还有一种方式,就是使用抽象的思维,看是is-a关系,还是has-a关系。is-a使用继承方式。has-a使用组合方式
总结
纵观这些原则,针对的是面向对象编程的思想,关注点是编程语言的封装性、继承性、多态性。通过这三大特性,是软件框架变得更加清晰,可维护性更好,可扩展性更强。希望自身在实际应用中,能够合理使用这些原则。
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论