正文 

当前位置： 首页 > java > java教程

设计模式2面向对象设计原则

author author     2022-08-15     396

关键词： 


面向对象设计原则 
原则的目的
面向对象设计原创表 

单一职责原则案例
开闭原则 案例
依赖倒转原则 案例

面向对象设计原则 


对于面向对象软件系统的设计而言，在支持可维护性的同时，提高系统的可复用性是一个至关重要的问题，如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要解决的核心问题之一。在面向对象设计中，可维护性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想，可以从不同的角度提升一个软件结构的设计水平。 


面向对象设计原则为支持可维护性复用而诞生，这些原则蕴含在很多设计模式中，它们是从许多设计方案中总结出的指导性原则。面向对象设计原则也是我们用于评价一个设计模式的使用效果的重要指标之一。 


原则的目的： 高内聚，低耦合 


面向对象设计原创表 

技术分享



1,单一职责原则:

如果将每个类的方法分离出来,就能够保证每个类的指针单一.

提高了安全性.

提高了可维护性

提高了可读性.



单一原则,示范1,

[email protected]:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class clothes
{
public:
	void working()
	{
		cout << "穿正式的衣服" <<endl;
	}
	void shoping()
	{
		cout << "穿休闲的衣服" <<endl;
	}
};

int main()
{
	clothes c ;
	c.working();
	c.shoping();
	return 0;
}
[email protected]:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿休闲的衣服
[email protected]:~/design$


但是这个项目,老程序员走了,新的程序员接手,要求上班穿休闲的衣服

于是代码就变成了这样的:

[email protected]:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿正式的衣服
[email protected]:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class clothes
{
public:
	void working()
	{
		cout << "穿正式的衣服" <<endl;
	}
	void shoping()
	{
		cout << "穿正式的衣服" <<endl;
	}
};

int main()
{
	clothes c ;
	c.working();
	c.shoping();
	return 0;
}
[email protected]:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿正式的衣服
[email protected]:~/design$


后来又有新的程序员看着这两行的功能是一样 的,于是又改成这样的

[email protected]:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class clothes
{
public:
	void working()
	{
		cout << "穿正式的衣服" <<endl;
	}
	void shoping()
	{
		cout << "穿正式的衣服" <<endl;
	}
};

int main()
{
	clothes c ;
	c.working();
	c.working();
	return 0;
}
[email protected]:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿正式的衣服
[email protected]:~/design$


再来新手接这样的项目就彻底晕了.....

写成单一原则,这样就不用搞来搞去了,不要修改已经写好的代码.

[email protected]:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class ClothesWoring
{
public:
	void style()
	{
		cout << "穿正装" << endl;
	}
};
class ClothesShoping
{
public:
	void style()
	{
		cout << "穿休闲装" << endl;
	}
};
int main()
{
	ClothesShoping cs;
	ClothesWoring cw;
	cs.style();
	cw.style();

	return 0;
}
[email protected]:~/design$ g++ main.cpp && ./a.out 
穿休闲装
穿正装
[email protected]:~/design$


单一职责原则:

如果将每个类的方法分离出来,就能够保证每个类的指针单一.

提高了安全性.

提高了可维护性

提高了可读性.



2,开闭原则案例:

类的改动是添加代码,而不是修改源代码

原始的代码:
[email protected]:~$ cat main.cpp 
//设计模式 开闭原则
//定义:类的改动是增加代码进行的,而不是修改源代码


#include<iostream>
using namespace std;
class Banker
{
public:
	void save()
	{
		cout << "存款" << endl;
	}
	void pay()
	{
		cout <<"付款" << endl;
	}
	void transfer()
	{
		cout << "转账 " <<endl;
	}
};

int main()
{
	Banker B;
	B.save();
	B.pay();
	B.transfer();
	return 0;
}
[email protected]:~$ g++ main.cpp && ./a.out 
存款
付款
转账 
[email protected]:~$

代码优化,

[email protected]:~$ cat main.cpp 
//设计模式 开闭原则
//定义:类的改动是增加代码进行的,而不是修改源代码


#include<iostream>
using namespace std;
//////////////////////////////////////////////////////////////////
class AbstractBanker //抽象类
{
public:
	//AbstractBanker() = 0;
	virtual ~AbstractBanker(){};
	virtual void work() = 0;//接口
};
// // // // // // // // // // // // // // // // // // // // // //

class SaveBanker:public AbstractBanker //存款,继承抽象类
{
public:
	virtual void work()
	{
		cout << "存款方法" << endl;
	}
};

class PayBanker:public AbstractBanker //支付,继承抽象类
{
public:
	virtual void work()
	{
		cout << "支付方法" << endl;
	}
};

