它经常被重复，但完全正确——理解你的数据。

对于面向对象编程，你的类应该描述重要的信息片段以及它们如何交互。

如果您有一个心智模型，它很好地描述了数据的行为和生命周期，那么您将很容易布局您的类。

这句话其实是“确切地知道你要做什么”的延伸。

我建议你使用BlueJ和ActiveWriter来学习和发展对对象的良好理解。推荐的书也是很好的资源。

从维基百科:

(来源:bluej.org)

BlueJ是一个综合开发项目 Java编程环境 语言，主要是为了 教育的目的，也是 适用于小规模软件 发展。

此外，它使用UML，对我来说，这是一个很好的资源来理解建模对象的一些事情。

可选文字 http://www.ryanknu.com/ryan/bluej.png

ActiveWriter是一个建模实体和关系的工具，它还可以生成代码，并且很容易进行更改。它将节省您的时间，并且对于敏捷开发非常适合。

(来源:altinoren.com)

老实说，最好是回头看看流程图和序列图。有大量的好网站告诉你如何做到这一点。当我考虑如何将程序分解为类时，我发现这是非常宝贵的，因为我确切地知道程序需要输入、计算和输出什么，并且每一步都可以分解为程序的一个部分。

在你要写的软件设计中，你遵循的工作流程是什么?

当我有机会时，我通常会使用我所谓的“三次迭代规则”。

In the first iteration (or startup), I devise the general layout of the application according to the model objects, the algorithms, and the expected (really expected, not maybe expected) future directions. I don't write design documents, but if I have to coordinate multiple people, a rough sketch of the procedure is of course needed, together with an analysis of dependencies and guesstimate of the time needed. Try to keep this phase to a minimum if, like me, you prefer a more agile method. There are cases where a strong design phase is needed, in particular when everything is known and true about the logic of your program, and if you plan to have a lot of interactions between features in your code. In this case, use cases or user stories provide are a good high level idea, in particular for GUI apps. For command line apps, and in particular libraries, try to write "program stories" in which you code against the library you have to develop and check how it looks. These programs will become functional tests of your library when completed.

After this first iteration, you will have a better understanding on how things interact, got out the details and the rough spots, solved issues with a slapped duct tape patch. You are ready to make use of this experience to improve, clean, polish, divide what was too large, coalesce what was too fragmented, define and use design patterns, analyze performance bottlenecks and nontrivial security issues. In general, all these changes will have a huge impact on the unit tests you wrote, but not on the functional tests.

当您完成第二次迭代时，您将拥有一个经过良好测试、良好记录和良好设计的小珍宝。现在您已经有了进行第三次迭代(扩展)的经验和代码。您将添加新的特性和用例来改进应用程序。你会发现一些粗糙的地方，最终你会进入与第二次类似的第四次迭代。清洗并重复。

这是我软件设计的一般方法。它类似于螺旋设计，具有简短的，三个月的迭代，以及敏捷开发的元素，允许您了解问题并了解您的软件及其应用领域。当然，这是一个可伸缩性的问题，所以如果应用程序非常大，涉及到数百名开发人员，事情就会比这复杂一些，但最终我想想法总是一样的，分门别类。

总结一下:

在第一次迭代中，您将体验并学习它 在迭代2中，您将清理产品并为未来做好准备 在迭代3中，您添加了新特性并了解了更多 转到2

我用于初始设计(得到类图)的步骤是:

Requirements gathering. Talk to the client and factor out the use cases to define what functionality the software should have. Compose a narrative of the individual use cases. Go through the narrative and highlight nouns (person, place, thing), as candidate classes and verbs (actions), as methods / behaviors. Discard duplicate nouns and factor out common functionality. Create a class diagram. If you're a Java developer, NetBeans 6.7 from Sun has a UML module that allows for diagramming as well as round-trip engineering and it's FREE. Eclipse (an open source Java IDE), also has a modeling framework, but I have no experience with it. You may also want to try out ArgoUML, an open source tool. Apply OOD principles to organize your classes (factor out common functionality, build hierarchies, etc.)

尝试使用行为驱动开发。要打破你的旧习惯很难，但我发现BDD确实是你在现实世界中开发的最佳选择。

http://behaviour-driven.org/

一个有用的技巧是将你独特的问题描述与你在现实世界中可以找到的东西联系起来。例如，你正在为一个将席卷全球的复杂医疗保健系统建模。有什么例子你可以随时调用建模吗?

