it-swarm.com.de

Wie gestalten Sie objektorientierte Projekte?

Ich arbeite an einem großen Projekt (für mich), das viele Klassen haben wird und erweiterbar sein muss, aber ich bin nicht sicher, wie ich mein Programm planen soll und wie die Klassen interagieren müssen.

Ich habe vor ein paar Semestern einen OOD-Kurs besucht und viel daraus gelernt. B. UML schreiben und Anforderungsdokumente in Objekte und Klassen übersetzen. Wir haben auch Sequenzdiagramme gelernt, aber irgendwie habe ich die Vorlesung verpasst oder so, sie sind nicht wirklich bei mir geblieben.

Bei früheren Projekten habe ich versucht, Methoden zu verwenden, die ich aus dem Kurs gelernt habe, aber normalerweise erhalte ich Code, mit dem ich, sobald ich sagen kann: "Ja, das sieht ungefähr so ​​aus, wie ich es mir vorgestellt habe." Neue Eigenschaften.

Ich habe eine Kopie von Steve McConnells Code Complete , von der ich immer wieder höre, dass sie hier und anderswo erstaunlich ist. Ich las das Kapitel über Design und schien nicht mit den Informationen herauszukommen, nach denen ich suche. Ich weiß, dass er sagt, dass es kein zerschnittener und getrockneter Prozess ist, dass er hauptsächlich auf Heuristiken basiert, aber ich kann scheinbar nicht alle seine Informationen nehmen und auf meine Projekte anwenden.

Also Was sind die Dinge, die Sie während der Entwurfsphase auf hoher Ebene tun (bevor Sie mit dem Programmieren beginnen), um zu bestimmen, welche Klassen Sie benötigen (insbesondere solche, die nicht auf Objekten der realen Welt basieren) und wie sie mit den einzelnen interagieren andere?

Insbesondere interessiert mich, welche Methoden Sie anwenden? Was ist der Prozess, dem Sie folgen, der normalerweise ein gutes, klares Design ergibt, das das Endprodukt genau wiedergibt?

225
Victor

Die Schritte, die ich für das anfängliche Design verwende (um zu einem Klassendiagramm zu gelangen), sind:

  1. Erfassung von Anforderungen. Sprechen Sie mit dem Kunden und klären Sie die Anwendungsfälle ab, welche Funktionalität die Software haben soll.

  2. Verfassen Sie eine Darstellung der einzelnen Anwendungsfälle.

  3. Gehen Sie die Erzählung durch und markieren Sie Substantive (Person, Ort, Sache) als Kandidatenklassen und Verben (Aktionen) als Methoden/Verhaltensweisen.

  4. Verwerfen Sie doppelte Substantive und schließen Sie gemeinsame Funktionen aus.

  5. Erstellen Sie ein Klassendiagramm. Wenn Sie ein Java -Entwickler sind, verfügt NetBeans 6.7 von Sun über ein UML-Modul, das sowohl Diagramm- als auch Round-Trip-Engineering ermöglicht und KOSTENLOS ist. Eclipse (eine Open Source Java IDE) hat ebenfalls ein Modellierungsframework, aber ich habe keine Erfahrung damit. Vielleicht möchten Sie auch ArgoUML ausprobieren, ein Open-Source-Tool.

  6. Wenden Sie OOD-Prinzipien an, um Ihre Klassen zu organisieren (berücksichtigen Sie die allgemeinen Funktionen, erstellen Sie Hierarchien usw.).

190
Scott Davies

