程序设计六大原则之开放封闭原则

最新推荐文章于 2021-04-01 10:56:08 发布
原创 最新推荐文章于 2021-04-01 10:56:08 发布 · 611 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#程序设计 #开闭原则 #抽象类 #接口 #属性

本文探讨了软件设计中的开闭原则，强调了实体应为扩展开放，为修改关闭的概念。通过抽象类和接口的使用，确保软件的可复用性和可维护性，避免直接修改现有代码以适应变化。

一.开饭封闭原则（Open-Closed Principle,OCP）

1.定义：

软件实体（包括类、模块、函数）应该为扩展而打开，为修改而关闭。

大概意思就是：一个软件实体应该通过扩展来实现变化，而不是通过修改原有的代码来实现变化

2.实现：

开闭原则实现关键是抽象

抽象基类：把系统的所有可能的行为抽象成一个抽象底层，这个抽象底层规定出所有的具体实现必须提供的方法的特征。作为系统设计的抽象层，要预见所有可能的扩展，从而使得在任何扩展情况下，系统的抽象底层不需修改

派生类：从抽象基类派生一个或多个新的具体实现，可以扩展基类的行为，系统设计对扩展开放

3.使用：

通过接口或者抽象类约束扩展，对于扩展进行边界限定

参数类型、引用对象尽量使用接口或者抽象方法，而不是实现类

抽象层应该保持稳定和可靠，一但确认即不允许修改

4.优点：

可复用、可维护

