08 Dez

Programmiere ein Bier

Bei einem Kreativwettbewerb im AHOY Berlin hatten wir Stephan Rybarz, Ivan Jovic, Hans Kirchner und Fabian Schurig folgende Aufgabe:

Suche coole Konzepte und Ideen, um absoluten Neulingen die Grundkenntnisse der Programmierung zu vermitteln!

Da die besten Konzepte in einem Lehrbuch abgedruckt werden sollten, entschieden wir uns, unsere Idee in Form eines Romans zu schreiben. Im Vordergrund steht also nicht mehr das Vermitteln von Wissen, sondern der Spaß am Lesen… und ganz nebenbei werden wichtige Konzepte der Programmierung erlernt.

Im folgenden Textbeispiel wollen wir unsere Ergebnisse präsentieren.


Pass auf… Programmierung ist wahrscheinlich nicht jedermanns Sache. Wahrscheinlich auch nicht deine. Lass uns deshalb die ganze Sache etwas flüssiger gestalten. Darf ich dir vielleicht ein Bier anbieten? Am besten nimmst du es dir selbst. Du weißt schon… offensichtliche Gründe. Ich bin schließlich ein Buch und kann dir deswegen kein Bier geben. Andere Lehrbücher werden dir an dieser Stelle jetzt wahrscheinlich ihre erste Weisheit präsentieren. Wir lehnen uns jedoch zurück und genießen erstmal unser Bier. Es gibt sogar ein soziales Netzwerk für Biertrinker. Du denkst, ich will dich über den Tisch ziehen, oder? Wenn du mir nicht glaubst, dann überzeug dich doch einfach selbst. Schlag einfach mal bei deiner bevorzugten Suchmaschine nach. Ich selbst habe „social network for beers“ eingegeben und gleich der erste Eintrag war ein Volltreffer. Verrückt, oder? Ich weiß nicht, wie es dir dabei geht, aber ich war sofort angemeldet. „Wie kann ein Bier ein eigenes soziales Netzwerk haben?“ ist jetzt bestimmt eine Frage die neben dem Alkohol in deinem Kopf wütet. Bestimmung und Bedarf sind zwei Begriffe die dir eine Antwort auf deine Frage liefern können. Vor einiger Zeit hatte ein schlauer Kopf eine Idee. Die Idee war ein soziales „Biernetzwerk“, das Ziel war ganz einfach: Er wollte mit anderen Biertrinkern schnell und einfach in Kontakt treten. Sofort setzte er sich den Rechner und startete mit seinem Projekt, dem sozialen Biernetzwerk, durch. Bis hierhin ist eigentlich alles ziemlich simpel. Eine Idee – Eine Berufung – Ein Projekt. Jetzt kommen allerdings Menschen wie du und ich ins Spiel. Jährlich werden pro Kopf allein in Deutschland zirka 105 Liter des gelblichen Getränks zu sich genommen. Bei solchen Massen liegt es nahe, dass ein soziales Biernetzwerk erfolgreich ist. Du siehst: Selbst so etwas wie Bier hat etwas mit Programmierung zu tun. Das, was ich dir hier erzähle, muss dir mittlerweile ziemlich komisch vorkommen, oder? Immerhin hast du für dieses Buch vermutlich Geld ausgegeben und du wunderst dich jetzt bestimmt, wann du endlich programmieren lernen wirst. Weil du es bist und weil ich meiner Berufung als Lehrbuch folgen möchte, fangen wir jetzt endlich an. Andere, ich nenne sie nett „herkömmliche“ – Programmierbücher werden dir wahrscheinlich anhand von „Hello World“-Beispielen und Codeschnipseln die Grundkenntnisse des Programmierens beibringen. Hier kommt nun die halbleere Bierflasche in deiner Hand zum Einsatz. Damit hättest du sicherlich nicht gerechnet oder? Es wird dich überraschen, aber anhand deiner Bierflasche lassen sich ziemlich einfach Grundkenntnisse der Programmierung erläutern.