Ich habe noch nicht genug Ruf, um Kommentare abzugeben (bin heute beigetreten), oder ich möchte nur die Antwort von Scott Davies kommentieren. Hinzufügen zu dem, was er zu sagen hatte:

  1. Stellen Sie unbedingt sicher, dass Sie wissen, worum es in Ihrem Programm geht, bevor Sie beginnen. Was ist dein Programm? Was wird es nicht tun? Welches Problem versucht es zu lösen?

  2. Ihr erster Satz von Anwendungsfällen sollte nicht eine Wäscheliste von allem sein, was das Programm irgendwann tun wird. Beginnen Sie mit dem kleinsten Satz von Anwendungsfällen, die Sie entwickeln können und die immer noch das Wesentliche dessen erfassen, wofür Ihr Programm gedacht ist. Für diese Website sind die wichtigsten Anwendungsfälle beispielsweise Anmelden , Eine Frage stellen , eine Frage beantworten und Fragen und Antworten anzeigen . Nichts über Reputation, Abstimmung oder das Community-Wiki, nur die Essenz dessen, wonach du drehst.

  3. Wenn Sie sich potenzielle Klassen überlegen, denken Sie nicht nur daran, für welches Substantiv sie stehen, sondern welche Verantwortlichkeiten sie haben. Ich habe festgestellt, dass dies die größte Hilfe ist, um herauszufinden, wie sich Klassen während der Programmausführung zueinander verhalten. Es ist einfach, Beziehungen zu entwickeln wie "ein Hund ist ein Tier" oder "ein Welpe hat eine Mutter". Normalerweise ist es schwieriger, Beziehungen zu ermitteln, die Laufzeitinteraktionen zwischen Objekten beschreiben. Die Algorithmen Ihres Programms sind mindestens so wichtig wie Ihre Objekte, und sie sind viel einfacher zu entwerfen, wenn Sie die Aufgaben der einzelnen Klassen genau definieren.

  4. Sobald Sie diese minimalen Anwendungsfälle und Objekte haben, können Sie mit dem Codieren beginnen. Holen Sie sich etwas, das tatsächlich so schnell wie möglich ausgeführt wird, obwohl es nicht viel bringt und wahrscheinlich beschissen aussieht. Es ist ein Ausgangspunkt und zwingt Sie, Fragen zu beantworten, die Sie möglicherweise auf Papier beschönigen.

  5. Gehen Sie jetzt zurück und wählen Sie weitere Anwendungsfälle aus, schreiben Sie auf, wie sie funktionieren, ändern Sie Ihr Klassenmodell und schreiben Sie mehr Code. Nehmen Sie wie bei Ihrem ersten Schnitt so wenig Zeit wie möglich, während Sie noch etwas Bedeutendes hinzufügen. Spülen und wiederholen.

Nur meine zwei Cent. Hoffentlich ist es nützlich.

65
Darryl

Wenn ich die Chance hatte, verwende ich normalerweise die sogenannte "Drei-Iterationen-Regel".

In der ersten Iteration (oder beim Start) entwerfe ich das allgemeine Layout der Anwendung entsprechend den Modellobjekten, den Algorithmen und den erwarteten (wirklich erwarteten, nicht vielleicht erwarteten ) zukünftige Richtungen. Ich schreibe keine Designdokumente, aber wenn ich mehrere Personen koordinieren muss, ist natürlich eine grobe Skizze des Verfahrens erforderlich, zusammen mit einer Analyse der Abhängigkeiten und einer Schätzung der benötigten Zeit. Versuchen Sie, diese Phase auf ein Minimum zu beschränken, wenn Sie wie ich eine agilere Methode bevorzugen. Es gibt Fälle, in denen eine starke Entwurfsphase erforderlich ist, insbesondere wenn alles über die Logik Ihres Programms bekannt und wahr ist und wenn Sie vorhaben, viele Interaktionen zwischen Funktionen in Ihrem Code durchzuführen. In diesem Fall sind Use Cases oder User Stories eine gute Idee, insbesondere für GUI-Apps. Versuchen Sie, für Befehlszeilen-Apps und insbesondere für Bibliotheken "Programmgeschichten" zu schreiben, in denen Sie Code für die Bibliothek verwenden, die Sie entwickeln müssen, und überprüfen Sie, wie sie aussieht. Diese Programme werden zu Funktionstests Ihrer Bibliothek, wenn sie abgeschlossen sind.

Nach dieser ersten Iteration haben Sie ein besseres Verständnis dafür, wie die Dinge zusammenwirken, haben die Details und die rauen Stellen herausgefunden und Probleme mit einem angeschlagenen Klebeband-Patch behoben. Sie sind bereit, diese Erfahrung zu nutzen, um zu verbessern, zu bereinigen, zu polieren, zu teilen, zu fragmentieren, Entwurfsmuster zu definieren und zu verwenden, Leistungsengpässe und nicht triviale Sicherheitsprobleme zu analysieren. Im Allgemeinen haben all diese Änderungen einen großen Einfluss auf die von Ihnen erstellten Komponententests, jedoch nicht auf die Funktionstests.

