我正在处理一个大型项目(对我来说)，它将有许多类，需要可扩展，但我不确定如何规划我的程序以及类需要如何交互。
几个学期前我上了一门OOD课程，从中学到了很多东西;比如编写UML，并将需求文档转换为对象和类。我们也学过序列图但不知怎么的我错过了这节课，我没能记住它们。
在之前的项目中，我尝试使用从课程中学到的方法，但通常在我说“是的，这看起来像我想要的东西”时，我就会以代码结束，我不想再挖掘出新的功能。
我有一本Steve McConnell的《Code Complete》，我经常在这里和其他地方听到它的神奇之处。我读了关于设计的章节，似乎没有得到我想要的信息。我知道他说这不是一个固定的过程，它主要是基于启发式，但我似乎不能把他所有的信息都应用到我的项目中。
那么，在高级设计阶段(在开始编程之前)，你要做些什么来确定你需要什么类(特别是那些不基于任何“现实世界对象”的类)以及它们如何相互交互?
我特别感兴趣的是你使用的方法是什么?你遵循什么样的过程，通常会产生一个良好的，干净的设计，将接近最终产品?
当前回答
斯科特·戴维斯补充说:
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.
这只是我的个人意见。希望对大家有用。
其他回答
我用于初始设计(得到类图)的步骤是:
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.)
我使用测试驱动设计(TDD)。首先编写测试实际上有助于引导您获得干净和正确的设计。见http://en.wikipedia.org/wiki/Test-driven_development。
大型项目的问题在于您无法监督组件之间的所有交互。因此，降低项目的复杂性是很重要的。类图和序列图对于这个设计阶段来说太详细了。
首先试着从更高的抽象层次来思考。考虑主要组件及其职责(它们与其他组件的接口)，查看一些架构模式以获得灵感(不，不是设计模式，这些太低级了!MVC和多层是架构模式的例子)。 对于相当大的项目，这样的视图应该有大约3-5个组件。
只有这样，你才能放大到某个组件，并尝试设计它。现在我们到了设计模式和类图的层次。试着把注意力集中在项目的这一部分，如果你发现你需要向其他组件之一添加一个职责，就把它添加到你的文档/待办事项列表中。不要在这个时候浪费时间思考它们的含义，因为它们的变化太快了，当设计更加可靠时再进行检查。
此时您不需要完整地设计每个组件，尽管使用一段代码来实现未实现的组件接口并生成简单但有用的响应可能是明智的。这样，您就可以一次开始开发(和设计)一个组件，并对其进行合理的测试。
当然，当新组件完成后，您应该在继续之前测试它们如何(以及是否)相互集成。
简而言之: 采用面向对象和信息隐藏原理，并将其提升到另一个层次!
PS: 在设计的时候画很多草图，就像真正的建筑一样!
PPS:试着从不同的角度来看待这个问题，跳出固有的思维模式(尽管固有的思维模式可能是正确的)，与同行讨论可能会非常有用……午餐时你们有话可聊。
尝试使用行为驱动开发。要打破你的旧习惯很难，但我发现BDD确实是你在现实世界中开发的最佳选择。
http://behaviour-driven.org/
当我有机会时，我通常会使用我所谓的“三次迭代规则”。
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