In einer objektorientierten Programmiersprache, wie zum Beispiel Java oder C#, lässt sich deine Bierflasche als Objekt mit den dazugehörigen Eigenschaften (Attributen) beschreiben. Dazu überlegen wir uns, welche Eigenschaften vermutlich jede Bierflasche hat. Richtig, einen Namen und einen Volumeninhalt. Wenn wir nun etwas weiter denken, dann können wir auch noch weitere Eigenschaften finden. Angenommen du möchtest etwas aus der Bierflasche trinken, dann musst du die geschlossene Flasche erst öffnen. Demzufolge kann sie offen oder geschlossen sein. Wenn du etwas trinkst, dann wird die Füllmenge, also das Bier, weniger bis es leer ist. Wenn du mir nicht glaubst, dann schau dir einfach den folgenden Code-Ausschnitt in Java sowie die dazugehörigen Schaubilder an.

BeerBottle

Attribute einer Bierflasche: Name, offen oder geschlossen, maximales Volumen und momentane Füllmenge, leer oder nicht leer

JavaBeer

Attribute der Bierflasche in Java: String name, boolean isOpen, int totalVolume, int currentVolume, boolean isEmpty

/**
 * Mithilfe von // oder /** erstellst du einen Kommentar.
 */
private String name;
private int totalVolume;
private int currentVolume;
private boolean isEmpty;
private boolean isOpen;

Die vollständige Umsetzung einer Flasche in Java-Quelltext findest du auf GitHub.

Java unterscheidet hier, wie du sehen kannst, erst einmal 3 Eigenschaftstypen:

  • String (für einen Text wie z.Bsp. „Hallo Welt!“)
  • int (kurz für Integer, also ganzzahlige Werte wie z.Bsp. 1,2,3,…,n)
  • boolean (Wahrheitswerte wie z.Bsp. true (Wahr/ Ja) oder false (Falsch/ Nein))

mit deren Hilfe die Flasche Bier beschrieben wird. Mithilfe von Anführungszeichen kannst du der Variable name einen Text zuweisen.

String name = "Chucky´s Pils"; 
/* Herzlichen Glückwunsch dein Bier hat jetzt einen Namen 🙂 */

int totalVolume = 500;
/* Die Flasche beinhaltet maximal 500 Milliliter an Flüssigkeit */

boolean isOpen = true;
/* Die Flasche ist nun geöffnet */

Deine Flasche bekommt eine Füllmenge totalVolume von 500 Millilitern als Typ int zugewiesen. Wie oben zu sehen, wird der Eigenschaft Offen isOpen der Wert true für Ja zugewiesen. Nimmst du dir eine neue Flasche so ist diese zu Beginn geschlossen, also false, und muss erst noch geöffnet werden. Mithilfe von Methoden, die das Verhalten von Objekten definieren, kannst du den Zustand der Flasche verändern. Folglich kann durch die Methode open() der Wahrheitswert deiner Flasche in der Eigenschaft isOpen auf true geändert werden.

/**
 * Open the bottle
 */
public void open() {
  isOpen = true;
}

Den Aufruf dieser Methode gleicht deiner Handlung die du machst um deine neue Flasche mithilfe des Flaschenöffners zu öffnen.  Eine Objektorientierte Programmiersprache besitzt natürlich mehr als diese drei dargestellten Eigenschaftstypen. Folgende Tabelle zeigt dir die wichtigsten Eigenschaftstypen in Java.

