In diesem Artikel gehe ich nun weiter im Lernpfad zum Thema der Objektorientierung.
Wenn du deine erste eigene Anwendung geschrieben hast, lernst die Objektorientierte Programmierung kennen. Dieses Thema hört sich so schwierig an und ist doch so einfach, wenn man erst einmal durchgeblickt hat.
Steigst du in die Objektorientierung ein, wirst du alle Strukturen und Ideen in deinem Kopf in ein Programm überführen können.
Ab dieser Stelle geht es nicht mehr alleine um das Eintippen von Quelltext in deine Entwicklungsumgebung.
Hier geht es um richtigen Gehirnschmalz. Ich erkläre dir kurz die wesentlichen Bereiche die du dir aneignen solltest.
Objektorientierte Analyse (OOA)
Was passiert bei der objektorientierten Analyse und wofür ist diese gut? Du willst deine Idee in ein Programm überführen. Das bedeutet, dass du dein Konzept im Kopf irgendwie in deinen Programmcode überführen musst.
Damit du genau weißt, wie deine Idee später im Programmcode aussehen soll, gibt es die objektorientierte Analyse.
Du gehst los und schreibst alle wesentlichen Merkmale deiner Idee auf und zwar bis in das kleinste Detail. Auch hier gibt es wieder verschiedene Techniken um eine ordentliche Analyse zu erhalten.
Als nächstes prüfst du, ob die Merkmale deiner Idee in Klassen passen (Du weißt nicht was eine Klasse ist? Dann aber schnell zurück zu den Grundlagen).
Sobald du anfängst mit Klassen zu arbeiten, bist du bereits im nächsten Schritt, nämlich dem Design deiner Klassenstruktur. Damit du auch später alle Funktionen programmieren kannst, solltest du bereits wissen, welche Funktionen deine Bibliothek bereits zur Verfügung stellt oder zumindest zu diesem Zeitpunkt danach suchen.
Objektorientiertes Design (OOD)
Du weißt anhand deiner Analyse nun ganz genau welche Klassen und Methoden du benötigst und welche davon du schreiben musst.
Nun gilt es das Ganze zu einem Gesamtbild zu gestalten. Dafür wirst du weiter Klassen benötigen. Hier kommen bereits erste objektorientierte Prinzipien zum Vorschein. Denn irgendwann werden Strukturen unhandlich und nicht wartbar.
Wichtig ist hier erstmal ein Gesamtkonzept über dein Programm zu erhalten.
Dieses teilt man auch noch meistens auf in Grob- und Feinkonzept.
Im Grobkonzept sind nur ganz allgemeine Strukturen beschrieben, aber im Feinkonzept geht es richtig ins Detail. Somit weißt du nun was du genau programmieren musst.
Das Gute daran ist: Du kannst während des Designs bereits kleine Prototypen erstellen, um zu sehen ob die Struktur so umsetzbar ist.
Objektorientierte Programmierung (OOP)
Da du nun ein fertiges Design hast, geht es darum dieses mittels einer Programmiersprache einzuprogrammieren. Wenn du dir die richtigen Gedanken gemacht hast ist dieser Schritt fast der einfachste. Allerdings musst du auch immer wieder überprüfen ob dein Programm dann auch wirklich das tut was es soll. Hier greifst du auf die Grundlagen zurück die du im Vorfeld gelernt hast. Nicht nur die Grundelemente der Hochsprachen sind hier wichtig. Hier benötigt bereits das Wissen über Klassen und Objekte und genauso das Wissen über die Bibliothek, die du verwendest. Außerdem können Klassen miteinander arbeiten oder können Eigenschaften voneinander erben. Diese Dinge musst du an diesem Punkt bereits anwenden oder dir aneignen können. Bist du hier angekommen, ist deine eigenes richtiges Programm nicht mehr weit oder du hast es bereits geschafft dein Programm zu schreiben, welches du dir vorstellst.
Unit-Testing
Du wirst von Anfang an gemerkt haben. Programme haben Fehler. Egal was du programmierst, irgendwann musst du einen Fehler suchen. In der Objektorientierung versucht man dieses Problem mittels Unit-Tests in den Griff zu bekommen. Dafür wird neben dem eigentlichen Programm ein zusätzliches Testprogramm geschrieben. Für jede Klasse in deinem Programm, gibt es eine passende Testklasse. Das hört sich zwar nach viel Arbeit an, aber ist im Vergleich zu der Zeit wie lange du einen Fehler suchen würdest ein kleiner Bruchteil. Man bekommt so nicht alle Fehler herausgefunden, aber selbst eine Testabdeckung von nur 1% ist besser als gar keine Tests.
Unified Modeling Language (UML)
Diese sogenannte Sprache ist eine Beschreibungssprache, mit der du grafisch Strukturen notieren kannst. Die UML besteht aus einer Sammlung von verschiedenen Diagrammarten. Mit jeder Diagrammart kannst du andere Strukturen dokumentieren. Wofür? Nehmen wir mal das Klassendiagramm. Hiermit kannst du dein objektorientiertes Design grafisch darstellen. Wenn du dann mal mit einem anderen Programmierer über dein Design sprechen willst, versteht er dich sofort, weil er die UML ebenfalls kennt. Es gibt natürlich noch mehr Diagrammarten in der UML.
Das nützliche an der UML ist, dass es Codegeneratoren gibt, mit denen man direkt aus den Diagrammen Programmcode generieren lassen kann. Bevor du nun losrennst um die so ein Werkzeug zu suchen, diese Werkzeuge programmieren nicht für dich, du programmierst dann zum Teil in der UML und in deiner Programmiersprache. Also das ganze ist wirklich nur nützlich für dich, wenn du bereits perfekt programmieren kannst und du UML Diagramme erstellen kannst. Die Arbeit selbst wird dadurch nicht weniger, aber kann dadurch erheblich beschleunigt werden.
Fazit
Bist du an diesem Punkt angekommen und kennst dich in der Objektorientierung aus und genauso so in der UML, kannst du bereits normale Programme schreiben. Wenn du eine konkrete Vorstellung deines Programmes hast, hast du kein Problem dieses umzusetzen. Du kannst dein Programm mittels der UML designen und komplexe Strukturen programmieren. Deine Programme stürzen nicht so oft ab, da du mit Unit-Tests jede deiner Klassen auf die Funktionalität testest. Ab hier gilt es nur noch besser und effizienter zu werden. Wie du siehst, gibt es hier langsam keine neue Grundwerkzeuge mehr. Wie weit bist du? Kommentiere unten den Artikel und lass uns über deinen Lernweg diskutieren!
- Programmiere echte Apps als Anfänger
- Keine Installation, sofort loslegen
- Komplett praxisbezogen
- Zugriff auf Online-Editor
