Der erste Schritt wäre stets, das Problem zu erfassen, welches folgend gelöst werden soll. Ob es hierbei nun darum geht, ein komplettes Programm zu entwickeln oder nur um die Entwicklung einer einzigen Funktion in einem Programm, ist an der Stelle egal. Beschreibe also zuerst, in Kurzform (Stichpunkte / wenige Sätze), was du überhaupt erreichen möchtest. Dabei kann man zusätzliche Informationen, wie den aktuellen Zustand mit hineinnehmen, wenn man es als hilfreich empfindet.
Solltest du dabei mit dir unbekannten Themen konfrontiert sein, müsstest du dich in diese erst hineinarbeiten. Wolltest du beispielsweise einen Konverter entwickeln, der Dezimalzahlen in eine Form des Binärsystems umwandelt, müsstet du erst wissen, wie diese Zahlensysteme überhaupt funktionieren und wie der mathematische Weg zur Umwandlung aussieht.
Der zweite Schritt wäre eine Ausarbeitung und der Beginn einer Aufteilung. Vor allem wenn es um ein komplexes Problem geht, welches in seiner Rohform noch zu abstrakt ist, als dass man es direkt lösen könnte, muss man schauen, dass man es zergliedern kann. So oft, bis man konkrete, fassbare Teilaufgaben vor sich hat, mit denen zusammengenommen sich das Gesamtziel erreichen lässt.
Ein sehr einfaches, bildhaftes Beispiel dafür wäre die Ausgabe eines beliebig großen Vierecks mit einem beliebigen Zeichen in der Konsole. So ein Viereck besteht aus mehreren Reihen und Spalten. Insofern kann man erst schauen, wie man eine Reihe ausgibt und noch davor, wie man überhaupt eine Spalte zeichnet.
void printColumn(char symbol) {
System.out.print(symbol);
}
void printRow(char symbol, int width) {
for (int x = 0; x < width; ++x) {
printColumn(symbol);
}
System.out.println();
}
void printRectangle(char symbol, int width, int height) {
for (int y = 0; y < height; ++y) {
printRow(symbol, width);
}
}
Es setzt in diesem Beispiel natürlich auch etwas voraus, dass zumindest ein paar Implementationen (siehe print, println) aus der Standard-API bereits bekannt sind, damit man nicht wirklich alles versucht, neu zu erfinden. Bei bestimmten Herausforderungen sollte man daher ebenso eine kurze Recherche in Erwägung ziehen, ob es nicht schon fertige Lösungen gibt. Mathematische Funktionen (log, pow, sin, ...) oder String-Operationen (reverse, substring, ...) sind typische Beispiele.
Die Umstellung in ein recht striktweises Denken ist zugegeben nicht immer einfach. Für Programmiereinsteiger ist es vor allem ungewohnt, da der Mensch an sich sprachlich Operationen meist zusammenfasst. Eine Aktion wie laufen ist für uns alle verständlich. Für den Computer ist es eine komplexe Operation, die erst in die einzelnen Muskelbewegungen heruntergebrochen werden müsste.
Ein paar Tipps, die ich bei der Entwicklung von Funktionen/Algorithmen geben könnte, wären diese:
- Suche in der Beschreibung des Problems nach Verben, die notwendige Operationen (also Funktionen) darstellen könnten.
- Überlege dir, was der IST-/Anfangs- und der SOLL-/End-Zustand ist.
- Halte dich möglichst strikt an die Regel, dass jede Funktion nur einem Zweck dient, nicht mehreren.
- Scheue nicht davor zurück, Hilfsfunktionen zu formulieren, wenn eine Operation leicht beschreibbar, aber für sich gesehen dennoch komplex ausfällt. Ein typisches Beispiel wäre eine mathematische Prüfung, ob sich ein Punkt in einem Rechteck befindet. So etwas lässt sich gut auslagern und später an anderer Stelle wiederverwenden.
- Lege dir einen Programmablaufplan an (alternativ ein Struktogramm o.ä. Skizzen - hauptsache es gibt nur einfache Bauteile wie if-else, Deklaration/Definition, Anweisung); Operationen, die noch zu abstrakt/komplex sind, werden in weiteren (eigenen) Diagrammen/Skizzen behandelt.
- Wenn du die Möglichkeit hast, dir Operationen durch Nachstellung bildlich zu machen, dann nutze das (Beispiel: Arrayoperationen wie Tauschen, Sortieren kann man sich mit Karten nachlegen).
- Löse Probleme nie direkt mit Programmcode. Beginne mit einer Übersetzung in Java-Code erst, sobald der Ablauf des Algorithmus bereits (z.B. als Diagramm) feststeht und getestet werden konnte (nimm dir 1-2 konkrete Anwendungsfälle und versuche mit ihnen deinen Plan einmal durchzuspielen, so fallen frühzeitig Logikfehler auf).
- Stelle (Performance-)optimierungen hintenan.
- Vergib für alle Elemente (Variablen, Funktionen, etc.) immer eindeutige, aussagekräftige Namen.
Dazu gibt es eine große Bandbreite an möglichen Aufgaben, an denen sich das Vorgehen üben lässt. Zum Beispiel:
- Berechnung des Produkts zweier Faktoren, ohne den Multiplikationsoperator zu nutzen
- Konversion von Zahlen in unterschiedliche Zahlensysteme (Dezimal-/Oktal-/Hexadezimal-/Binärsystem)
- Addition und Subtraktion beliebiger Brüche
- Berechnung des größten/kleinsten gemeinsamen Teilers zweier Zahlen
- Berechnung der Quersumme einer dreistelligen Zahl
- Berechnung und Ausgabe der ersten zehn Ziffern der Fibonacci-Reihenfolge
- Die Lösung von Problemen gezielt mit Rekursion (Test ob ein Wort einem Palindrom entspricht, Rückwärtsausgabe einer Zeichenfolge, Berechnung der Werte für ein Pascal'sches Dreieck)
- Viele mathematische Rätsel findest du auf Projekt Euler
- Zahlen-raten (eine Zahl zwischen 0 und 1000 wird berechnet, in Folge soll versucht werden, mit möglichst wenigen Arbeitsschritten diese Zahl zu erraten)
- Eigenimplementation von bekannten String-Methoden (z.B. indexOf, replace und replaceAll für einfache Zeichenfolgen, substring)
- Die Implementation von Sortierverfahren (Bubblesort, Selectionsort, Insertionsort, Quicksort) - schau für die jeweiligen Beschreibungen auf Wikipedia
- Überlege dir Methoden, wie man in einer Liste beliebiger Zahlen eine bestimmte Zahl suchen könnte
- Entwicklung eigener Datenstrukturen (ohne dafür die List-Implementationen der Standard-API zu nutzen): Stack (mit peek, pop und push), doppelt verkettete Liste (mit add, insert, remove), eine Queue (mit add, remove), AVL-Baum (mit add, insert, remove), Graph (mit add, insert, remove)
- Binäre Suche für einen binären Baum
- Traversionsverfahren für einen binären Baum (pre-order, in-order, post-order)
- Suche nach dem kürzesten Weg von einem Knoten eines Graph zu einem anderen (die Kanten, die die Knoten verbinden, geben die Entfernung zwischen zwei verbundenen Knoten vor)
- Minispiele oder Simulationen wie Conway's Game Of Life, Türme von Hanoi oder Snake (für die grafische Darstellung kannst du Processing nutzen)
Bei der Entwicklung von komplexen Programmen kommt es oft vor, dass man keinen allgemeinen Hauptprogrammablauf hat und stattdessen ein Bündel verschiedener Anwendungsfälle/Funktionen (vgl. mit MSPaint: Der Nutzer kann das Programm öffnen und verschiedene Aktionen in beliebiger Reihenfolge starten). Zudem ist man meist damit konfrontiert, neben der eigentlichen Anwendungslogik noch eine grafische Oberfläche zu haben, die interaktiv sein muss.
Es ist bei so einem Projekt sinnvoll, in der Analysephase das Programm als eigenständiges System auszuarbeiten, welches sich an objektorientierte Konzepte orientiert.
- Man muss die Anwendungsfälle finden, die in dem System auftreten können (ein use-case-diagram kann hierbei helfen: Erst schaut man, wer das Programm nutzen soll und dann, welche Interessen diese Personengruppe hat bzw. was für Aktionen sie nutzen wird)
- Anhand einer textuellen Beschreibung des Systems (Was tut es? Wer agiert damit?) kann man einmal wieder herausfinden, welcher Objekte es braucht und wie sie miteinander agieren. Ich habe das in diesem Beitrag einmal an dem Spiel Pac-Man ansatzweise gezeigt. Letztendlich lässt sich damit ein Objektdiagramm und anschließend ein Klassendiagramm kreieren (Stichwort: UML)
In der Projektstrukturierung wiederum sollte es klare Aufteilungen geben. Funktionsbündel kann man als eigene Module definieren (Beispiel MSPaint: Es gibt ein Modul zur Speicherung von Bildformaten, ein Modul für Zeichenoperationen, usw.). Die Anwendungslogik sollte generell von der Formulierung der grafischen Oberfläche getrennt sein. Architekturmuster wie MVC, MVP oder MVVM sind dabei ziemlich hilfreich. Generell macht es Sinn, sich zu diesem Thema (Architektur- und Entwurfsmuster) genauer zu belesen.
Hilfreich könnte zudem eine testgesteuerte Entwicklung (test-driven-development/TDD) sein, da sie dich unter anderem stärker dazu drängt, modular zu denken. Recherchiere zu dem Thema einfach einmal.