class TransferBanker:public AbstractBanker //转账,继承抽象类
{
public:
	virtual void work()
	{
		cout << "转账方法" << endl;
	}
};
/////////////////////////////////////////////////////////

int main()
{
	SaveBanker* sb = new SaveBanker;
	sb->work();
	delete sb;

	PayBanker  *pb = new PayBanker;
	pb->work();
	delete sb;

	TransferBanker *tb = new TransferBanker;
	tb->work();
	delete tb;

	return 0;
}
[email protected]:~$ g++ main.cpp -Wall && ./a.out 
存款方法
支付方法
转账方法
[email protected]:~$


新增 基金办理 需求,不再需要修改源代码

[email protected]:~$ cat main.cpp 
//设计模式 开闭原则
//定义:类的改动是增加代码进行的,而不是修改源代码


#include<iostream>
using namespace std;
//////////////////////////////////////////////////////////////////
class AbstractBanker //抽象类
{
public:
	//AbstractBanker() = 0;
	virtual ~AbstractBanker(){};
	virtual void work() = 0;//接口
};
// // // // // // // // // // // // // // // // // // // // // //

class SaveBanker:public AbstractBanker //存款,继承抽象类
{
public:
	virtual void work()
	{
		cout << "存款方法" << endl;
	}
};

class PayBanker:public AbstractBanker //支付,继承抽象类
{
public:
	virtual void work()
	{
		cout << "支付方法" << endl;
	}
};

class TransferBanker:public AbstractBanker //转账,继承抽象类
{
public:
	virtual void work()
	{
		cout << "转账方法" << endl;
	}
};

class FundBanker:public AbstractBanker //新增基金,继承抽象类,不需要修改其他类的源代码
{
public:
	virtual void work()
	{
		cout << "基金办理" << endl;
	}
};
/////////////////////////////////////////////////////////

int main()
{
	SaveBanker* sb = new SaveBanker;
	sb->work();
	delete sb;

	PayBanker  *pb = new PayBanker;
	pb->work();
	delete sb;

	TransferBanker *tb = new TransferBanker;
	tb->work();
	delete tb;
	FundBanker *fb = new FundBanker;
	fb->work();
	delete fb;

	return 0;
}
[email protected]:~$ g++ main.cpp -Wall && ./a.out 
存款方法
支付方法
转账方法
基金办理
[email protected]:~$


总结:

开闭原则: 安全稳定,可维护.



3,依赖倒转原则案例:

张三上班开奔驰

[email protected]:~$ cat main.cpp 
//设计模式:依赖倒转

#include<iostream>
using namespace std;

class Benz
{
public:
	void run()
	{
		cout << "奔驰启动了" << endl;
	}
};

class Zhangsan
{
public:
	void driveBenz(Benz *car)
	{
		cout << "张三 开车上班"<< endl;
		car->run();
	}
};

int main()
{
	Benz *benz = new Benz;
	Zhangsan *z3 = new Zhangsan;
	z3->driveBenz(benz);
	
	return 0;
}
[email protected]:~$ g++ main.cpp -Wall && ./a.out 
张三 开车上班
奔驰启动了
[email protected]:~$


张三还可能开宝马上班

[email protected]:~$ cat main.cpp 
//设计模式:依赖倒转

#include<iostream>
using namespace std;

class Benz
{
public:
	void run()
	{
		cout << "奔驰启动了" << endl;
	}
};

class BMW
{
public:
	void run()
	{
		cout << "宝马启动了" << endl;
	}
};

class Zhangsan
{
public:
	void driveBenz(Benz *car)
	{
		cout << "张三 开车上班"<< endl;
		car->run();
	}
	void driveBMW(BMW *car)
	{
		cout << "张三 开车上班"<< endl;
		car->run();
	}
};

int main()
{
	Benz *benz = new Benz;
	Zhangsan *z3 = new Zhangsan;
	z3->driveBenz(benz);


	BMW *bmw = new BMW;
	z3->driveBMW(bmw);
	
	return 0;
}
[email protected]:~$ g++ main.cpp -Wall && ./a.out 
张三 开车上班
奔驰启动了
张三 开车上班
宝马启动了
[email protected]:~$

-------------------------------

业务逐渐复杂,那大众呢?越来越多的的呢?

越来越乱............

------------------------------------------


将业务层和实现层 通过抽象层 隔离,解耦合 

[email protected]:~$ cat main.cpp 
//设计模式:依赖倒转
//将业务层和实现层 通过抽象层 隔离,解耦合 