确实。观察旁边的药房是如何运作的，或者医生的房间。

把你的领域问题归结为你能理解的问题;一些你能联想到的东西。

然后，一旦领域内的“玩家”开始出现，你开始对你的代码建模，选择“提供者-消费者”建模方法，即你的代码是模型的“提供者”，而你是“消费者”。

与领域相关并在较高层次上理解它是任何设计的关键部分。

我认为这里的答案应该是非常不同的，这取决于这个人在现实世界中的经验。

如果你只有一两年的工作经验，那么你必须明白这一点:你如何才能真正了解你的数据，并确切地了解你要做的事情?

是的，如果您已经在现实世界中工作了5年以上，那么您可以在许多软件开发过程模型或技术中选择任何一种。

但是光靠读书是得不到经验的。你应该在一个好的领导下的好团队中学习。

如果这是不可能的，那么你应该自己做。从编写一段可能非常糟糕的代码开始迭代，学习错误，丢弃所有错误，编写更好的代码等等。

您将学到很多关于代码库的知识。工具就是工具，它们不会教你任何东西。

你问了一个很多作家用来写书的问题。有很多方法，你应该选择一个对你来说“最漂亮”的。 我可以推荐Eric Evans写的《Domain Driven Design》。另外，查看dddcommunity.org网站。

学习和掌握设计模式。 接下来，学习领域驱动设计 之后，学习需求收集

我上了几个学期的OOD课程 回来后，我学到了很多;就像 编写UML和翻译 将需求文档转换为对象 和类。我们学过序列 图表也有，但不知怎么的，我错过了 讲座之类的，他们没有 跟紧我。

You know about the step 3. You need to master it. I mean, via a lot of practice to make it become your second nature. That's because the method you learn, is simply against the way we used to have. So you need to really master it. Otherwise, you will always find yourself go back to your original way of doing thing. This is somehow like Test Driven Process, where a lot of java developer give it up after a few tries. Unless they fully master it, otherwise it's just a burden to them Write use cases, especially for alternate course. Alternate course occupy more than 50% of our development time. Normally when your PM assign you a task, for instance, create a login system, he will think it's straight forward, you can take 1 day to finish it off. But he never take into account that you need to consider, 1. what if user key in wrong password, 2. what if user key in wrong password for 3 times, 3. what if user doesn't type in user name and etc. You need to list them out, and show it to your PM, ask him to reschedule the deadline.

大型项目的问题在于您无法监督组件之间的所有交互。因此，降低项目的复杂性是很重要的。类图和序列图对于这个设计阶段来说太详细了。

首先试着从更高的抽象层次来思考。考虑主要组件及其职责(它们与其他组件的接口)，查看一些架构模式以获得灵感(不，不是设计模式，这些太低级了!MVC和多层是架构模式的例子)。 对于相当大的项目，这样的视图应该有大约3-5个组件。

只有这样，你才能放大到某个组件，并尝试设计它。现在我们到了设计模式和类图的层次。试着把注意力集中在项目的这一部分，如果你发现你需要向其他组件之一添加一个职责，就把它添加到你的文档/待办事项列表中。不要在这个时候浪费时间思考它们的含义，因为它们的变化太快了，当设计更加可靠时再进行检查。

此时您不需要完整地设计每个组件，尽管使用一段代码来实现未实现的组件接口并生成简单但有用的响应可能是明智的。这样，您就可以一次开始开发(和设计)一个组件，并对其进行合理的测试。

当然，当新组件完成后，您应该在继续之前测试它们如何(以及是否)相互集成。

简而言之: 采用面向对象和信息隐藏原理，并将其提升到另一个层次!

PS: 在设计的时候画很多草图，就像真正的建筑一样!

PPS:试着从不同的角度来看待这个问题，跳出固有的思维模式(尽管固有的思维模式可能是正确的)，与同行讨论可能会非常有用……午餐时你们有话可聊。

关于这一点，我所知道的最有趣的来源是Bertrand Meyer所著的《面向对象软件构建》第二版的D部分。

第四部分:面向对象的方法论:很好地应用该方法

19:关于方法论， 20:设计 模式:多面板交互 系统中, 21:传承案例研究: 交互系统中的“undo”，22: 如何找到课程，23: 课程设计原则，24:使用 继承好，25:有用 技巧，26分:风格感，27分: 面向对象分析，28:The 软件构建过程，29: 教学方法

有趣的是，第22章。如何在网上找到课程。