Basistyp Beschreibung
boolean Ist eine Darstellung von einem Wahrheitswert „true“ oder „false“
byte Kann Ganzzahlige Zahlen zwischen -128 und +127 enthalten
short Kann Ganzzahlige Zahlen zwischen -32.768 und +32.767 enthalten
int Kann Ganzzahlige Zahlen zwischen –2.147.483.648 und +2.147.483.647 enthalten
long Kann Ganzzahlige Zahlen zwischen -9.223.372.036.854.775.808 und 9.223.372.036.854.775.807 enthalten
float Kann Gebrochene Zahlen zwischen -127 bis +127 enthalten
double
Kann zahlen beinhalten von -127 bis +127
char
Arrays Arrays erweitern Datentypen so dass diese mehr als einen Wert enthalten können. Jeder Datentyp kann ein Array sein. Beispielsweise kannst du über int name[] = new int[2] der Variablen Name 2 Werte zuweisen. Indem du beispielsweise name[0] = 21; und name[1] = 100; schreibst, wird deine Variable „name“ zum Array. Die eckigen Klammern definieren Arrays. Arrays fangen immer bei 0 an weswegen du bei der Zuweisung der Werte aufpassen musst. Um den letzten Wert des Arrays zu erhalten oder zu definieren musst du also immer die Länge des Arrays minus 1 nehmen.

Tabelle 1: Beschreibung der Basisdatentypen in Java

Und? Hast du immer noch Lust auf objektorientierte Programmiersprachen? Lass mich dir was aus meinem langen Buchleben erzählen. Damals habe ich mit Java angefangen. Ich stand damals an demselben Punkt wie du. Ich hatte überhaupt keine Ahnung von Programmierung und wurde in diese Welt hineingeworfen. Mein Gesicht glich damals wahrscheinlich gerade deinem. Kinnlade weit unten und die Augen weit verdreht. Du bist aber besser dran als ich damals. Du hast nämlich mich – dieses Lehrbuch, das dir hier und heute zur Seite steht. Deswegen nimm noch einen Schluck von deinem Bier und wir machen gleich weiter.

Wie du sicherlich in unserem kleinen Codeschnipsel gesehen hast, standen vor den Eigenschaftstypen weitere lila Wörter. Lila hervorgehobene Wörter sind Schlüsselwörter in der Programmiersprache Java. Das bedeutet, dass diesen Wörtern bereits Funktionen zugewiesen sind und du diese nur in ihren vordefinierten Kontext verwenden kannst. Oben steht vor jedem Eigenschaftstyp ein eigenes Wort in lila. Wie du siehst steht dort „public“ oder „private“. Diese Wörter drücken aus, wie du auf Variablen und Methoden zugreifen kannst. Ist eine Methode oder eine Variable mit „public“ bezeichnet so kannst du auf diese Variablen oder Methoden auch außerhalb des Objekts zugreifen. Übersetzt bedeutet das wenn du ein zweites Objekt hast, das zum Beispiel einen Mensch darstellt, so kannst du mithilfe einer Methode des Objektes „Mensch“ auf eine Methode oder Variable des Objektes „Bier“ zugreifen. Würdest du versuchen auf eine Methode oder Variable des Objektes Bier die mithilfe des Schlüsselworts „private“ ausgestattet ist, zuzugreifen, so erhältst du einen Fehler. „Private“ bedeutet nämlich das Methoden und Variablen nur innerhalb des Objektes angesprochen werden können. Am besten könntest du dieses Verhalten mit einem Geheimhaltungsabkommen vergleichen. Dem Objekt Bier wird durch das Schlüsselwort „private“ untersagt, das es diese Information nach außen geben darf. Durch das separate Erstellen einer Methode die durch „public“ gekennzeichnet ist kannst die wie in nachfolgender Abbildung zu sehen beispielweise den Namen des Bieres herausfinden.

Du wirst mich wahrscheinlich jetzt ins Feuer werfen wollen. Wahrscheinlich fühlst du dich jetzt etwas überfordert. Du wirst mich verstehen wenn ich hier bereits meine dritte Flasche in der Mangel habe. Nicht nur für dich ist das hier anstrengend. Ich bin die ganze Zeit am Überlegen wie ich dir das hier beibringen soll. Das hier sind nur die Grundkenntnisse. Zum Glück muss ich dir nicht mehr als das beibringen. Folgende Tabelle zeigt dir noch andere Schlüsselwörter die vor Methoden und Variablen stehen können.