#include<iostream>
using namespace std;
//////////抽象层 车  人 ////////////////////////////
class Car
{
public:
	virtual void run() = 0;
	virtual ~Car(){}
};

class Driver
{
public:
	virtual void drive(Car *car) = 0;
	virtual ~Driver(){}
};

////////    实现层        /////////////////////////
class ZhangSan:public Driver
{
public:
	virtual void drive(Car *car)
	{
		cout << "张三开车上班了" << endl;
		car->run();
	}
};
class LiSi:public Driver
{
public:
	virtual void drive(Car *car)
	{
		cout << "李四 开车上班了" << endl;
		car->run();
	}
};


class Benz:public Car
{
public:
	virtual void run()
	{
		cout << "Benz 启动了" << endl;
	};
};

class BMW:public Car
{
public:
	virtual void run()
	{
		cout << "BMW 启动了" << endl;
	};
};
///////////// 主函数 ////////////////////////////////////
int main()
{
	//让张三开奔驰
	Car * benz = new Benz;
	Driver *zhangsan = new ZhangSan;
	zhangsan->drive(benz);

	//让李四上班 开宝马
	Car *bmw = new BMW;
	Driver *lisi = new LiSi;
	lisi->drive(bmw);  


	return 0;
}
[email protected]:~$ g++ main.cpp -Wall && ./a.out 
张三开车上班了
Benz 启动了
李四 开车上班了
BMW 启动了
[email protected]:~$




依赖倒转原则,电脑组装案例:

抽象层:CPU,显卡,内存

框架层:组合CPU,显卡,内存

[email protected]:~$ cat main.cpp 
//设计模式:依赖倒转,电脑组装案例
#include<iostream>
using namespace std;

//抽象类
class CPU
{
public:
	virtual void caculate() = 0;
	virtual ~CPU(){}
};

class Card
{
public:
        virtual void display() = 0;
	virtual ~Card(){}
};

class Memmory
{
public:
	virtual void storage() = 0;
	virtual ~Memmory(){}
};

//架构类
class Computer
{
public:
	Computer(CPU* cpu,Card* card,Memmory* mem)
	{
		this->cpu = cpu;
		this->card = card;
		this->mem = mem;
	}
	virtual ~Computer() {};
	void work()
	{
		cpu->caculate();
		card->display();
		mem->storage();
	}
private:
	CPU *cpu;
	Card *card;
	Memmory* mem;
};
//////实现层//////////////////////////////////
class IntelCPU:public CPU
{
public:
	virtual void caculate()
	{
		cout << "intel CPU working" << endl;
	}
};

class NvidiaCard:public Card
{
public:
	virtual void display()
	{
		cout << "nvidia card  working" << endl;
	}
};
class KingSton:public Memmory
{
public:
	virtual void storage()
	{
		cout << "KingSton mem  working" << endl;
	}
};
/////////  主函数 ///////////////////
int main()
{

	CPU* cpu 	= new IntelCPU;
	Card* card 	= new NvidiaCard;
	Memmory* mem	= new KingSton;

	Computer* computer = new Computer(cpu,card,mem);
	computer->work();
	return 0;
}





[email protected]:~$ g++ main.cpp -Wall && ./a.out 
intel CPU working
nvidia card  working
KingSton mem  working
[email protected]:~$


里氏代换原则:略

接口隔离原则:

合成复用原则:继承,组合,依赖

能用组合不用继承

迪米特法则:





本文出自 “魂斗罗” 博客，请务必保留此出处http://990487026.blog.51cto.com/10133282/1877855

2面向对象设计原则

(1)面向对象设计原则单一职责原则单一职责原则是最简单的面向对象设计原则，用于控制类的粒度大小定义：一个对象应该只包含单一的职责，并且该职责被完整的封装在一个类中。就一个类而言，应该仅有一个... 查看详情

面向对象的七大设计原则