我在实际项目中使用的成功的技术是责任驱动设计，灵感来自Wirfs-Brock的书。

从最顶层的用户故事开始，与同事一起，在白板上勾勒出它们所暗示的高级交互。这让你对大模块有了初步的了解;重复一两次高级CRC-card(游戏邦注:如play)，你应该已经稳定了一个主要组件列表，它们的作用以及它们如何相互作用。

然后，如果任何职责很大或很复杂，那么细化这些模块，直到有足够小且简单的东西成为对象，方法是在模块内执行由更高级别交互确定的每个主要操作的交互。

知道什么时候该停下来是一个判断问题(只有经验才能决定)。

恐怕人们不愿意听到这样的回答。无论如何，让我陈述我的观点。

OOP should be viewed as one of the paradigms, not as the superior paradigm. OOP is good for solving certain kind of problems, like developing a GUI library. It also fits into the style of software development usually followed by large software companies - an elite team of designers or architects lays down the software design in UML diagrams or some other similar medium and a less enlightened team of developers translate that design into source code. OOP offer little benefit if you are working alone or with a small team of highly talented programmers. Then, it is better to use a language that supports multiple paradigms and will help you to come up with a prototype fast. Python, Ruby, Lisp/Scheme etc are good choices. The prototype is your design. Then you improve on that. Use the paradigm that is best to solve the problem at hand. If needed, optimize hot spots with extensions written in C or some other systems language. By using one of these languages, you also get extensibility for free, not just at the programmer level but also at the user level. Languages like Lisp can dynamically generate and execute code, which means your users can extend the application by writing small code snippets, in the language that the software itself is coded! Or if you choose to write the program in C or C++, consider embedding an interpreter for a small language like Lua. Expose functionalities as plugins written in that language.

我认为，大多数时候OOP和OOD所创造的软件都是过度设计的受害者。

总之，我喜欢的写软件的方式是:

使用动态语言。 用这种语言编写设计(原型)。 如果有必要，使用C/ c++优化某些领域。 通过实现语言本身的解释器提供可扩展性。

最后一个特性使软件能够轻松地适应特定用户(包括我自己!)的需求。

设计模式

创造性设计模式

单例——确保只创建类的一个实例，并提供对象的全局访问点。

Factory(Factory Method的简化版)—创建对象时不向客户端公开实例化逻辑，并通过公共接口引用新创建的对象。

Factory方法——定义一个用于创建对象的接口，但是让子类来决定实例化哪个类，并通过公共接口引用新创建的对象。

抽象工厂——提供了创建一系列相关对象的接口，而无需显式地指定它们的类。

Builder -定义一个创建对象的实例，但让子类决定实例化哪个类，并允许对构造过程进行更精细的控制。

Prototype—指定使用原型实例创建的对象类型，并通过复制该原型创建新对象。

行为设计模式

责任链——它避免了将请求的发送方附加到它的接收方，从而使其他对象也可以处理请求。 -对象成为链的一部分，请求通过链从一个对象发送到另一个对象，直到其中一个对象处理它。

命令-将请求封装在对象中，允许对不同请求的客户端进行参数化，并允许将请求保存在队列中。

解释器——给定一种语言，为其语法定义一个表示法，并定义一个解释器，使用该表示法解释该语言中的句子/将域映射到语言，将语言映射到语法，将语法映射到分层面向对象的设计

迭代器——提供一种方法，可以按顺序访问聚合对象的元素，而不暴露其底层表示。

中介——定义一个对象，它封装一组对象如何交互。Mediator通过防止对象显式地相互引用来促进松耦合，并且允许您独立地改变它们的交互。

观察者——在对象之间定义一对多的依赖关系，这样当一个对象改变状态时，它的所有依赖关系都会被自动通知和更新。

策略——定义一组算法，封装每个算法，并使它们可互换。策略允许算法独立于使用它的客户机而变化。

模板方法——在一个操作中定义一个算法的框架，将一些步骤推迟到子类/模板方法让子类重新定义算法的某些步骤，而不让它们改变算法的结构。

Visitor -表示要在对象结构的元素上执行的操作/ Visitor允许您定义一个新操作，而无需更改其操作的元素的类。

空对象——提供一个对象作为缺少给定类型对象的代理。/空对象模式提供了智能的无为行为，对合作者隐藏了细节。

结构设计模式

适配器——将一个类的接口转换成客户端期望的另一个接口。/ Adapter允许类一起工作，否则由于不兼容的接口而无法一起工作。