Wenn Sie diese zweite Iteration abschließen, erhalten Sie ein kleines Juwel, das gut getestet, gut dokumentiert und gut gestaltet ist. Jetzt haben Sie sowohl die Erfahrung als auch den Code, um die dritte Iteration durchzuführen, zu erweitern. Sie werden neue Funktionen und Anwendungsfälle hinzufügen, um Ihre Anwendung zu verbessern. Sie werden raue Stellen finden und schließlich eine vierte Iteration eingeben, die der zweiten analog ist. Spülen und wiederholen.

Dies ist meine allgemeine Herangehensweise an das Software-Design. Es ähnelt dem Spiraldesign mit kurzen, dreimonatigen Iterationen und Elementen der agilen Entwicklung, mit denen Sie die Probleme kennenlernen und Ihre Software und ihren Anwendungsbereich kennenlernen können. Natürlich ist es eine Frage der Skalierbarkeit. Wenn also die Anwendung so groß ist, dass Hunderte von Entwicklern daran beteiligt sind, sind die Dinge etwas komplexer, aber am Ende denke ich, dass die Idee immer dieselbe ist teile et impera .

Also zusammenfassend:

  1. In Iteration eins bekommt man einen Vorgeschmack und lernt
  2. In Iteration 2 bereinigen Sie Ihr Produkt und bereiten es für die Zukunft vor
  3. In Iteration 3 fügen Sie neue Funktionen hinzu und erfahren mehr
  4. gehe zu 2
19
Stefano Borini

Die interessanteste mir bekannte Quelle dazu ist Teil D von Object Oriented Software Construction, 2. Auflage von Bertrand Meyer.

Teil D: Objektorientierte Methodik: Methode gut anwenden

19: Zur Methodik, 20: Entwurfsmuster: Interaktive Systeme mit mehreren Anzeigetafeln, 21: Vererbungsfallstudie: "Rückgängig" in einem interaktiven System, 22: Wie finde ich die Klassen? , 23: Prinzipien der Klassengestaltung, 24: Vererbung gut nutzen, 25: Nützliche Techniken, 26: Sinn für Stil, 27 : Objektorientierte Analyse, 28: Der Softwarekonstruktionsprozess, 29: Unterrichten der Methode

Interessanterweise ist das Kapitel 22. So finden Sie die Klassen online verfügbar.

16
Daniel Daranas

Es ist oft wiederholt, aber völlig wahr - verstehen Sie Ihre Daten.

Für OOP Ihre Klassen sollten wichtige Informationen beschreiben und wie sie interagieren.

Wenn Sie ein mentales Modell haben, das das Verhalten und die Lebensdauer der Daten gut beschreibt, können Sie Ihre Klassen problemlos aufteilen.

Dies ist einfach eine Erweiterung von: Wissen Sie genau, was Sie versuchen zu tun.

12
Dave Gamble

Versuchen Sie es mit einer verhaltensorientierten Entwicklung. Es wird schwierig sein, Ihre alten Gewohnheiten zu brechen, aber ich habe festgestellt, dass BDD wirklich die beste Wahl ist, wenn es darum geht, sich in der realen Welt zu entwickeln.

http://behaviour-driven.org/

10
Eric the Red

Das Problem bei großen Projekten ist, dass Sie nicht alle Interaktionen zwischen Komponenten überwachen können. Es ist daher wichtig, die Komplexität des Projekts zu reduzieren. Klassen- und Sequenzdiagramme sind für diese Entwurfsphase zu detailliert.

Versuchen Sie zunächst, von einer höheren Abstraktionsebene aus zu denken. Denken Sie über Hauptkomponenten und ihre Verantwortlichkeiten nach (ihre Schnittstelle zu anderen Komponenten), und lassen Sie sich von einigen Architekturmustern inspirieren (nein, keine Entwurfsmuster, diese sind zu niedrig! MVC und Multi-Tier sind Beispiele für Architekturmuster). Für einigermaßen große Projekte sollte eine solche Ansicht etwa 3 bis 5 Komponenten haben.

Erst dann zoomen Sie in ein bestimmtes Bauteil und versuchen, dieses zu gestalten. Jetzt sind wir auf der Ebene der Entwurfsmuster und Klassendiagramme. Versuchen Sie, sich auf diesen Teil des Projekts zu konzentrieren. Wenn Sie feststellen, dass Sie einer der anderen Komponenten eine Verantwortung hinzufügen müssen, fügen Sie sie einfach Ihrer Dokumentations-/Aufgabenliste hinzu. Verschwenden Sie keine Zeit damit, über die Auswirkungen nachzudenken, die sich an diesem Punkt viel zu schnell ändern. Überprüfen Sie, wenn das Design solider ist.