Schlüsselwort Beschreibung
public Dieses Schlüsselwort beschreibt, das du eine Methode oder Variable von überall aus in deinem Programm aus ansprechen kannst
private Dieses Schlüsselwort bedeutet, das du eine Methode oder Variable nur innerhalb einer Klasse oder einem Objekt aus ansprechen kannst. Indem du eine simple public-Methode in deiner Klasse oder deinem Objekt erstellst, kannst du trotzdem auf diese „privaten“ Eigenschaften zugreifen
protected Dieses Schlüsselwort beschreibt, das du nur dann auf eine Methode oder Variable zugreifen kannst, wenn die beinhaltende Klasse von einer anderen Klasse verwendet wird.

Tabelle 2: Beschreibung Schlüsselwörter Java

Am liebsten würde ich dir hier bereits etwas Feierliches in die Hand drücken. Eine Fahne oder Medaille dafür dass du solange durchgehalten hast. So kann ich dir nur meinen Respekt dafür ausdrücken. Glaub mir wenn ich dir sage, dass die meisten Bücher ihre Interessenten bereits nach den ersten zwei Seiten verlieren. Es ist unglaublich schwer so etwas wie objektorientiertes Programmieren per Lehrbuch zu vermitteln.

Wusstest du, dass man im Wesentlichen vier Biergattungen unterscheidet? Einfachbier mit 1,5 bis 6,9 Prozent, Schankbier mit 7,0 bis 10,9 Prozent, Vollbier 11,0 bis 15,9 Prozent und Starkbier mit mehr als 16,0 Prozent. Ich wette du schaust gerade zu welcher Kategorie das Bier in deiner Hand gehört oder? Wenn du jetzt wissen würdest was auf dich in diesem Buchabschnitt noch zukommt, würdest du dein Bier jetzt wahrscheinlich gegen eines der nächsthöheren Kategorie eintauschen denke ich. Wenn wir gerade bei verschiedenen Prozentsätzen der Biere sind, so können wir deinem Bier eine Kategorisierung zuweisen. Dafür müssen wir dem Bier eine neue String-Eigenschaft hinzufügen. „Bierart“ ist im Folgenden unsere Eigenschaftsbezeichnung für dieses Merkmal. Bevor wir diese Zuweisung jedoch machen können, müssen wir Wertegrenzen, wie weiter oben beschrieben, definieren. Dies erfolgt über den Eigenschaftstypen „double“. Mithilfe von „double“ kannst du gebrochene Zahlen als Grenzen für eine Kategorisierung definieren. Grenze eins wird bei 1,5; Grenze zwei bei 7,0; Grenze drei bei 11,0 und Grenze vier bei 16,0 gesetzt.

public String getBeerType() {
  String type = "";

  if (alcoholPercentage < 1.5) {
    type = "Alkoholfrei";
  } else if (alcoholPercentage < 7) {
    type = "Einfachbier";
  } else if (alcoholPercentage < 11) {
    type = "Schankbier";
  } else if (alcoholPercentage < 16) {
    type = "Vollbier";
  } else {
    type = "Starkbier";
  }

  return type;
}

