OOP Principle

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

#oop #设计模式 #c++ #编程 #java #扩展

本文探讨了面向对象设计的五大原则，包括单一职责原则、开放封闭原则、Liskov替换原则、依赖倒置原则和接口隔离原则，以及如何利用这些原则处理软件设计中的依赖关系。
依赖是和变化紧密联系在一起的概念。由于依赖关系的存在，变化在某处发生时，影响会波及开来，造成很多修改工作，这就是依赖的危害。可以说变化是始作俑者，依赖是助纣为虐。
我们可以不去拥抱变化吗？不可以。未来将是越来越不可预测，这是新经济最具挑战性的方面之一。商务和技术上的瞬息万变会产生变化，这既可以看作要防范的威胁，也可以看作应该欢迎的机遇。
既然变化不可避免，我们所能做的就是处理好依赖关系，将变化造成的影响波及范围尽量减小。

下面总结一下"面向对象设计五大原则"和良性依赖原则在应付变化方面的作用。

单 一职责原则(Single-Resposibility Principle)。"对一个类而言，应该仅有一个引起它变化的原因。"本原则是我们非常熟悉地"高内聚性原则"的引申，但是通过将"职责"极具创意地 定义为"变化的原因"，使得本原则极具操作性，尽显大师风范。同时，本原则还揭示了内聚性和耦合生，基本途径就是提高内聚性；如果一个类承担的职责过多， 那么这些职责就会相互依赖，一个职责的变化可能会影响另一个职责的履行。其实OOD的实质，就是合理地进行类的职责分配。

开放封闭原则 (Open-Closed principle)。"软件实体应该是可以扩展的，但是不可修改。"本原则紧紧围绕变化展开，变化来临时，如果不必改动软件实体裁的源代码，就能扩充它 的行为，那么这个软件实体设计就是满足开放封闭原则的。如果说我们预测到某种变化，或者某种变化发生了，我们应当创建抽象类来隔离以后发生的同类变化。在 Java中，这种抽象是指抽象基类或接口；在C++中，这各抽象是指抽象基类或纯抽象基类。当然，没有对所有情况都贴切的模型，我们必须对软件实体应该面 对的变化做出选择。

Liskov替换原则(Liskov-Substituion Principle)。"子类型必须能够替换掉它们的基类型。"本原则和开放封闭原则关系密切，正是子类型的可替换性，才使得使用基类型模块无需修改就可 扩充。Liskov替换原则从基于契约的设计演化而来，契约通过为每个方法声明"先验条件"和"后验条件"；定义子类时，必须遵守这些"先验条件"和"后 验条件"。当前基于契的设计发展势头正劲，对实现"软件工厂"的"组装生产"梦想是一个有力的支持。

依赖倒置原则(Dependecy- Inversion Principle)。"抽象不应依赖于细节，细节应该依赖于抽象。"本原则几乎就是软件设计的正本清源之道。因为人解决问题的思考过程是先抽象后具体， 从笼统到细节，所以我们先生产出的势必是抽象程度比较高的实体，而后才是更加细节化的实体。于是，"细节依赖于抽象"就意味着后来的依赖于先前的，这是自 然而然的重用之道。而且，抽象的实体代表着笼而统之的认识，人们总是比较容易正确认识它们，而且本身也是不易变的，依赖于它们是安全的。依赖倒置原则适应 了人类认识过程的规律，是面向对象设计的标志所在。

接口隔离原则(Interface-Segregation Principle)。"多个专用接口优于一个单一的通用接口。"本原则是单一职责原则用于接口设计的自然结果。一个接口应该保证，实现该接口的实例对象 可以只呈现为单一的角色；这样，当某个客户程序的要求发生变化，而迫使接口发生改变时，影响到其他客户程序的可能生性小。

良性依赖原则。" 不会在实际中造成危害的依赖关系，都是良性依赖。"通过分析不难发现，本原则的核心思想是"务实"，很好地揭示了极限编程(Extreme Programming)中"简单设计"各"重构"的理论基础。本原则可以帮助我们抵御"面向对象设计五大原则"以及设计模式的诱惑，以免陷入过度设计 (Over-engineering)的尴尬境地，带来不必要的复杂性。
                                                                            -----------摘自<<程序员>>