Sie müssen zu diesem Zeitpunkt nicht jede Komponente vollständig entwerfen, obwohl es wahrscheinlich ratsam ist, über einen Code zu verfügen, der die nicht implementierte Komponentenschnittstelle implementiert und einfache, aber nützliche Antworten generiert. Auf diese Weise können Sie jeweils eine Komponente entwickeln (und konstruieren) und in angemessenem Umfang testen.

Wenn neue Komponenten fertiggestellt sind, sollten Sie natürlich testen, wie (und ob) sie sich integrieren, bevor Sie fortfahren.

Kurz gesagt: Nehmen Sie das OO und das Prinzip des Versteckens von Informationen und heben Sie es auf eine andere Ebene!


PS: Zeichne viel, während du entwirfst, es ist wie echte Architektur!

PPS: Versuchen Sie, sich der Sache aus verschiedenen Blickwinkeln anzunähern, über den Tellerrand hinauszudenken (obwohl dies möglicherweise der richtige Weg ist). Diskussionen mit Kollegen können dabei sehr nützlich sein ... und Sie haben beim Mittagessen etwas zu besprechen.

8
NomeN

Die Technik, die ich in realen Projekten mit zumutbarem Erfolg eingesetzt habe, ist Responsibility Driven Design, inspiriert von Wirfs-Brocks Buch.

Beginnen Sie mit den User Stories der obersten Ebene und skizzieren Sie mit Kollegen an einem Whiteboard die Interaktionen auf hoher Ebene, die sie implizieren. Dies gibt Ihnen einen ersten Überblick über die großen Module. und ein oder zwei Wiederholungen eines CRC-Karten-ähnlichen Spiels sollten Sie eine Liste der Hauptkomponenten stabilisiert haben, was sie tun und wie sie interagieren.

Wenn eine der Verantwortlichkeiten groß oder komplex ist, verfeinern Sie diese Module, bis Sie Dinge haben, die klein und einfach genug sind, um Objekte zu sein, indem Sie die Interaktionen innerhalb des Moduls für jede der Hauptoperationen ausspielen, die durch die Interaktionen der höheren Ebenen identifiziert werden .

Zu wissen, wann aufzuhören ist eine Frage des Urteils (die nur mit Erfahrung einhergeht).

7
Steve Gilham

Designmuster

Kreative Entwurfsmuster

Singleton - Stellen Sie sicher, dass nur eine Instanz einer Klasse erstellt wird, und stellen Sie einen globalen Zugriffspunkt für das Objekt bereit.

Factory (Vereinfachte Version der Factory-Methode) - Erstellt Objekte, ohne die Instanziierungslogik für den Client verfügbar zu machen, und verweist über eine gemeinsame Schnittstelle auf das neu erstellte Objekt.

Factory-Methode - Definiert eine Schnittstelle zum Erstellen von Objekten, lässt Unterklassen jedoch entscheiden, welche Klasse instanziiert werden soll, und verweist über eine gemeinsame Schnittstelle auf das neu erstellte Objekt.

Abstract Factory - Bietet die Schnittstelle zum Erstellen einer Familie verwandter Objekte, ohne deren Klassen explizit anzugeben.

Builder - Definiert eine Instanz zum Erstellen eines Objekts, lässt jedoch Unterklassen entscheiden, welche Klasse instanziiert werden soll, und ermöglicht eine genauere Steuerung des Konstruktionsprozesses.

Prototyp - Geben Sie die Arten von Objekten an, die mithilfe einer prototypischen Instanz erstellt werden sollen, und erstellen Sie neue Objekte, indem Sie diesen Prototyp kopieren.

Verhaltensmuster

Verantwortungskette - Es wird vermieden, dass der Absender einer Anfrage an den Empfänger angehängt wird, so dass andere Objekte die Möglichkeit haben, die Anfrage ebenfalls zu bearbeiten. - Die Objekte werden zu Teilen einer Kette, und die Anforderung wird von einem Objekt zu einem anderen über die Kette gesendet, bis eines der Objekte sie verarbeitet.