Durch das Verwenden der Schlüsselwörter „if“ und „else“ können wir eine Entscheidungsfindung in deinem Programm implementieren. Innerhalb des nach „if“ folgenden Klammern Paares definierst du die Entscheidung nach der das Programm kategorisieren soll. Als Vergleichswert zur Entscheidungsfindung nutzt deine „if“-Anweisung die Eigenschaft „Alkoholgehalt“ deines Objektes „Bier“. Dabei vergleicht die Anweisung ob eine wahre Aussage getroffen wird. Ist die Aussage die du im Klammern Paar getroffen hast „wahr“, so führt dein Programm den Programmcode des folgenden geschweiften Klammern Paares aus. Ist die Aussage „falsch“, so führt das Programm den Programmcode der „else“-Anweisung aus. Innerhalb der geschweiften Klammern kannst du, wie oben zu sehen ist, immer weiter mit „if“-Anweisungen verschachteln. So kannst du einen Entscheidungsbaum erstellen wobei immer ermittelt wird ob eine Eingabe endlich mit einem Vergleichswert übereinstimmt. Für das Bier was wir bisher als Objekt erstellt haben hast du wahrscheinlich irgendetwas um die 5,5 als Alkoholgehalt angegeben. Damit wird deinem Bier wahrscheinlich in der zweiten „if“ Anweisung die Bierart „Einfachbier“ zugewiesen. Du kannst erkennen, dass Java sehr viel mit Wahrheitswerten und vergleichen arbeitet. Eine Aussage die du in Programmcode beschreibst kann entweder wahr – und damit ausführbar – oder falsch – und damit nicht ausführbar – sein. Wahrheitswerte und Eigenschaftstypen die mit Zahlen beschrieben werden kannst du mithilfe der „==“ (doppelten Ist-Gleich) – Anweisung vergleichen. Texte musst du allerdings mithilfe der „.equals(„“)“ Anweisung überprüfen. Um dies möglich zu machen musst du einen String nehmen und mit .equals(„“) erweitern. Innerhalb der Anführungszeichen beschreibst du –wie du unter diesen Textabschnitt sehen kannst – einen Text der mit deinen im Programmcode hinterlegten String auf Gleichheit hin überprüft wird. Beachte jedoch, dass wenn ein Text einen Teil des Strings ausdrückt, das Ergebnis immer „falsch“ ist. Um dies zu lösen gibt es eine weitere Möglichkeit die aber die Grundkenntnisse die ich dir hier vermitteln will übersteigt. Wenn ich damit jetzt anfangen würde, dann würden du und ich wahrscheinlich noch mindestens vier weitere Bier benötigen. Trink deswegen lieber einen Schluck von deinem fantastischen Bier und lass uns danach weitermachen.

Wie du hoffentlich nach deinen – mittlerweile bestimmt schon drei – Bier erkennen konntest, ist eine Kategorisierung der Biere in einer Programmiersprache wirklich einfach. Im Prinzip haben wir einfach nur 4 Grenzbereiche für den Alkoholbereich festgelegt und eine Methode definiert welche dem Bier in deiner Hand einer Kategorie zuordnet. Das witzige ist. An dieser Stelle hast du schon fast alle Grundkenntnisse der Programmiersprache gelernt. Kaum zu fassen oder? Programmieren und das erstellen deines ersten Programmes kann wirklich einfach sein.

In dem oberen Codebeispiel hast du dich bestimmt auch gewundert das nach dem Sichtbarkeitsschlüsselwort ein Datentyp folgte. Das bedeutet, dass die Methode einen Wert zurückliefert von dem definierten Datentyp. Hierbei wirst du gezwungen diese Rückgabe über ein „return“ einzuleiten. Danach musst du eine Variable oder einen Ausdruck übermitteln der dem Datentyp entspricht. Diese sogenannten Rückgabewerte ermöglichen die Kommunikation zwischen Klassen und Methoden und vereinfachen dir das Leben in der Programmierung enorm. Rückgabewerte können alle möglichen Datentypen sein. Alternativ wenn eine Methode keinen Rückgabewert liefert musst du dies mit dem Schlüsselwort „void“ in einer Methode zum Ausdruck bringen.

Nun muss dir bestimmt der Kopf rauchen. Wahrscheinlich hast du auch gar keine Lust mehr auf mich. Mir in deiner Position würde es zumindest so gehen. Wahrscheinlich würde ich das Buch was gerade vor dir liegt verzweifelnd in die Ecke werfen. Alternativ würde ich gerade darüber nachdenken das Buch in den Mülleimer zu werfen, anzuzünden und als Werk des Teufels zu bezeichnen. Trotzdem möchte ich dir sagen, dass ich stolz auf dich bin. An diesem Punkt hast du nun zirka 70 Prozent der Grundkenntnisse dieses Lehrbuchabschnittes durch, weswegen du dir als Belohnung nun ein neues Bier aufmachen kannst. Da du mittlerweile nun mindestens das dritte Bier in der Hand halten solltest, bemerkst du sicherlich auch schon wie die vollen Biere in deinem Kasten immer weiter schwinden. In Java kannst du diesen Flaschenschwund aus deinem Kasten mithilfe einer „for“-Schleife und einem Array was deinen Kasten repräsentiert (bottles = new Bottle[20];), kannst du das ganz einfach ausdrücken.