Trackback: http://tb.blog.youkuaiyun.com/TrackBack.aspx?PostId=631404

 
shielden
关注
oop设计原则SOLID详解
goodparty的专栏
10-27 681
面向对象编程设计原则有个总结，叫SOLID原则。再具体下去就是具体的设计模式了。
良好OOP的10条黄金法则
04-05
在软件开发领域，面向对象编程（Object-Oriented Programming，简称OOP）是一种常见的编程范式，它基于类和对象的概念，强调数据封装、继承和多态性等核心特性。良好的OOP实践不仅可以提高代码的可读性、可维护性和...
OOP Principles
vividboy的专栏
03-11 1050
Principles of OOP
LongZh_CN的专栏
08-21 628
Principles of OOP If you come from a structured-programming background, the OOP value proposition might not be clear yet. After all, the attributes of a person and any logic to retrieve (and conver
OOP的六大原则+一法则
weixin_44228952的博客
03-28 1066
面向对象设计在网上一直说不清到底是几种，5种？6种？7种？ 这里我截取了《Java设计模式》一书的说法。7种设计原则=6原则+1法则。 7种原则主要从高内聚、低耦合的考量得出的。主要焦距在抽象、接口、实体的关系间。面向对象编程的三大特性：封装、继承、多态。具有这样特性的oop语言，在进行项目显实现是就容易达到重用性、灵活性和扩展性。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mSv6LrIG-1616935412156)(C:\Users\XIAOLEI07\AppDat
The S.O.L.I.D. Object Oriented Programming(OOP) Principles
Angelo Lee's Blog
08-12 1020
Introduction What does it take to be an Object Oriented Programmer? There was a time where I believed all that meant was that you worked wi
Chapter 3: Introduction to Objects and Classes The Object-Oriented Paradigm Course: CS101: Java Language Programming Instructor: [Instructor Name] Date: September 22, 2025 Practical Session Objective Lab Goal: Refactor to an Object-Oriented Design Our goal is to stop using loose, primitive variables to represent our contact and instead create a proper Contact object. This is a foundational step in building professional software. Prerequisites: Java JDK 11 or higher installed. An IDE like IntelliJ IDEA or VS Code ready. Your MyContactManager project from the last lab. Final Result Preview: The console output will look exactly the same as before, but the underlying code structure will be vastly superior, organized, and ready for future expansion. Step 1: Create the Contact Class Blueprint First, we need to create the blueprint for what a "Contact" is in our application. 1. Goal: Create a new Contact.java file and define the state of a contact. 2. Instructions: 1. In your IDE's project explorer, right-click on your source folder and create a new Java Class. 2. Name the file Contact . This will generate Contact.java . 3. Inside the Contact class, declare the instance variables that every contact will have. These are the same variables that are currently cluttering up your main method. 3. Code Block (for Contact.java ): --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 44. Expected Result: You now have two files in your project: MyContactManager.java and Contact.java . The code should compile without errors. Step 2: Instantiate a Contact Object Now that we have the blueprint, let's go back to our main application and create an actual contact from it. 1. Goal: In MyContactManager.java , replace the old primitive variables with a single Contact object. 2. Instructions: 1. Open MyContactManager.java . 2. Delete all the old variable declarations for the contact ( String firstName = "Jane"; , int age = 32; , etc.). 3. In their place, declare and instantiate a new Contact object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: Your main method is now much cleaner. Your code will no longer compile because the parts that used the old variables are now broken. This is good! We'll fix it next. Step 3: Set the Object's State Our contact1 object exists, but its instance variables are all empty ( null or 0 ). Let's fill them with data using dot notation. 1. Goal: Assign values to the instance variables of our new contact1 object. public class Contact { // Instance variables to hold the state of a single contact String firstName; String lastName; int age; String phoneNumber; boolean isFriend; } 1 2 3 4 5 6 7 8 public static void main(String[] args) { // Delete the old variables: // String firstName = "Jane"; (DELETE) // String lastName = "Doe"; (DELETE) // int age = 32; (DELETE) // ...and so on. // Create an object from our blueprint Contact contact1 = new Contact(); // Now we have a single variable, 'contact1', that holds all // the information about our contact. } 1 2 3 4 5 6 7 8 9 10 11 12 132. Instructions: 1. After the line Contact contact1 = new Contact(); , use the dot operator to access each instance variable and assign it a value. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: The contact1 object in memory now holds all the data for John Doe. The code still won't compile because the System.out.println statements are broken. Step 4: Get the Object's State Finally, let's fix our print statements to read the data back from the object, again using dot notation. 1. Goal: Update the System.out.println statements to use the object's fields. 2. Instructions: 1. Find your old println statements that are showing compile errors. 2. Prefix each old variable name with contact1. to tell Java to get the value from the object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: All compile errors should now be gone! Your application is fully refactored. // ... after creating the contact object Contact contact1 = new Contact(); // Use dot notation to set the object's state contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; 1 2 3 4 5 6 7 8 9 // ... after setting the object's state System.out.println("\n--- Contact Details ---"); // OLD: System.out.println("Name: " + firstName + " " + lastName); // NEW: System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); // OLD: System.out.println("Age: " + age); // NEW: System.out.println("Age: " + contact1.age); // OLD: System.out.println("Phone: " + phoneNumber); // NEW: System.out.println("Phone: " + contact1.phoneNumber); 1 2 3 4 5 6 7 8 9 10 11 12 13 14Final Code and Verification Let's look at the final, refactored MyContactManager.java and verify that it works. 1. Goal: Run the application and confirm the output is correct. 2. Code Block (Complete MyContactManager.java ): 3. Expected Output: Success! The output is the same, but our code structure is infinitely better. Optional Challenge Task For Those Who Finish Early... 🚀 If you've completed the refactoring, this challenge will solidify your understanding of objects. Challenge: Create a Second, Independent Object 1. In your main method, create a second Contact object called contact2 . 2. Set the state for contact2 with completely different data (e.g., "Jane Smith", age 35, etc.). 3. Add println statements to display the details for contact2 after displaying the details for contact1 . public class MyContactManager { public static void main(String[] args) { // 1. Create an object (an instance) from the Contact class blueprint Contact contact1 = new Contact(); // 2. Set the state of the object using dot notation contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; // 3. Get the state of the object using dot notation System.out.println("--- Contact Details ---"); System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); System.out.println("Age: " + contact1.age); System.out.println("Phone: " + contact1.phoneNumber); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 4This will prove that contact1 and contact2 are two separate objects in memory, each with its own independent state, even though they were built from the same class blueprint. Q&A and Wrap-up Questions? Today's Most Important Lesson Organizing code into classes that model real-world concepts is the single most powerful strategy for managing complexity in software. We took a chaotic collection of variables and transformed it into a clean, intuitive structure. A Contact is now a "thing" in our program, just as it is in the real world. This is the foundation upon which all large-scale, professional applications are built. What's Next? Up Next: Protecting Our Objects Right now, our code has a major flaw. Anyone using our Contact class can do this: contact1.age = -99; contact1.phoneNumber = "this is not a phone number"; This is dangerous and leads to bugs! An object should be in control of its own data. Next Lecture: Chapter 4: Deeper Dive into Classes - Encapsulation We'll learn about encapsulation, a core OOP principle for data hiding and protection. We'll introduce private variables and public getter/setter methods to create robust, bug-resistant objects. 以上问题的答案是什么
最新发布
09-21
### 从使用原始变量到创建 Contact 对象的代码重构步骤 #### 1. 分析原始代码 假设原始代码使用多个独立的变量来存储联系人信息，例如： ```java // 原始代码使用独立变量存储联系人信息 String contactName = ...
99 Bottles of OOP A Practical Guide to Object-Oriented Design 1st Edition
04-04
99 Bottles of OOP is a practical guide to writing cost-effective, maintainable, and pleasing object-oriented code. It explores: Recognizing when code is “good enough” Getting the best value from ...
OOP设计原则
10-17
**OOP设计原则详解** 面向对象编程（Object-Oriented Programming，简称OOP）是一种流行的编程范式，它强调将数据和操作数据的方法封装在一起，形成独立的对象。OOP设计原则是指导我们如何构建可维护、可扩展和可...
实例解析OOP程序设计七大设计原则(一)
Kiboo的博客
07-25 5071
开闭原则（Open-Closed Principle,OCP） 开闭原则是这七大设计原则中最常见、最基本的 开闭原则定义：软件实体对扩展是开放的，但对修改是关闭的。意思就是说在不修改软件实体的基础上去扩展其他功能。 开闭原则实例： 比如实现一个绘制图线的功能 设计方案如下图所示 用户类中直接调用画直线类，但是如果有一个新需求，要求我们画斜线或者曲线的话，这时就需要修改画直线类中
OOP 七大原则
Fanstasic的博客
03-15 2017
一、开-闭原则(Open-Closed Principle, OCP) 二、里氏替换原则(Liskov Substitution Principle,LSP) 三、依赖倒置原则(Dependence Inversion Principle) 四、接口隔离原则(Interface Segregation Principle, ISP) 五、合成/聚合复用原则(Composite/Aggreg...
OOP面向对象编程的几大原则
学而不思则罔 思而不学则殆
09-19 1484
部分转载，部分原创。 1. 开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。  2. 里氏代换原则（Liskov Substitution
OOP面向对象的七大原则
zhang_java_11的博客
07-24 170
OOP七大原则 开闭原则(Open-Closed Principle, OCP):一个软件的实体应当对拓展开放，对修改关闭。 里氏替换原则(Liskov Substitution Principle,LSP):任何时候都可以用子类型替换掉父类型。 依赖倒置原则(Dependence Inversion Principle):要针对接口编程，不要针对实现编程–面向接口编程。 接口隔离原则(Interface Segregation Principle, ISP):接口要小而专，绝不能大而全。 合成/聚合复用
每个程序员都应了解的10个OOP设计原则
编程故事的地方
05-05 361
面向对象的设计原则 OOP是OOP编程的核心，但是我看到大多数Java程序员都在追求诸如Singleton模式 ， Decorator模式或Observer模式之类的设计模式，而对学习面向对象的分析和设计没有给予足够的重视。 了解诸如抽象 ， 封装 ， 多态和继承之类的面向对象程序设计的基础很重要。 但是，与此同时，了解面向对象的设计原则也同样重要。 它们将帮助您创建简洁的模块化设计，将...
2.2 单一职责原则
dcryefx44317的博客
04-18 201
2.2 单一职责原则 2.2.1 引言 一个优良的系统设计，强调模块间保持低耦合、高内聚的关系，在面向对象设计中这条规则同样适用，所以面向对象的第一个设计原则就是：单一职责原则（SRP，Single Responsibility Principle）。 单一职责，强调的是职责的分离，在某种程度上对职责的理解，构成了不同类之间耦合关系的设计关键，...
快速理解 SOLID (面向对象设计)——单一职责原则
qq_18208265的博客
09-08 687
快速理解 SOLID (面向对象设计)——单一职责原则 在程序设计领域， SOLID（单一功能、开闭原则、里氏替换、接口隔离以及依赖反转），指代了面向对象编程和面向对象设计的五个基本原则。当这些原则被一起应用时，它们使得一个程序员开发一个容易进行软件维护和扩展的系统变得更加可能。 1. 单一职责原则 1.1 单一职责原则 的定义 不要存在多于一个导致类变更的原因。简单的讲，认为对象应该仅具有一...
七大原则——单一职责原则
m0_37654408的博客
04-09 2232
单一职责原则的定义 单一职责原则（Single Responsibility Principle，SRP）又称单一功能原则，由罗伯特·C.马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中提出的。这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one...
解读设计模式--单一职责原则
Q
07-01 2705
认识单一职责原则          单一职责原则是面向对象设计中最重要的原则之一，而面向对象最基础的东西就是类和对象的使用，而单一职责可以说是对类和对象的一种要求，也就是要求类应该有且仅有一个引起它变化的原因。       开闭原则是指一个类，只有一个引起它变化的原因。有且只有一个职责。每一个职责都是变化的一个轴线，如果一个类有一个以上的职责，这些职责就耦合在了一起。这会导致脆弱的设计。当一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值