Befehl - Kapselung einer Anforderung in ein Objekt. Ermöglicht die Parametrisierung von Clients mit unterschiedlichen Anforderungen. Ermöglicht das Speichern der Anforderungen in einer Warteschlange.

Interpreter - Definieren Sie für eine gegebene Sprache eine Darstellung für ihre Grammatik zusammen mit einem Interpreter, der die Darstellung zum Interpretieren von Sätzen in der Sprache verwendet

Iterator - Bieten Sie eine Möglichkeit, nacheinander auf die Elemente eines aggregierten Objekts zuzugreifen, ohne die zugrunde liegende Darstellung preiszugeben.

Mediator - Definieren Sie ein Objekt, das die Interaktion einer Gruppe von Objekten zusammenfasst. Mediator fördert die lose Kopplung, indem es verhindert, dass Objekte explizit aufeinander verweisen, und ermöglicht es Ihnen, ihre Interaktion unabhängig voneinander zu variieren.

Beobachter - Definieren Sie eine Eins-zu-Viele-Abhängigkeit zwischen Objekten, sodass alle abhängigen Objekte automatisch benachrichtigt und aktualisiert werden, wenn ein Objekt den Status ändert.

Strategie - Definieren Sie eine Familie von Algorithmen, kapseln Sie sie und machen Sie sie austauschbar. Mit der Strategie kann der Algorithmus unabhängig von den Clients variieren, die ihn verwenden.

Template-Methode - Definieren Sie das Grundgerüst eines Algorithmus in einer Operation, indem Sie einige Schritte auf Unterklassen verschieben. Mit Template-Methode können Unterklassen bestimmte Schritte eines Algorithmus neu definieren, ohne dass sie die Struktur des Algorithmus ändern können.

Besucher - Stellt eine Operation dar, die für die Elemente einer Objektstruktur ausgeführt werden soll. Mit "Besucher" können Sie eine neue Operation definieren, ohne die Klassen der Elemente zu ändern, für die sie ausgeführt werden.

Null-Objekt - Geben Sie ein Objekt als Ersatz für das Fehlen eines Objekts eines bestimmten Typs an./Das Null-Objektmuster bietet intelligentes Verhalten, bei dem die Details vor den Mitarbeitern verborgen bleiben.

Strukturelle Entwurfsmuster

Adapter - Konvertiert die Schnittstelle einer Klasse in eine andere Schnittstelle, die von Clients erwartet wird. Mit/Adapter können Klassen zusammenarbeiten, was sonst wegen inkompatibler Schnittstellen nicht möglich wäre.

Brücke - Objekte in Baumstrukturen zusammenstellen, um Teil-Ganz-Hierarchien darzustellen. Mit/Composite können Clients einzelne Objekte und Kompositionen von Objekten einheitlich behandeln.

Zusammengesetzt - Objekte in Baumstrukturen zusammensetzen, um Teil-Ganz-Hierarchien darzustellen. Mit/Composite können Clients einzelne Objekte und Kompositionen von Objekten einheitlich behandeln.

Dekorateur - fügen Sie einem Objekt dynamisch zusätzliche Verantwortlichkeiten hinzu.

Fliegengewicht - Verwenden Sie die Freigabe, um eine große Anzahl von Objekten zu unterstützen, die einen Teil ihres internen Zustands gemeinsam haben, wobei der andere Teil des Zustands variieren kann.

Memento - Erfassen Sie den internen Zustand eines Objekts, ohne die Kapselung zu verletzen, und stellen Sie so ein Mittel zur Verfügung, um das Objekt bei Bedarf in den Ausgangszustand zurückzusetzen.

Proxy - Geben Sie einen "Platzhalter" für ein Objekt ein, um Verweise darauf zu steuern.

7
Sauron

Ich würde Ihnen empfehlen, BlueJ und auch ActiveWriter zu verwenden, um zu lernen und auch ein gutes Verständnis für Objekte zu entwickeln. Das empfohlene Buch ist auch eine nette Ressource.

Aus Wikipedia :

alt text

BlueJ ist eine integrierte Entwicklungsumgebung für die Programmiersprache Java), die hauptsächlich für Unterrichtszwecke entwickelt wurde, aber auch für die Entwicklung kleinerer Software geeignet ist.