private Bottle[] bottles = new Bottle[20];
private int zuTrinkendeFlaschen = 3;

public void removeAllBottles() {
  for(int position = 0; position < zuTrinkendeFlaschen; position++) {
    removeBottleInPlace(position);
  }
}

public void removeBottleInPlace(int position) {
  bottles[position] = null;
}

In den oben zu sehenden Codebestandteil beginnst du mit einem vollen Kasten. Nacheinander nimmst du immer eine weitere Flasche an der Position „position“ aus dem Kasten. Solange wie du immer wieder eine Flasche aus dem Kasten nimmst wird immer wieder eine Flasche aus dem Kasten entnommen. Innerhalb des Klammern Paares, das nach der „for“-Anweisung folgt, definierst du dieses Verhalten. Innerhalb einer Startvariable („position = 0“) definierst du, das zu Beginn dein Kasten voll war. Danach definierst du eine Bedingung die anzeigt wieviele Flaschen du aus dem Kasten nimmst  („position < zuTrinkendeFlaschen; – in der Regel verwendest du hier die Zeichen „<“, „>“, „!=“ (Verneinung) oder „==“). Als drittes definierst du mithilfe eines Mathematischen Ausdrucks wie du die Flaschen entnimmst (position++ – dies bedeutet eine nach dem anderen). Hast du all das definiert, so hast du dein Vorgehen bei der Entnahme der Biere mithilfe einer „for“-Schleife ausgedrückt. Die „for“-Schleife durchläuft sich so oft selbst wie es deine definierte  Rechenoperation in Abhängigkeit von deiner definierten Bedingung zulässt. Innerhalb der „for“-Schleife rufst du eine Methode auf die die Flasche an der „position“ aus dem Kasten entnimmt. Folglich wird diese Position im Kasten leer. Diese leere Position wird über das Schlüsselwort „null“ ausgedrückt. „null“ drückt den Startzustand einer Variablen aus wenn diese nicht mit einem Wert belegt ist. Rufst du zum Beispiel eine Variable auf die von dir noch nicht oder nicht mit einem Wert belegt wurde, so hat diese den Wert „null“. Auf die gleiche Weise funktioniert auch eine „while“-Schleife. Eine solche Schleife kann jedoch auch unendlich lang wiederholt werden, wenn in ihrer Bedingung (folgendes Klammern Paar) etwas definiert wird, was nie eintrifft. Folgendes Beispiel würde beispielsweise eine Schleife auslösen die niemals enden würde.

public void drink() {
  int place = 3;
  Bottle bottle = getBottleFromPlace(place);
  boolean kastenLeer = isEverythingEmpty();
  
  while (kastenLeer == true) {
    bottle.drinkSomething(20);
    kastenLeer = isEverythingEmpty();
  }
}