桥接——将对象组合成树形结构来表示部分-整体层次结构。/ Composite允许客户端统一地处理单个对象和对象的组合。

复合——将对象组合成树状结构来表示部分-整体层次结构。/ Composite允许客户端统一地处理单个对象和对象的组合。

装饰器——动态地向对象添加额外的职责。

Flyweight——使用共享来支持大量的对象，这些对象的部分内部状态是相同的，而另一部分状态可能是不同的。

记忆碎片——在不违反封装的情况下捕获对象的内部状态，从而提供了在需要时将对象恢复到初始状态的方法。

代理——为对象提供一个“占位符”来控制对它的引用。

首先，设计应该来自你的灵魂。你必须用每一根纤维去感受它。在我开始做任何事情之前，我通常会走两三个月，只是在街上走(真的)。和思考。你知道，散步是一种很好的冥想。所以它能让你更好地集中注意力。

其次，只在存在自然对象层次结构的地方使用OOP和类。不要人为地把它“拧”进去。如果没有严格的层次结构存在(就像在大多数业务应用程序中一样)-选择过程式/函数式，或者至少只将对象用作具有隔离访问器的数据容器。

最后一本——试着读一下:《创造性思维的算法》

斯科特·戴维斯补充说:

Make absolutely sure you know what your program is all about before you start. What is your program? What will it not do? What problem is it trying to solve? Your first set of use cases shouldn't be a laundry list of everything the program will eventually do. Start with the smallest set of use cases you can come up with that still captures the essence of what your program is for. For this web site, for example, the core use cases might be log in, ask a question, answer a question, and view questions and answers. Nothing about reputation, voting, or the community wiki, just the raw essence of what you're shooting for. As you come up with potential classes, don't think of them only in terms of what noun they represent, but what responsibilities they have. I've found this to be the biggest aid in figuring out how classes relate to each other during program execution. It's easy to come up with relationships like "a dog is an animal" or "a puppy has one mother." It's usually harder to figure out relationships describing run-time interactions between objects. You're program's algorithms are at least as important as your objects, and they're much easier to design if you've spelled out what each class's job is. Once you've got that minimal set of use cases and objects, start coding. Get something that actually runs as soon as possible, even though it doesn't do much and probably looks like crap. It's a starting point, and will force you to answer questions you might gloss over on paper. Now go back and pick more use cases, write up how they'll work, modify your class model, and write more code. Just like your first cut, take on as little at a time as you can while still adding something meaningful. Rinse and repeat.

这只是我的个人意见。希望对大家有用。

During my adventures of designing class structures, I’ve noticed that it’s very helpful to start with writing some pseudo-code. That means: I start with “writing” some general fragments of application’s code on a highest level, play with it, and discover the elements that are appearing – in fact, the elements that I – as a programmer – would like to use. It’s a very good starting point for designing general structure of modules and their interactions. After few iterations the whole structure starts to look more like a full system of classes. It’s a very flexible way to design parts of code. You can call it a programmer-oriented design.

如果你对你要从事的项目有专业知识，比如银行业。你可以很容易地构建你的对象，而且你知道每隔一天就会有这些增强。

如果你没有这方面的专业知识，那就和有这方面专业知识的人合作，把这些想法转化为技术细节。

如果你对如何组织你的项目设计感到困惑。盲目地遵循“实用的程序员”这本书。我以前也遇到过同样的情况，试着读那本书的一章。它会改变你作为软件开发人员的思维方式。

学习设计模式。在过去的两年里，这是我个人在面向对象编程方面的革命。找一本书。我向你推荐这个:

头部优先的设计模式

它使用Java，但可以扩展到任何语言。

只是引用http://www.fysh.org/~katie/computing/methodologies.txt

并且RUP的核心是一个您必须使用面向对象设计的小区域 人才……如果你没有它们，就像有一个方法论 100米跑。

“第一步:写关于快跑的故事。 第二步:画一张赛马场平面图。 第三步:去买紧身的莱卡短裤。 第四步:跑得非常、非常、非常快。 第五步:先跨线

第四步才是最难的。但如果你特别强调 在第1 2 3 5次，有可能没有人会注意到，然后你就可以 卖这个方法可能会赚很多钱 那些认为成为百米运动员有什么“秘密”的运动员

我使用测试驱动设计(TDD)。首先编写测试实际上有助于引导您获得干净和正确的设计。见http://en.wikipedia.org/wiki/Test-driven_development。