Außerdem verwendet es UML und für mich war es eine gute Ressource, um einige Dinge über das Modellieren von Objekten zu verstehen.

Alternativtext http://www.ryanknu.com/ryan/bluej.png

ActiveWriter ist ein Tool zum Modellieren von Entitäten und Beziehungen, es generiert auch Code und ist leicht zu ändern. Das spart Ihnen Zeit und ist für eine agile Entwicklung sehr gut geeignet.

alt text
(Quelle: altinoren.com )

4
Nelson Miranda

Zitiere einfach http://www.fysh.org/~katie/computing/methodologies.txt

Und das Herzstück von RUP ist ein kleiner Bereich, in dem Sie OO=) Designtalente einsetzen müssen. Wenn Sie nicht über diese verfügen, ist dies wie eine Methodik zum Laufen der 100 m.

"Schritt 1: Schreiben Sie über das schnelle Laufen. Schritt 2: Zeichnen Sie einen Plan für die Rennstrecke. Schritt 3: Gehen Sie und kaufen Sie sehr enge Lycra-Shorts. Schritt 4: Laufen Sie sehr, sehr, sehr schnell. Schritt 5: Überqueren Sie zuerst die Linie "

Es ist dieser Schritt 4, der schwierig ist. Aber wenn Sie viel Wert auf 1,2,3 und 5 legen, wird das möglicherweise niemand bemerken, und dann könnten Sie wahrscheinlich eine Menge Geld verdienen, indem Sie die Methode an Athleten verkaufen, die glauben, dass es ein "Geheimnis" gibt, 100 m zu sein Läufer vorbei

4
martin

Vor allem - Design sollte aus Ihrer Seele kommen. Sie müssen es an jeder Faser spüren. Normalerweise gehe ich zwei oder drei Monate runter, bevor ich anfange etwas zu tun. Und denken. Gehen ist eine gute Meditation, wissen Sie. So können Sie sich gut konzentrieren.

Zweitens: Verwenden Sie OOP und Klassen nur dort, wo eine natürliche Objekthierarchie existiert. Fügen Sie diese nicht künstlich ein. Wenn keine strenge Hierarchie existiert (wie in den meisten Geschäftsanwendungen), gehen Sie für prozedurale/funktionale oder verwenden Sie Objekte zumindest nur als Datencontainer mit isolierten Zugriffsmethoden.

Und das letzte - versuchen Sie dies zu lesen: Der Algorithmus des kreativen Denkens

4
Thevs

Sie haben eine Frage gestellt, die viele Autoren verwenden, um ein Buch zu schreiben. Es gibt eine Reihe von Methoden, und Sie sollten eine auswählen, die Ihnen "am schönsten" erscheint.
Ich kann das Buch "Domain Driven Design" von Eric Evans empfehlen. Überprüfen Sie auch site dddcommunity.org .

4
zendar

Ich denke, die Antwort hier sollte sehr unterschiedlich sein, abhängig von der realen Erfahrung des fragenden Mannes.

Wenn Sie nur ein oder zwei Jahre Berufserfahrung haben, müssen Sie zu dem Punkt gehen, der ist: wie Kommen Sie zu dem Punkt, an dem Sie Ihre Daten wirklich kennen und genau verstehen, was Sie versuchen zu tun?

Ja, wenn Sie mehr als 5 Jahre in der realen Welt gearbeitet haben, haben Sie die Wahl zwischen einem der vielen Modelle oder Techniken für Softwareentwicklungsprozesse.

Erfahrung macht man aber nicht, wenn man nur Bücher liest. Sie sollten lernen, indem Sie in einer guten Gruppe unter einer guten Führung arbeiten.

Wenn das nicht möglich ist, sollten Sie es einfach selbst tun. Beginnen Sie mit der Iteration, indem Sie einen wahrscheinlich sehr unangenehmen Teil des Codes codieren, Ihre Fehler lernen, alles ausgeben, einen besseren Code codieren und so weiter.

Sie werden viel über Ihre Codebasis lernen. Die Werkzeuge sind Werkzeuge, sie werden dir nichts beibringen.

3
IlDan

Wenn Sie über Fachkenntnisse in Bezug auf das Projekt verfügen, werden Sie beispielsweise an Bankgeschäften arbeiten. Es ist einfach, Ihre Objekte zu strukturieren, und Sie wissen, wie sich diese Verbesserungen jeden zweiten Tag auswirken.