Falls du dich wunderst was in der „while“-Schleife zum Ausdruck gebracht wurde… Innerhalb der Bedingung wird ausgedrückt, dass du solange Bier trinkst bis dein Kasten leer ist. Ziemlich dämlich oder? Natürlich trinkst du nicht den ganzen Kasten leer beziehungsweise hörst du wahrscheinlich auf sobald deine Flasche leer ist. Für dich scheint das ziemlich offensichtlich. Das Programm kann jedoch nicht wissen, dass dieser Programmteil völliger Unsinn ist. Folglich würdest du nach dem Programm nie mehr aufhören zu trinken. Für dich ziemlich fatal. Du weißt das es ab 5,0 Prozent Blutalkohol für einen Menschen gefährlich wird oder? Wenn nicht solltest du es nicht ausprobieren. Man sagt, das Menschen die diese Grenze überschreiten anschließend ihrem Schöpfer die Hand reichen können. Glaub mir wenn ich dir aus Erfahrung sage, dass sich der Aufwand allerdings nicht wirklich lohnt. Du kannst beispielsweise deine Idee nichtmehr umsetzen die du hattest bevor du diesen Lehrbuchabschnitt angefangen hast. Darum sind wir beide ja gerade in dieser Situation hier. Ich kann dir sagen dass es nun aber gleich geschafft ist. Ich habe nur noch eine kleine Lektion für dich. Folglich haben wir es beide gleich geschafft. Ich hab übrigens gerade mein viertes Bier falls es dich interessiert. Frauen können Alkohol übrigens nicht so schnell abbauen wie Männer. Ihr Östrogenhaushalt hindert sie daran Alkohol genauso effektiv wie Männer abzubauen. Frauen haben folglich mehr Spaß mit Alkohol als Männer. Ziemlich unfair wenn du mich fragst. Wir als Männer… oder Bücher… geben uns unendlich viel Mühe Spaß zu haben und die Mädels neben uns feiern bereits mit vollem Enthusiasmus. Jetzt bin ich aber abgeschweift. Wo waren wir… Richtig. Das letzte was ich dir hier beibringen möchte. Hierbei geht es um die eigentliche Seele eines Programmes in Java. Irgendwo in deinem Programm muss es an einer Stelle folgende Codezeile vorkommen:

public static void main(String[] args) {
  BeerBottle kindl = new BeerBottle(330, 5.1f);
  System.out.println(kindl.getBeerType());

  BeerBottle wein = new BeerBottle(125, 11);
  Person you = new Person("Dein Name!", Gender.FEMALE, 60);
  you.consume(wein);

  System.out.println(you.getPromille());
}

Die Main-Methode ist der Einstieg in jedes Programm. Wenn du auf ein Programmicon deines Desktops oder Smartphones klickst, wird diese Methode aufgerufen um das Programm was du starten möchtest zu starten. Diese Methode kannst du vielleicht mit deiner Seele oder deinem Gehirn vergleichen. Innerhalb dieser Methode sprichst du die einzelnen Codebestandteile deines Programmes an. Beispielsweise greifst du von hier aus auf die Methoden deines Objektes „Bier“ zu. Bist du am Ende der geschweiften Klammern dieser Methode angekommen, so ist dein Programm beendet. In der Realität würde das bedeuten, dass beispielsweise dein Gehirn aufhören würde zu funktionieren. Für dich und mich wäre das bestimmt nicht sonderlich effektiv. Für ein Programm jedoch spielt dies eher weniger eine Rolle. Da wir bis jetzt noch keine künstliche Intelligenz entwickeln konnten, entsteht auch kein Schaden sobald die Methode beendet wird.

An dieser Stelle möchte ich dir gratulieren. Wenn du hier angekommen bist hast du ziemlich alle Grundkenntnisse der Programmiersprache Java erlernt. Leider konnte ich dir hier nur Java nah bringen. Wenn du allerdings alles was ich dir bis hierhin vermitteln wollte verstanden hast, so wirst du merken das es ziemlich einfach für dich ist auch in anderen Programmiersprachen durchzustarten. Falls du dich gewundert hast warum ich dir hier die ganze Zeit von Bier erzähle: Eine Studie meinte, das ein bis zwei Glas Bier täglich deine Lebenserwartung erhöhen. Wenn du dir also wie ich im Laufe unserer Zusammenarbeit hier mit mir zusammen Bier getrunken hast, so kannst du davon ausgehen, dass du dein Herzinfarktrisiko für später gesenkt hast. Du hast also nicht nur was gelernt sondern auch was für deine Gesundheit getan. Viel mehr kann ich für dich von hier aus nicht tun und hoffe, dass du von nun an mit deiner Idee durchstarten kannst.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.