Methoden, Konstruktoren, Objekte und Beziehung zwischen Objekten.
Allgemeines Beispiel über Methoden, Konstruktoren, Objekte und Beziehung zwischen Objekten.
Zunächst möchte ich mich entschuldigen für die Späte Rückmeldung. Ich musste viel für die Uni tun was mich davon abgehalten hat, einen neuen Beitrag zu halten. Ich werde, wie letztes mal, die Quelldatei auf GitHub Hochladen sodass ihr die Datei problemlos downloaden und kompilieren könnt.
Unsere jetziges Thema bezieht sich, wie ihr es im Überschrift gelesen habt, auf Methoden, Konstruktoren, Objekten und Beziehungen zwischen Objekten. Dazu habe ich ein alltägliches Beispiel ausgesucht was mich extrem Fasziniert hat. Ich hoffe, dass ich euch genau so fasziniere wie ich mich selber.
Das folgende Beispiel Programm bezieht sich auf die Anzeigetafel im Flughafen. Jeder zweite hat schon einmal im Leben mit dem Flugzeug geflogen. Da ich seit meiner Kindheit vom fliegen fasziniert bin, wollte ich einfach spaßeshalber eine Anzeigetafel für Start und Landungen von Flugzeugen programmieren und euch diese präsentieren. Für unsere Beispielprojekt habe ich drei Klassen angelegt. Die erste Klasse ist, was bei Objekt Orientierung ganz Normal ist, die ProjektKlasse welches die Main-Methode beinhaltet. In diese Main-Methode werden die beiden Klassen mit unterschiedlichen Attributwerten aufgerufen. Die zweite Klasse ist für die Abflüge/Departures der Flieger zuständig und die dritte Klasse beschäftigt sich für die Landungen der jeweiligen Flieger. Ich werde wie immer eine Rezension halten und euch die möglichen Ausgabe des Programms ganz am Ende vorstellen. Dieses Programm wird nicht immer die gleichen Ausgaben tätigen da die Werte durch den Zufallsgenerator durchlaufen.
public class Flugzeug {
int ankunftszeit;
boolean gelandet;
double treibstoff;
int nummer;
String bezeichnung;
static int anzahlFlugzeuge = 0;
Flugzeug(){
anzahlFlugzeuge++;
gelandet = false;
double flieger = (2*Math.PI)*(20*Math.random());
nummer = (int)(flieger);
}
Flugzeug(int ankunftszeit, double treibstoff, String bezeichnung){
this();
this.ankunftszeit = ankunftszeit;
this.treibstoff = treibstoff;
this.bezeichnung = bezeichnung;
}
public void ausgabe(){
System.out.println("----------------------------------------------------------------");
System.out.println("Arrival"+ "\t" + "landed" + "\t" + "Fuel" + "\t" + "Gate" + "\t"+"\t" + "Flight");
System.out.println(ankunftszeit + ":00 h\t" + gelandet +"\t" + treibstoff+"%"+"\t" + nummer +"\t" + bezeichnung);
}
public void setgelandet(boolean zustand){
gelandet = zustand;
}
public static int naechsteAntkunftszeit(Flugzeug[] liste){
int min = liste[0].ankunftszeit;
for(int i=1;i<liste.length;i++){
if(liste[i].ankunftszeit < min)
min = liste[i].ankunftszeit;
}
return min;
}
}
Ich möchte einzeln die Klassen durchgehen. Die Klasse Flugzeug ist zuständig, wie ich es oben angedeutet habe, für die Landungen der Flieger zuständig. Als erstes legen wir, wie immer, unsere Klasse Flugzeug fest. Danach deklarieren wir unsere Attribute ankunftszeit, gelandet, treibstoff, nummer, bezeichnung und den Klassenattribut anzahlFlugzeuge deklariert und mit dem Wert 0 initialisiert.
Nach dem wir dies unternommen haben, schreiben wir ein Konstruktor welches kein Parameter beinhaltet. Falls diese Konstruktor ausgelöst wird, wird die Anzahl der Flugzeuge um Eins erhöht. Danach wird der zustand des Flugzeugs auf true gesetzt was bedeutet, dass das Flugzeug gelandet ist. Die Flugzeugnummer wird durch den Zufallsgenerator festgestellt welches innerhalb des Intervalls (2PI*20;0) liegt. Danach wird dieser Wert mithilfe von Typecasting auf ein Integer (int) abgeschnitten. Das heißt, dass der Compiler nur das in die Konsole aufschreibt was vor dem Komma des double Werts ist.
Schließlich programmieren wir den zweiten Konstruktor mit dem Namen Flugzeug diesmal aber mit drei Parameter. Diese Konstruktor erwartet drei Angaben von der Klasse ProjektKlasse. Diese sind die Ankunftszeit, Treibstoffzustand und die Bezeichnung. Alle diese werte werden ebenfalls durch den Zufallsgenerator random() erzeugt und sind unabhängig von unsere Eingabe. Hier kommen natürlich das Schlüsselwort this im Spiel. This unterscheidet die Parameter und Attribute voneinander. Ohne this würde der Compiler Fehler melden da er nicht erkennen kann was was ist.
Wir schreiben als erstes this.ankunftszeit = ankunftszeit; auf. Zur einfacher Veranschaulichung haben die Entwickler von der Entwicklungsumgebungen wie Eclipse, NetBeans etc. die Schriften Farbig gemacht sodass einer, der keine Ahnung vom Programmieren hat die einzelnen Parameter und Attribute voneinander unterscheiden kann. Das Begriff ankunftszeit (BLAU) welches direkt nach dem Schlüsselwort this vorkommt bezieht sich auf das Attribut ankunftszeit. Die Zweite Eingabe ankunftszeit (SCHWARZ) bezieht sich auf den Parameter ankunftszeit welches der Konstruktor Flugzeug von der Klasse ProjektKlasse erwartet. Genau so geht es mit this.treibstoff = treibstoff; und this.bezeichnung = bezeichnung;
Nun was haben wir bis jetzt gemacht? Wir haben unsere Attribute und die Konstruktoren unsere Klasse Flugzeug festgelegt. Da wir eine Tabellenförmige Ausgabe haben möchten, müssen wir eine Methode welches für die Ausgabe zuständig ist programmieren.
Unsere Methode für die Ausgabe lautet ausgabe(). Diese Methode beinhaltet, wie ihr es in der Quelldatei sehen könnt, nur Ausgabebefehle. Die erste Ausgabe beinhaltet lauter Bindestriche. Das habe ich mit Absicht gemacht damit unsere Liste Benutzerfreundlich ist sodass Jeder Passagier auf einen Blick die nötigen Informationen aus der Anzeigetafel ablesen kann. Die zweite Ausgabe beinhaltet die Überschriebe auf Englisch wie Ankunftszeit, gelandet, Treibstoffzustand, Gate... Die Eingaben "\t" sind von Bedeutung. Diese habe ich eingefügt sodass unsere Ausgabe Tabellenförmig ist und schön aussieht. In der dritten und somit unserer letzten Ausgabe werden die Eigentlichen Werte ausgegeben.
Nach dem wir dies unternommen haben, habe ich eine weitere Methode programmiert welches für den Zustand des Fliegers verantwortlich ist. Diese Methode ist vom Typ boolean. Diese Methode wird erst dann ausgeführt, wenn der Konstruktor ohne Parameter ausgeführt wird.
Danach haben wir eine Methode die unsere Ankunfszeit für die Flugzeuge berechnet. Dieses ist vom Typ int und ist static. Was bedeutet, dass wir ein return statement haben. Also diese Methode bekommt einen Wert und liefert ein Ergebnis zurück. Um diese Methode zu verstehen, benötigen wir die Quelldatei vom ProjektKlasse.
Die zweite Klasse FlugzeugDepartures() hat einen ähnlichen Aufbau wie die Klasse Flugzeug und könnt deshalb diese ohne weitere Angaben nachvollziehen.
public class FlugzeugDepartures {
int abflugzeit;
boolean gestartet;
int flugnummer;
String bezeichnung;
String flugort;
int counter;
int gate;
static int anzahlFlugzeuge = 0;
FlugzeugDepartures() {
anzahlFlugzeuge++;
gestartet = false;
double flieger = (3*Math.PI)*(20*Math.random());
flugnummer = (int)(flieger);
}
FlugzeugDepartures(int abflugzeit, String bezeichnung, String flugort, int counter, int gate) {
this();
this.abflugzeit = abflugzeit;
this.bezeichnung = bezeichnung;
this.flugort = flugort;
this.gate = gate;
this.counter = counter;
}
public void ausgabe() {
System.out.println("--------------------------------------------------------------------");
System.out.println("Flight"+"\t"+"Departures"+"\t"+"TakeOff"+"\t"+"FlightTo"+"\t"+"\t"+"Counter"+"\t"+"Gate");
System.out.println("TK1"+flugnummer+"\t"+gestartet+"\t"+"\t"+abflugzeit+":00h\t"+flugort+"\t"+"\t"+"\t"+counter+"\t"+gate);
}
public void setgestartet(boolean zustand) {
gestartet = zustand;
}
public static int naechsteAbflugzeit(FlugzeugDepartures[] liste){
int min = liste[0].abflugzeit;
for(int i=1;i<liste.length;i++){
if(liste[i].abflugzeit < min)
min = liste[i].abflugzeit;
}
return min;
}
}
public class ProjektKlasse {
public static void main(String[] args) {
System.out.println("--------------------------DEPARTURES--------------------------------");
FlugzeugDepartures[] liste = new FlugzeugDepartures[5];
for(int i = 0; i < liste.length; i++) {
int abflugzeit = (int)(25*Math.random());
String bezeichnung = "\t"+"Turkish Airlines TK 761"+i;
double fluortwaaehler = (int)(10*Math.random());
double sollen = (int)(300*Math.random());
int counter = (int)sollen;
double tuer = (int)(10*Math.random());
int gate = (int)tuer;
if(fluortwaaehler == 0) {
String flugort = "Trabzon";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 1) {
String flugort = "Ankara";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 2) {
String flugort = "Ataturk";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 3) {
String flugort = "Bursa";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 4) {
String flugort = "Izmir";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 5) {
String flugort = "Antalya";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 6) {
String flugort = "Adana";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 7) {
String flugort = "Van";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 8) {
String flugort = "Kars";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
else if(fluortwaaehler == 9) {
String flugort = "Erzurum";
liste[i] = new FlugzeugDepartures(abflugzeit, bezeichnung, flugort, counter, gate);
liste[i].ausgabe();
}
}
System.out.println();
System.out.println();
System.out.println();
System.out.println("-------------------------ARRIVALS-------------------------------");
Flugzeug[] liste1 = new Flugzeug[4];
for(int i=0; i<liste1.length; i++){
int ankunftszeit = (int)(25*Math.random());
double treibstoff = ((int)(10001*Math.random()))/100.;
String bezeichnung = "\t"+"Turkish Airlines TK 148" + i;
liste1[i] = new Flugzeug(ankunftszeit, treibstoff, bezeichnung);
liste1[i].ausgabe();
}
}
}
Unsere Klasse ProjektKlasse sieht für die Main-Methoden extrem Lang aus. Aber gute Nachrichten wir haben nichts neues im Code. Alles haben wir schon besprochen. Als erstes legen wir unsere Klasse fest. Danach setzen wir die Main-Methode fest. Mit der Ausgabe (---...--Departures--...---) der Überschrift der Anzeigetafel für die Starts festgestellt. Danach definieren wir eine Eindimensionaler Array mit dem Anzahl an 5 Elementen also vom 5 Flieger. Dann wird eine for Schleife festgelegt welches die Länge des Arrays als Grenzwert beinhaltet. Also startet die For-Schleife ab 0 und zählt bis zu 4 auf. Diese sind die Anzahl der Flieger, die starten werden. Wie vorher gesagt werden alle Angaben/Eigenschaften der Flieger durch den Zufallsgenerator definiert. So die Abflugzeit des Flugzeugs der sich im Intervall [0,24] Stunden befindet. Der Counter Nummer und die Gate Nummer wird ebenfalls mit dem Zufallsgenerator entwickelt. Die Bezeichnung unserer Flugzeug heißt Turkish Airlines TK 761+i mit i = die Anzahl an Flugzeugen die Gelandet worden sind. Ich wollte einfach Arbeit sparen und habe den Flugnummer einfach mit dem i Variable gemacht ansonsten könnte man auch diese durch den Zufallsgenerator laufen lassen. Damit der Flugziel auch unbestimmt ist also nicht vor definiert ist, habe ich eine Liste mit Zehn möcglichen Flugziele entworfen. Falls aus dem Zufallsgenerator einen Wert (int) 0 Rauskommt, so wird das Flugziel (String) nach Trabzon gesetzt. Trabzon ist eine Große Hafenstadt aus der Türkei welches ganz im Osten der Schwarzmeerküste liegt. Die folgenden if und else if Verzeigung hängt davon ab, was aus dem Zufallsgenerator für die Flugziele rauskommt.
Schließlich kommen wir zu unsere Aufrufe der Klasse Flugzeug welches für die Landungen der Flieger zuständig ist. Wir geben drei leere Zeilen aus sodass wir die beiden Anzeigetafeln auseinander setzen können. Danach wird der Überschrift für die Landungen ausgegeben. Wie bei Starts werden alle Parameter mit der Zufallsgenerator festgestellt und an den Konstruktor Flugzeug(...) weitergegeben. Ich hoffe, dass ihr es nicht vergessen habt, was ich euch vorhin gesagt habe.
public static int naechsteAntkunftszeit(Flugzeug[] liste){
int min = liste[0].ankunftszeit;
for(int i=1;i<liste.length;i++){
if(liste[i].ankunftszeit < min)
min = liste[i].ankunftszeit;
}
return min;
}
Diese Methode habe ich euch von der Klasse Flugzeug euch nicht erörtert da ich es erwähnt habe, dass wir den Aufruf dafür benötigen sodass ihr es nachvollziehen könnt. Der Aufruf für diese Methode sieht wie folgt aus:
Flugzeug[] liste1 = new Flugzeug[4];
for(int i=0; i<liste1.length; i++){
int ankunftszeit = (int)(25*Math.random());
double treibstoff = ((int)(10001*Math.random()))/100.;
String bezeichnung = "\t"+"Turkish Airlines TK 148" + i;
liste1[i] = new Flugzeug(ankunftszeit, treibstoff, bezeichnung);
liste1[i].ausgabe();
}
Zunächst wird innerhalb der for-schleife die angaben für den ankunftszeit, treibstoff und bezeichnung generiert. Danach wird der Aufruf der Liste mit dem i-ten Element der for-schleife ausgeführt welches dem Konstruktor die drei Attribute angibt. Danach wird mit dem i-ten Element die Ausgabe für die drei Attribute ausgegeben. Es ist ganz Einfach. Am Anfang hatte ich selber Schwierigkeiten jedoch konnte es mit viel probieren und spielen nachvollziehen. Ladet den Code einfach kostenlos bei Github >>HIER<< herunter und kompiliert diese. Natürlich könnt ihr das Programm so ändern wie ihr wollt oder benutzen wie ihr es gern habt. Hauptsache ihr lernt davon etwas.
Die Ausgabe der Datei sieht wie folgt aus:
Kommentare
Kommentar veröffentlichen