面向对象七大设计原则　　1、开闭原则(OCP:Open-ClosedPrinciple)　　2、里氏替换原则(LSP:LiskovSubstitutionPrinciple)　　3、单一职责原则(SRP:Singleresponsibilityprinciple)　　4、接口隔离原则(ISP:InterfaceSegregationPrinciple)　　5、依赖倒置原则(DIP:De... 查看详情

设计模式

1.设计模式原则开闭原则：　　即对扩展开放，对修改关闭里氏代换原则（面向对象）：　　继承特性迪米特原则（面向对象）：　　封装特性合成复用原则（面向对象）：依赖倒转原则（面向接口）：接口隔离原则（面向接口... 查看详情

面向对象设计七大原则

这目录1.单一职责原则（SingleResponsibilityPrinciple）2.里氏替换原则（LiskovSubstitutionPrinciple）3.依赖倒置原则（DependenceInversionPrinciple）4.接口隔离原则（InterfaceSegregationPrinc 查看详情

面向对象七大设计原则

面向对象七大设计原则1、开闭原则2、里氏替换原则3、单一职责原则4、接口隔离原则5、依赖倒置原则6、迪米特原则7、组合/聚合复用原则原则一：（SRP：Singleresponsibilityprinciple）单一职责原则又称单一功能原则 核心：解耦... 查看详情

面向对象设计原则

1.依赖倒置原则(DIP):　　1.1高层模块(稳定)不应该依赖于底层模块(变化),两者都应该依赖于抽象模块(稳定);　　1.2抽象(稳定)不应该依赖于实现细节(变化),实现细节应该依赖于抽象(稳定);2.开发封闭原则(OCP):　　2.1对扩展开放,对更... 查看详情

java设计模式：软件设计原则面向对象理论23种设计模式(代码片段)

文章目录软件设计原则1.单一职责原则（SingleResponsibilityPrinciple）2.开闭原则（OpenClosedPrinciple）3.里氏代换原则（LiskovSubstitutionPrinciple）4.接口隔离原则（InterfaceSegregationPrinciple）3.依赖倒转原则（... 查看详情

面向对象设计原则(代码片段)

为什么要面向对象设计？对于软件开发人员来说，变化是复用的天敌，而面向对象设计的最大优势在于抵御变化。提到这，我们不得不重新认识下面向对象。1、理解隔离变化从宏观层面来看，面向对象的构建方式更能适应软件... 查看详情

面向对象设计原则(代码片段)

为什么要面向对象设计？对于软件开发人员来说，变化是复用的天敌，而面向对象设计的最大优势在于抵御变化。提到这，我们不得不重新认识下面向对象。1、理解隔离变化从宏观层面来看，面向对象的构建方式更能适应软件... 查看详情

c++设计模式学习笔记：面向对象设计原则

目录简介面向对象设计原则（1）依赖倒置原则(DIP)（2）开放封闭原则(OCP)（3）单一职责原则(SRP)（4）Liskov替换原则(LSP)（5）接口隔离原则(ISP)（6）优先使用对象组合，而不是类继承（7）封装变化点（8）针对接口编程，而不是针... 查看详情

c++设计模式学习笔记：面向对象设计原则

目录简介面向对象设计原则（1）依赖倒置原则(DIP)（2）开放封闭原则(OCP)（3）单一职责原则(SRP)（4）Liskov替换原则(LSP)（5）接口隔离原则(ISP)（6）优先使用对象组合，而不是类继承（7）封装变化点（8）针对接口编程，而不是针... 查看详情

设计模式学习笔记面向对象设计原则设计模式编程范式重构的关系

...则-DIP依赖倒置原则DRY原则、KISS原则、YAGNI原则、LOD法则3.设计模式设计模式，是针对软件开发遇到的设计问题，从而总结出来的一套解决方案或者设计思路。主要用于解决代码的可扩展性问题。经典的设计模式有23种。具... 查看详情

面向对象设计原则

...维护性复用而诞生。指导性原则，非强制性原则。每一个设计模式都符合一个或多个面向对象设计原则， 查看详情

设计模式(一）面向对象设计原则

1.单一职责原则一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。2.开闭原则一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况... 查看详情

java设计模式：软件设计原则面向对象理论23种设计模式

文章目录软件设计原则1.单一职责原则（SingleResponsibilityPrinciple）2.开闭原则（OpenClosedPrinciple）3.里氏代换原则（LiskovSubstitutionPrinciple）4.接口隔离原则（InterfaceSegregationPrinciple 查看详情

面向对象设计原则

...原则则为支持可维护性复用而诞生，这些原则蕴含在很多设计模式之中，它们是从许多设计方案中总结出的指导性原则，但并不是强制性的。7个常用的面向对象设计原则 设计原则名称定义使用频率(1-5越大使用余额频繁)单一... 查看详情

面向对象设计原则

1、单一职责原则定义：一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。单一职责原则是实现高内聚、低耦合的指导方针，是最简单却最难运用的原则，需要设计人员发现类的不同职责并将其分离2、开闭... 查看详情

面向对象设计原则

OOP基本上有6大原则，而实际上都是互补的，也就是说一些原则需要利用另一些原则来实现自己。6大原则如下：1)Open-ClosePrinciple（OCP），开-闭原则，讲的是设计要对扩展有好的支持，而对修改要严格限制。这是最重要也是最为抽... 查看详情