5.抽象方法示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study.Abstract
{
    /// <summary>
    /// 抽象类
    /// 形状
    /// </summary>
    public abstract class Shape
    {
        protected string Name;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="name">形状名称</param>
        public Shape(string name)
        {
            this.Name = name;
        }
        /// <summary>
        /// 面积
        /// </summary>
        /// <returns></returns>
        public abstract double Area();
        /// <summary>
        /// 显示
        /// </summary>
        public abstract void Display();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study.Abstract
{
    /// <summary>
    /// 圆形
    /// </summary>
    public class Circular:Shape
    {
        private double Radius;      

        public Circular(string name,double radius) : base(name)
        {
            this.Radius = radius;
        }

        public override double Area()
        {
            return Math.Round(Math.PI*Radius*Radius,2);
        }

        public override void Display()
        {
            Console.WriteLine($"{Name}的面积是{this.Area()}");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study.Abstract
{
    /// <summary>
    /// 矩形
    /// </summary>
    public class Rectangle : Shape
    {
        private double Width;//宽度
        private double Length;//长度

        public Rectangle(string name, double width, double length) : base(name)
        {
            this.Width = width;
            this.Length = length;
        }
       
        public override double Area()
        {
            return Length * Width;
        }

        public override void Display()
        {
            Console.WriteLine($"{Name}的面积是{this.Area()}");
        }
    }
}

using OCP.Study.Abstract;
using OCP.Study.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                {
                    Shape Circular = new Circular("圆形", 2);
                    Circular.Area();
                    Circular.Display();
                }
                {
                    Shape Rectangle = new Rectangle("矩形", 7, 12);
                    Rectangle.Area();
                    Rectangle.Display();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }
    }
}

6.接口示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study.Interface
{
    /// <summary>
    /// 课程接口
    /// </summary>
    public interface ICourse
    {
        /// <summary>
        /// 获取课程ID
        /// </summary>
        /// <returns></returns>
        int GetId();
        /// <summary>
        /// 获取课程名称
        /// </summary>
        /// <returns></returns>
        string GetName();
        /// <summary>
        /// 获取课程价格
        /// </summary>
        /// <returns></returns>
        double GetPrice();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study.Interface
{
    /// <summary>
    /// 课程C#
    /// </summary>
    public class CSharpCourse : ICourse
    {
        private int Id;
        private string Name;
        private double Price;

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="id">编号</param>
        /// <param name="name">名称</param>
        /// <param name="price">价格</param>
        public CSharpCourse(int id,string name,double price)
        {
            this.Id = id;
            this.Name = name;
            this.Price = price;
        }

        public int GetId()
        {
            Console.WriteLine(this.Id);
            return this.Id;
        }

        public string GetName()
        {
            Console.WriteLine(this.Name);
            return this.Name;
        }

        public double GetPrice()
        {
            Console.WriteLine(this.Price);
            return this.Price;
        }      
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study.Interface
{
    public class CSharpCourseDisCount : CSharpCourse
    {
        private double DisCount;

        public CSharpCourseDisCount(int id, string name, double price) : base(id, name, price)
        {
            this.DisCount = price*0.8;
        }

        public double GetDisCount()
        {
            Console.WriteLine(this.DisCount);
            return DisCount;
        }
    }
}

using OCP.Study.Abstract;
using OCP.Study.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OCP.Study
{
    /// <summary>
    /// 需求在原有的基础上添加折扣方法
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                ICourse CSharp = new CSharpCourseDisCount(1,"C#",0.9);
                CSharpCourseDisCount CSharpCourse = (CSharpCourseDisCount)CSharp;
                CSharpCourse.GetId();
                CSharpCourse.GetName();
                CSharpCourse.GetPrice();
                CSharpCourse.GetDisCount();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }
    }
}

7.简单说一下抽象类和接口的区别

抽象类：

不能实例化

可以包含抽象方法和抽象访问器（一但包含了抽象方法就必须声明成抽象类）

不能用sealed修饰符（阻止其他类继承自该类）修饰抽象类，因为两个修饰符的含义相反，sealed 修饰符阻止类被继承，而 abstract 修饰符要求类被继承

从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现

接口：

不能被实例化

只能包含方法声明

接口的成员包括方法、属性、索引器、事件（不能包含常量、字段、静态成员、构造函数、析构函数）

相同点：

都不能被实例化

都可以被继承

都可以包含方法声明

派生类必须实现为实现的方法

区别：

抽象类中可以包含静态方法、构造方法、普通成员变量，而接口没有

一个类可以继承多个接口、但只能继承一个抽象类

接口可以被多重实现、抽象类只能被单一继承

如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法

8.属性和字段的区别

属性是对字段的封装，在字段上添加了get、set两个方法

属性从实质上就是一种方法，而字段是用来存数据的

 

 

大话设计模式：七大设计原则
weixin_46228563的博客
08-11 1261
是软件设计和开发中的重要指导原则，‌它们帮助开发者创建可扩展、‌可维护和灵活的软件系统。‌这些原则包括：‌遵循这些原则可以帮助开发人员创建更加灵活、‌可维护和可扩展的软件系统。
程序设计六大原则-概况与举例
赵星海
01-26 1922
总结设计原则其实很早以前就在想了，但是起初我认为固定的原则会局限人的创新思维，陈旧的定律不一定是最好的。实际上随着代码量的沉积，你会发现无形之中你的程序设计会和这六大原则不谋而合。大道至简，前人走过的路，可能也是你将要走的路。 原则一：单一职责 这一块不管你写前端还是后端的项目，你会明白，所谓的设计模式（如MVC，MCP）就是帮助你实现部分代码的单一职责，就像是流水线上工作流程拆分，很多简单的步骤实现庞大的逻辑。当职责变得单一时，复用性提高，个体业务逻辑难度降低。这个原则算是应用最广，也最显而易见的。
开放-封闭原则（The Open-Closed Principle）
一朝风月
12-13 2576
开放-封闭原则（The Open-Closed Principle）
设计原则之一：开放封闭原则
zhouguizhi
01-04 6172
设计原则之一：开放封闭原则
面向对象设计原则之二：开放封闭原则
weixin_33711647的博客
02-02 238
开放封闭原则(Open-Closed Principle OCP) Software entities(classes,modules,functions etc) should open for extension ,but close for modification.    什么意思呢？    所谓开放封闭原则就是软件实体应该对扩展开放，而对修改封闭。开放封闭原则是所有面向对象原则的核...
图解Java设计模式-开闭原则
weixin_37841366的博客
10-04 414
开闭原则是编程中最基础，最重要的设计原则 一个软件实体如类，模块和函数应该对外开放（对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化 编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则。 package ocp; import java.awt.image.CropImageFilter; public class Ocp { public static void m
六大设计原则详解及其应用相关面试题
最新发布
11-29
内容概要：本文详细阐述了SOLID五大设计原则，分别为单一职责原则、开放封闭原则、里氏替换原则、接口隔离原则、依赖倒置原则和迪米特法则。每个原则的作用在于指导开发者编写更加稳定、灵活、可扩展的程序代码。...
设计模式六大原则
06-10
总结，设计模式的六大原则是指导软件设计的基本准则，它们帮助我们编写可维护、可扩展的代码，降低系统的耦合度，提高代码的灵活性。遵循这些原则，可以使我们的软件设计更加健壮，更易于理解和维护。在实际开发中，...
开放封闭原则在软件设计中的重要性
而开放封闭原则（Open/Closed Principle，OCP）是面向对象设计六大原则之一，由Bertrand Meyer提出。该原则强调软件实体应当对扩展开放，对修改封闭。" 知识点详细说明: 1. 设计模式: 设计模式是一套被广泛认可的...
六大设计原则，一些小例子（通俗易懂）
12-19
开放封闭原则表示，软件实体（如类、模块、函数等）应当对扩展开放，对修改关闭。这意味着我们可以增加新的功能，而不必修改现有的代码。比如，通过接口或抽象类实现，当需要添加新功能时，可以创建新的实现类，而...
开放封闭原则
weixin_34221276的博客
08-17 109
概述 软件实体，比如说类，模块，功能等，应当为扩展开放，但是对修改关闭，什么意思呢？就是说，在一个现有的工程完毕之后，以后所有的新添加的功能应当在不修改原有代码的基础上进行，不应当在已有的代码上进行任何的代码修改或者逻辑的修改添加操作。 简介 下面以一个银行存取的程序来讲解，既然是银行存储，那么就少不了存款，取款和利息计算等方面。 namespace OpenCloseDaemon...
程序设计的基本原则-开放封闭原则
分享技术，前沿人工智能动态
04-01 410
开发过程中有什么痛点 ，因为变化、升级和维护等原因需要对原有逻辑进行修改时，很有可能会给旧代码中引入错误，也可能会使我们不得不对整个功能进行重构，并且需要原有功能新测试。 怎么解决 —— 我们应该尽量通过扩展实体的行为来实现变化，而不是通过修改已有的代码来实现变化 具体一点呢 —— 类、模块和函数应该对扩展开放，对修改关闭。模块应该尽量在不修改原代码的情况下进行扩展。 核心 —— 用抽象构建框架，用实现扩展细节。 总结一下 —— 开发人员应该对程序中呈现的频繁变化的那些部分作...
开放-封闭原则
wanguangtong的专栏
02-17 926
时间过来真快，距离上次写设计模式的博客已经快两年了，时间跨度真心太大，整天忙忙碌碌，还是需要沉下心来好好整理一下对知识的理解。今天，分享一下开发过程中，一个比较重要的原则：开放-封闭原则。 开放-封闭原则是指软件在开发过程中，对于软件实体（类、模块、函数等）支持可扩展，但是不可修改。 软件开发过程中，新的需求难免提出，但如何在影响现有功能的情况下扩展新的功能，开放-封闭原则给了我们一个比较好软...
面向对象程序设计之开放-封闭原则(OCP)
mayo2012的专栏
03-10 819
所谓开放就是一个模块的功能是可以扩展的，是可以随时满足外部需求的变化；所谓封闭就是在模块功能扩展的同时，我们不必去改动原有模块的代码，不必去破坏原有模块的完整性，我们所要做的只是在模块之外添加一些代码。 要满足这个原则的关键方法就是抽象，将模块的功能抽象化，例如我们现在需要开发一个模块去读入外部设备输入的数据并把数据显示出来，刚开始的时候，需求只是要求从键盘读入，于是我们实现我们的模块 voi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值