Wenn Sie nicht über dieses Fachwissen verfügen, arbeiten Sie mit jemandem zusammen, der über dieses Fachwissen verfügt, und setzen Sie diese Ideen in technische Details um.

Wenn Sie sich nicht sicher sind, wie Sie Ihr Projektdesign strukturieren sollen. Folgen Sie BLINDLY dem Buch "Pragmatic Programmer". Ich war vorher in der gleichen Situation und habe versucht, ein Kapitel aus diesem Buch zu lesen. Sie werden den Unterschied sehen. Es wird die Art und Weise verändern, wie Sie als Softwareentwickler denken.

3
Broken Link

Ich benutze Test-Driven Design (TDD). Wenn Sie den Test zuerst schreiben, werden Sie zu einem sauberen und korrekten Design geführt. Siehe http://en.wikipedia.org/wiki/Test-driven_development .

2
David Allen
  1. design Patterns lernen & beherrschen.
  2. Als Nächstes lernen Sie das domänengesteuerte Design kennen
  3. Danach lernen Sie die Anforderungserfassung

Ich habe vor ein paar Semestern einen OOD-Kurs besucht und viel daraus gelernt. B. UML schreiben und Anforderungsdokumente in Objekte und Klassen übersetzen. Wir haben auch Sequenzdiagramme gelernt, aber irgendwie habe ich die Vorlesung verpasst oder so, sie sind nicht wirklich bei mir geblieben.

  1. Sie kennen den Schritt 3. Sie müssen ihn meistern. Ich meine, durch viel Übung, um es zu deiner zweiten Natur zu machen. Das liegt daran, dass die Methode, die Sie lernen, einfach gegen die Art und Weise ist, wie wir sie früher hatten. Also musst du es wirklich meistern. Andernfalls kehren Sie immer zu Ihrer ursprünglichen Arbeitsweise zurück. Das ist irgendwie wie bei Test Driven Process, wo viele Java Entwickler es nach ein paar Versuchen aufgeben. Es sei denn, sie beherrschen es vollständig, sonst ist es nur eine Last für sie

  2. Schreiben Sie Use Cases, insbesondere für Alternativkurse. Der Alternativkurs belegt mehr als 50% unserer Entwicklungszeit. Normalerweise, wenn Ihr PM Ihnen eine Aufgabe zuweist, zum Beispiel ein Anmeldesystem zu erstellen, wird er denken, dass es einfach ist, Sie können sich einen Tag Zeit nehmen, um es abzuschließen. Er berücksichtigt jedoch niemals, dass Sie Folgendes berücksichtigen müssen: 1. Was passiert, wenn der Benutzer das falsche Passwort eingibt? 2. Was passiert, wenn der Benutzer das falsche Passwort dreimal eingibt? 3. Was passiert, wenn der Benutzer den Benutzernamen nicht eingibt? Sie müssen sie auflisten und Ihrem Ministerpräsidenten zeigen. Bitten Sie ihn, die Frist zu verschieben.

2
janetsmith

Ich fürchte, das ist keine Antwort Leute hören gerne. Wie auch immer, lassen Sie mich meine Meinung äußern.

OOP sollte als eines der Paradigmen angesehen werden, nicht als übergeordnetes Paradigma. OOP ist gut für die Lösung bestimmter Probleme, wie die Entwicklung einer GUI-Bibliothek. Es passt auch in den Stil der Softwareentwicklung, der normalerweise von großen Softwareunternehmen befolgt wird - einem Elite-Team von Designern) oder Architekten legt das Software-Design in UML-Diagrammen oder einem ähnlichen Medium fest, und ein weniger erfahrenes Team von Entwicklern übersetzt dieses Design in Quellcode. OOP bieten wenig Nutzen, wenn Sie alleine oder mit einem kleinen Team hochbegabter Programmierer arbeiten. Dann ist es besser, eine Sprache zu verwenden, die mehrere Paradigmen unterstützt und Ihnen hilft, schnell einen Prototypen zu erstellen. Python , Ruby, LISP/Scheme usw. stellen eine gute Wahl dar. Der Prototyp ist Ihr Design. Dann verbessern Sie das. Verwenden Sie das Paradigma, das zur Lösung des vorliegenden Problems am besten geeignet ist. Optimieren Sie bei Bedarf Hotspots mit in C oder einem anderen geschriebenen Erweiterungen Durch die Verwendung einer dieser Sprachen erhalten Sie auch Erweiterbarkeit kostenlos, nicht nur beim Programmierer Ebene, sondern auch auf Benutzerebene. Sprachen wie LISP können dynamisch Code generieren und ausführen, was bedeutet, dass Ihre Benutzer die Anwendung erweitern können, indem sie kleine Codeausschnitte in der Sprache schreiben, in der die Software selbst codiert ist! Wenn Sie das Programm in C oder C++ schreiben möchten, sollten Sie einen Interpreter für eine kleine Sprache wie Lua einbetten. Stellen Sie Funktionalitäten als Plugins zur Verfügung, die in dieser Sprache geschrieben sind.

