alix

MainExample.java

/**
 * @file
 * Kleines Beispiel einer Main Methode.
 *
 * @author Kevin Ingwersen
 */

class MainExample {

  // Als aller Erstes definieren wir mal eine kleine Methode...
  public static void greet(String name) {
    System.out.println("Hallo, " + name + "!");
  }

  // Und nun, die main-Methode.
  // Wenn man eine Methode betrachtet, wird alles was vor den geschweiften
  // Klammern steht, als "Signatur" bezeichnet. Main hat zwei Solcher
  // Signaturen. Ich demonstriere hier die einfachere Variante.
  public static void main(String[] args) {

    // Die einfachste Signatur sagt folgendes:
    // - public: Diese Methode ist öffentlich und für alle Teile des
    //   des Programmes sichtbar.
    // - static: Diese Methode ist statisch. Es ist keine Instanz dieser
    //   Klasse notwendig, um sie Auszuführen.
    // - void: Der Rückgabewert - in diesem Fall, gar keiner. "void" heißt
    //   so viel wie "nichts" oder "leere".
    // - main: Der name der Methode. NUR main hat eine besondere Bedeutung -
    //   und NUR Main wird beim Programmstart automatisch ausgeführt.
    // - String[] args: Es ist möglich, einem Programm bei der Ausführung
    //   ebenfalls Parameter oder Argumente zu übergeben. Diese landen hier.
    // 
    // Für dieses kleine Beispiel, rufen wir erstmal unsere oben stehende 
    // Methode auf, damit wir begrü0z werden:
    greet("Kevin");

    // Jetzt müssen wir das Programm kompilieren und ausführen. Den Umgang
    // mit einer Kommandozeile erkläre ich dir wohl besser in persona - aber,
    // grob gesagt, navigierst du in der Konsole - auch Terminal genannt - 
    // in das gleiche Verzeichniss/Ordner in dem sich die Java-Datei befindet,
    // die du gerne kompilieren möchtest. In unserem Fall muss diese Datei 
    // exakt "MainExample.java" heißen. Warum? Naja...
    // 
    // Wenn in Java ein Programm kompiliert wird, benutzt Java den Dateinamen,
    // um fest zu stellen, WELCHE Klasse denn die main-Methode enthält, die
    // später geoffnet werden soll. Syntaktisch dargestellt wird Java also nach
    // "MainExample::main" suchen. In vielen Programmiersprachen werden
    // Zeichen wie der doppelte Doppelpunkt (::) verwendet, um Namen von 
    // verschiedenen Klassen und Methoden voneinander zu trennen. So zu sagen
    // das Leerzeichen eines Programmierers. Das sieht natürlich je nach
    // Sprache noch mal anders aus. Als kleiner Exkurs: In PHP könnte
    // eine solche Bezeichnung so aussehen: \MyNS\MyClass::main() .
    // 
    // Aber mal zurück zu Java...
    // Damit Java weiß, welche main-Methode aufgerufen werden osll, wird der
    // Dateiname vor dem ".java" verwendet. So sagst du Java also, wo es nach
    // dieser Methode suchen soll. Nun denn, kompilieren wir das mal:
    // 
    // > javac MainExample.java
    // 
    // "javac" bedeutet "Java Compiler" und ist ein Kommando, mit welchem eine
    // ".java" Datei in eine ".class" Datei umgewandelt wird. Wie du siehst,
    // steht schon jetzt im Dateinamen das Wort "class", was ja auch ganz oben
    // steht, um eine Klasse zu definieren. Tatsächlich ist in dieser Datei nun
    // nur noch die Klasse selbst als Maschinensprache enthalten - also nicht
    // mehr als Text, den du bearbeiten kannst, sondern etwas, was Java selbst
    // verstehen kann.
    // 
    // Wenn wir nun diese "MainExample.class" ausführen wollen, sieht das so aus:
    // 
    // > java MainExample
    // 
    // Du merkst, es steht kein ".class" Dabei. Nun, warum DAS so ist, weiß ich
    // gar nicht mal so genau...tatsächlich bin ich ja eigentlich kein Java-
    // Programmierer :). Fakt ist...Java benutzt den Namen den du eingibst und
    // hängt selbst automatisch ein ".class" drann, und sucht dann nach eben
    // dieser Datei - also "MainExample.class".
    // 
    // Wenn es diese gefunden hat, wird die Klasse geladen und Java sucht
    // zu aller erst nach einer main-Methode - und, wenn gefunden, führt
    // diese sofort und automatisch aus.
    // 
    // Stell dir das so vor:
    // 
    // String name = "MainExample";
    // String javaName = name + ".class";
    // if( file_exists(javaName) ) {
    //   JavaKlasse javaClass = load_java_class(javaName);
    //   
    //   if( javaClass.hasMethod("main") ) {
    //     javaClass.main();
    //   }
    // }
    // 
    // So ungefähr würde das in Code aussehen...natürlich ist das stark
    // vereinfacht, sollte aber genug ausdrücken.
    // 
    // Das heißt: Du definierst Methoden in einer Klasse, die verschiedene
    // Dinge machen. Aber, irgendwo muss ja auch mal eine Methode angestoßen
    // werden, wie ein Dominostein. Und dieser Anstoßer ist main().
    // 
    // Stell dir das so vor, wie der Beginn einer Stra0e - da steht dann halt
    // dick und fett "main" auf dem Boden - und auf dem Weg hast du dann
    // die verschiedensten Abzweigungen (Methoden) die du befahren kannst.
    // Aber irgendwann ist die Straße - also main() - zu Ende.
    // 
    // Hoffendlich hat dir das geholfen!
  }

}