python开闭原则_设计模式七⼤原则——开闭原则
⼀、基本介绍
(1)开闭原则(Open Closed Principle)是编程中最基础、最重要的设计原则
(2)⼀个软件实体如类，模块和函数应该对扩展开放(对提供⽅)，对修改关闭(对使⽤⽅)。⽤抽象构建框架，⽤实现扩展细节。
(3)当软件需要变化时，尽量通过扩展软件实体的⾏为来实现变化，⽽不是通过修改已有的代码来实现变化。
(4)编程中遵循其它原则，以及使⽤设计模式的⽬的就是遵循开闭原则。
⼆、应⽤实例
设计⼀个画图形的功能，类图如下：
说明：GraphicEditor是⼀个⽤于画图形的类，其中三个⽅法分别代表绘制图形drawShape，绘制矩形drawRectangle，绘制圆形drawCircle，Rectangle和Circle都继承⾃Shape类，drawShape根据传⼊shape对象的m_type来判断具体是绘制什么图形
代码实现：
1 public classOpenClosePrinciple {
2 public static voidmain(String[] args) {
3 GraphicEditor graphicEditor =
newGraphicEditor();4 graphicEditor.drawShape(newRectangle());5 graphicEditor.drawShape(newCircle());6 }7 }8
9 //⽤于绘图的类
10 classGraphicEditor {11 //接收Shape对象，根据m_type来绘制不同的图形
12 public voiddrawShape(Shape shape) {13 if (shape.m_type == 1) {14 drawRectangle(shape);15 } else if (shape.m_type == 2) {16 drawCircle(shape);17 }18 }19
20 public voiddrawRectangle(Shape rectangle) {21 System.out.println("绘制矩形");22 }23
24 public voiddrawCircle(Shape circle) {25 System.out.println("绘制圆形");26 }27 }28
29 //基类Shape
30 classShape {31 intm_type;32 }33
34 class Rectangle extendsShape {35 publicRectangle() {36 super.m_type = 1;37 }38 }39
40 class Circle extendsShape {41 publicCircle() {42 super.m_type = 2;43 }44 }
运⾏结果：
分析：
(1)优点是⽐较好理解，简单易操作。
(2)缺点是违反了设计模式的开闭原则，即对扩展开放(提供⽅)，对修改关闭(使⽤⽅)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
(3)⽐如我们这时要新增加⼀个图形种类三⾓形，我们需要做如下修改，修改的地⽅较多
新需求：增加绘制三⾓形功能
说明：⾸先我们要新增⼀个Triangle类继承Shape，并且将其m_type置为3，在GraphicEditor中新增⼀个drawTriangle⽅法⽤于绘制三⾓形
代码实现：
1 public classOpenClosePrinciple {
2 public static voidmain(String[] args) {
3 GraphicEditor graphicEditor =
newGraphicEditor();4 graphicEditor.drawShape(newRectangle());5 graphicEditor.drawShape(newCircle());6
graphicEditor.drawShape(newTriangle());7 }8 }9
10 //⽤于绘图的类
11 classGraphicEditor {12 //接收Shape对象，根据m_type来绘制不同的图形
13 public voiddrawShape(Shape shape) {14 if (shape.m_type == 1) {15 drawRectangle(shape);16 } else if (shape.m_type == 2) {17 drawCircle(shape);18 } else if (shape.m_type == 3) {19 drawTriangle(shape);20 }21 }22
23 public voiddrawRectangle(Shape rectangle) {24 System.out.println("绘制矩形");25 }26
27 public voiddrawCircle(Shape circle) {28 System.out.println("绘制圆形");29 }30
31 public voiddrawTriangle(Shape triangle) {32 System.out.println("绘制三⾓形");33 }34 }35
36 //基类Shape
37 classShape {38 intm_type;39 }40
41 class Rectangle extendsShape {42 publicRectangle() {43 super.m_type = 1;44 }45 }46
47 class Circle extendsShape {48 publicCircle() {49 super.m_type = 2;50 }51 }52
53 class Triangle extendsShape {54 publicTriangle() {55 super.m_type = 3;56 }57 }
运⾏结果：
分析：虽然我们将功能实现了，但是每次增加新的图形都要这样操作未免太过⿇烦，于是我们需要使⽤开闭原则来对程序进⾏改进，改进思路是把Shape类做成抽象类，并提供⼀个抽象的draw⽅法，让⼦类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承Shape，并实现 draw ⽅法即可，使⽤⽅的代码就不需要修改，这样就满⾜了开闭原则
代码实现：
1 public classOpenClosePrinciple {
2 public static voidmain(String[] args) {
3 GraphicEditor graphicEditor =
newGraphicEditor();4 graphicEditor.drawShape(newRectangle());5 graphicEditor.drawShape(newCircle());6
graphicEditor.drawShape(newTriangle());7 }8 }9
10 //⽤于绘图的类
11 classGraphicEditor {12 public voiddrawShape(Shape shape) {13 shape.draw();14 }15 }16
17 //基类Shape
18 abstract classShape {19 intm_type;20
21 //抽象⽅法：绘制图形
22 public abstract voiddraw();23 }24
25 class Rectangle extendsShape {26 publicRectangle() {27 super.m_type = 1;28 }29
30 @Override31 public voiddraw() {32 System.out.println("绘制矩形");33 }34 }35
36 class Circle extendsShape {37 publicCircle() {38 super.m_type = 2;39 }40
41 @Override42 public voiddraw() {43 System.out.println("绘制圆形");44 }45 }46
47 class Triangle extendsShape {48 publicTriangle() {49 super.m_type = 3;50 }51
52 @Override53 public voiddraw() {54 System.out.println("绘制三⾓形");55 }56 }
运⾏结果：
分析：运⾏结果与上⾯的代码相同，但是如果我们这时候新增⼀个绘制梯形的需求，只需要扩展代码即可，不需要修改原有代码
代码实现：
1 public classOpenClosePrinciple {
2 public static voidmain(String[] args) {
3 GraphicEditor graphicEditor =
抽象类的使用newGraphicEditor();4 graphicEditor.drawShape(newRectangle());5 graphicEditor.drawShape(newCircle());6
graphicEditor.drawShape(newTriangle());7 graphicEditor.drawShape(newTrapezoid());8 }9 }10
11 //⽤于绘图的类
12 classGraphicEditor {13 public voiddrawShape(Shape shape) {14 shape.draw();15 }16 }17
18 //基类Shape
19 abstract classShape {20 intm_type;21
22 //抽象⽅法：绘制图形
23 public abstract voiddraw();24 }25
26 class Rectangle extendsShape {27 publicRectangle() {28 super.m_type = 1;29 }30
31 @Override32 public voiddraw() {33 System.out.println("绘制矩形");34 }35 }36
37 class Circle extendsShape {38 publicCircle() {39 super.m_type = 2;40 }41
42 @Override43 public voiddraw() {44 System.out.println("绘制圆形");45 }46 }47
48 class Triangle extendsShape {49 publicTriangle() {50 super.m_type = 3;51 }52
53 @Override54 public voiddraw() {55 System.out.println("绘制三⾓形");56 }57 }58
59 class Trapezoid extendsShape {60 publicTrapezoid() {61 super.m_type = 4;62 }63
64 @Override65 public voiddraw() {66 System.out.println("绘制梯形");67 }68 }
运⾏结果：
分析：这时候我们发现，仅仅增加了⼀个新的类Trapezoid继承Shape并且实现了draw⽅法就实现了功能，在扩展了代码功能的同时也没有对原有代码进⾏较⼤的改动，这就是开闭原则的魅⼒所在

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。