Ich denke, dass die meiste Zeit OOP und OOD Software erstellen, die Opfer von übermäßigem Design sind.

Zusammenfassend ist meine bevorzugte Art, Software zu schreiben:

  1. Verwenden Sie eine dynamische Sprache.
  2. Schreiben Sie den Entwurf (Prototyp) in dieser Sprache.
  3. Optimieren Sie gegebenenfalls bestimmte Bereiche mit C/C++.
  4. Stellen Sie die Erweiterbarkeit über den Interpreter der Implementierungssprache selbst bereit.

Mit der letzten Funktion kann sich die Software problemlos an bestimmte Benutzeranforderungen (einschließlich meiner!) Anpassen.

2
Vijay Mathew

Lernen Sie Designmuster . Es war meine persönliche Revolution in den letzten zwei Jahren in Bezug auf OOP. Holen Sie sich ein Buch. Ich würde dir dieses empfehlen:

Head First Design Patterns

Es ist in Java aber es kann auf jede Sprache erweiterbar sein.

2
David Espart

Im Ernst, ein guter Schritt wäre es, sich mit Flussdiagrammen und Ablaufdiagrammen zu befassen. Es gibt eine Menge guter Websites, die Ihnen zeigen, wie es geht. Ich finde es von unschätzbarem Wert, wenn ich mir anschaue, wie ich ein Programm in Klassen aufteilen möchte, da ich genau weiß, was das Programm eingeben, berechnen und ausgeben muss, und jeder Schritt in einen Teil des Programms zerlegt werden kann.

1
user133018
1
ChrisW

Während meiner Abenteuer beim Entwerfen von Klassenstrukturen habe ich festgestellt, dass es sehr hilfreich ist, mit dem Schreiben von Pseudocode zu beginnen. Das heißt: Ich beginne mit dem „Schreiben“ einiger allgemeiner Fragmente des Anwendungscodes auf höchster Ebene, spiele damit und entdecke die Elemente, die auftauchen - tatsächlich die Elemente, die ich - als Programmierer - verwenden möchte. Es ist ein sehr guter Ausgangspunkt für das Entwerfen der allgemeinen Struktur von Modulen und ihrer Interaktionen. Nach wenigen Iterationen sieht die gesamte Struktur eher wie ein vollständiges Klassensystem aus. Es ist eine sehr flexible Möglichkeit, Codeteile zu entwerfen. Sie können es als programmiererorientiertes Design bezeichnen.

1
Darius

Eine nützliche Technik besteht darin, Ihre einzigartige Problembeschreibung mit etwas in Beziehung zu setzen, das Sie in der realen Welt finden können. Sie modellieren beispielsweise ein komplexes Gesundheitssystem, das die Welt im Sturm erobern wird. Gibt es Beispiele, auf die Sie gerne zurückgreifen können, um dies zu modellieren?

Tatsächlich. Beobachten Sie, wie die Seitenapotheke oder das Arztzimmer funktionieren würde.

Bringen Sie Ihr Domain-Problem auf etwas, das für Sie verständlich ist. etwas, worauf Sie sich beziehen können.

Sobald die "Player" innerhalb der Domain offensichtlich werden und Sie beginnen, Ihren Code zu modellieren, entscheiden Sie sich für einen "Provider-Consumer" -Modellierungsansatz, dh Ihr Code ist der "Provider" des Modells, und Sie) sind die "Verbraucher".

Sich auf die Domäne zu beziehen und sie auf hohem Niveau zu verstehen, ist ein wesentlicher Bestandteil jedes Designs.

1
Mike J