blocks|key|3846157|text|面向对象类设计原则(“实体”原则)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3846158|一个类应该有一个，而且只有一个，原因是，你应该能够扩展一个类的行为，而不需要修改利斯科夫替换原则，|3846159|SRP:派生类必须可以替代它们的基础接口分离原则，使细粒度的接口，这是客户端specific.|unordered-list-item|offset|length|style|BOLD|3846160|DIP:的依赖倒置原则依赖于抽象，不在concretions.|3846161|上|3846162|来源：http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod|3846163|视频(鲍勃大叔)：Clean+Coding+By+Robert+C.+Martin+(+Uncle+Bob+)|3846164|entityMap|0|LINK|mutability|MUTABLE|url|http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod|1|https://www.youtube.com/watch?v=ZPDC13_9PkI^0|0|0|0|1B|0|0|V|0|0|1|0|0|1N|3|1K|0|0|0|1J|9|1A|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@$G|15|H|16|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|17|8|@$G|18|H|19|I|J]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@$G|1B|H|1C|I|J]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1D|8|@$G|1E|H|1F|I|J]]|9|@$G|1G|H|1H|1|1I]]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@$G|1K|H|1L|I|J]]|9|@$G|1M|H|1N|1|1O]]|A|$]]|$1|S|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

<h3>Principles Of Object Oriented Class Design (the &quot;SOLID&quot; principles)</h3>
<ul>
<li>SRP: The Single Responsibility
Principle A class should have one,
and only one, reason to change.</li>
<li>OCP: The Open Closed Principle You
should be able to extend a classes
behavior, without modifying it.</li>
<li>LSP: The Liskov Substitution
Principle Derived classes must be
substitutable for their base
classes.</li>
<li>ISP: The Interface Segregation
Principle Make fine grained
interfaces that are client specific.</li>
<li>DIP: The Dependency
Inversion Principle Depend on
abstractions, not on concretions.</li>
</ul>
Source: <a href="http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod" rel="nofollow noreferrer">http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod</a>
Video (Uncle Bob): <a href="https://www.youtube.com/watch?v=ZPDC13_9PkI" rel="nofollow noreferrer">Clean Coding By Robert C. Martin ( Uncle Bob )</a>

blocks|key|754155|text|别忘了Law+of+Demeter。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|754156|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Law_of_Demeter^0|3|E|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Don't forget the <a href="http://en.wikipedia.org/wiki/Law_of_Demeter" rel="nofollow noreferrer">Law of Demeter</a>.

blocks|key|3846263|text|S.O.L.I.D.+principles。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3846264|或者至少我尽量不离他们太远。|3846265|entityMap|0|LINK|mutability|MUTABLE|url|http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod^0|0|L|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

The <a href="http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod" rel="noreferrer">S.O.L.I.D. principles</a>. 
Or at least I try not to steer away too much from them.

blocks|key|3002413|text|最基本的设计模式应该是KISS+(保持简单、愚蠢)，这意味着有时根本不对某些元素使用类，这是正确的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3002414|这和CRC(类，责任，协作者)卡片(将卡片写在你的头文件中，而不是写在实际的卡片上，因为它们也很容易理解文档)|3002415|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The most fundamental design pattern should be KISS (keep it simple stupid)
Which means that sometimes not using classes for some elements at all it the right solution.

That and CRC(Class, Responsibility, Collaborators) cards (write the card down in your header files, not on actual cards that way they because easy to understand documentation too)

blocks|key|5257269|text|如上所述，一些基本的面向对象设计原则是OCP、LSP、DIP和ISP。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5257270|Robert+C.Martin(+Object+Mentor的)对这些的一个很好的概述可以在这里获得：OOD+Principles+and+Patterns|offset|length|5257271|entityMap|0|LINK|mutability|MUTABLE|url|http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf^0|0|1F|R|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

As mentioned above, some of the fundamental Object Oriented Design principles are OCP, LSP, DIP and ISP. 

An excellent overview of these by Robert C. Martin (of Object Mentor) is available here: <a href="http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf" rel="nofollow noreferrer">OOD Principles and Patterns</a>

blocks|key|754062|text|"Resource+Acquisition+Is+Initialization“范例很方便，特别是在用C%2B%2B编写代码和处理操作系统资源(文件句柄、端口等)时。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|754063|这种方法的一个关键好处是，对象一旦创建，就是“完整的”--不需要两个阶段的初始化，也不可能出现部分初始化的对象。|754064|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Resource_acquisition_is_initialization^0|1|12|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

The "<a href="http://en.wikipedia.org/wiki/Resource_acquisition_is_initialization" rel="nofollow noreferrer">Resource Acquisition Is Initialization</a>" paradigm is handy, particularly when writing in C++ and dealing with operating system resources (file handles, ports, etc.).

A key benefit of this approach is that an object, once created, is "complete" - there is no need for two-phase initialization and no possibility of partially-initialized objects.

blocks|key|3002348|text|松散耦合，高度内聚。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3002349|组合优先于继承。|3002350|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

loosely coupled, highly cohesive.

Composition over inheritance.

blocks|key|3846196|text|领域驱动设计通常是一个很好的遵循原则。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3846197|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Domain Driven Design is generally a good principle to follow.

blocks|key|3002265|text|基本上，我不需要对接口进行编程。我试图封装那些通过案例发生变化的代码，以避免代码重复，并将代码隔离为可管理的(对于我的大脑而言)块。稍后，如果我需要的话，我可以很容易地重构代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3002266|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Basically I get away with programming to interfaces. I try to encapsulate that which changes through cases to avoid code duplication and to isolate code into managable (for my brain) chunks. Later, if I need, I can then refactor the code quite easily.

blocks|key|3002385|text|坚实的原则和利斯科夫的模式，以及单一责任模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3002386|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

SOLID principles and Liskov's pattern, along with Single responsibility pattern.

blocks|key|5257512|text|我想要补充的一件事是分层，在你的应用程序中定义层，一个层的总体责任，他们两层将交互的方式。只有与该层具有相同职责的类才应该被允许在该层中。这样做可以解决很多混乱问题，确保适当地处理异常，并确保新开发人员知道将代码放在哪里。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5257513|另一种设计方法是将您的类设计为可配置的创建一种机制，使配置可以插入到您的类中，而不是重写子类中的方法，确定更改了什么，看看是否可以配置，并确保此功能是从配置派生的|5257514|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A thing which I would like to add to all this is layering, Define layers in your application, the overall responsibility of a layer, they way two layers will interact. Only classes which have the same responsibility as that of the layer should be allowed in that layer. Doing this resolves a lot of chaos, ensures exceptions are handled appropriately, and it makes sure that new developers know where to place their code. 

Another way to design is by designing your class to be configurable creating a mechanism where the configuration can be plugged in your class, rather than overriding methods in sub classes, identify what changes, see if that can be made configurable and ensures that this functionality is derived from configurations

blocks|key|754074|text|我通常会尝试将这个类放入一个oo+design+patterns.中。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|754075|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Design_pattern_(computer_science)^0|H|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I usually try to fit the class into one of the oo <a href="http://en.wikipedia.org/wiki/Design_pattern_(computer_science)" rel="nofollow noreferrer">design patterns.</a>

What principles do you generally follow when doing class design?

Design Principles

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在进行类设计时，您通常遵循哪些原则？

问设计原则
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问设计原则EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问设计原则
EN