Genereller Aufbau

  • Code
  • Erklärung
  • Ergebnis

public class JavaExample {

	public static void main(String[] args) {
		System.out.println("Erste Ausgabe in der Console");
	}

}

Erstelle in deiner IDE für Java neues Projekt. Unsere ersten Java Programme werden alle fast gleich beginnen.
Zu Beginn steht unsere main-Funktion die in der Klasse JavaExample eingebettet ist. Klassen werden an anderer Stelle behandelt. Diese main ist der Einstiegspunkt jedes Programmes und muss in jedem Code ein mal (und nur ein mal) vorkommen. Das vorangestellte void definiert den Rückgabetyp dieser Funktion - nämlich keine Rückgabe. Doch dazu später mehr. Nach dem Funktionsnamen folgen zwei runde Klammern.
Das string[] args beschreibt Parameter die ggf. an die Methode übergeben werden. Die geschweiften Klammern { } bilden einen sogenannten Anweisungsblock der unseren Code sozusagen gruppiert und anzeigt, dass der darin geschrieben Code zu unserer main-Methode gehört. System.out leitet unsere Ausgabe in der Console ein. Mit println() geben wir in Anführungszeichen an was wir als Zeile in der Console ausgeben möchten.
Das Semikolon muss (bis auf wenige Ausnahmen) jede Anweisung beenden. Der geschrieben Code lässt sich nun in Eclipse per Strg-F11 in der Consolenansicht ausführen.

Einfache Datentypen und Variablen

  • Code
  • Erklärung
  • Ergebnis

public static void main (String[] args)
{
    int i = 13;
    int j = 24;
    int k = 26;
    float ergebnis = 5 * k + 5 - 3.0f / 7;

    boolean b = true;
    byte by = 123;

    float f;
    f = 13.7603f;

    char c = 'c';

    System.out.println("i = " + i + " j = " + j + " k = " + k);
    System.out.println("Ergebnis = " + ergebnis);
    System.out.println("b = " + b);
    System.out.println("f = " + f + " c = " + c);
    System.out.println("by = " + by);
}

Variablen dienen dazu Informationen zu speichern. Dafür gibt es unterschiedliche Datentypen, die anhängig von ihrem Inhalt zu verwenden sind. Da Java eine statisch typisierte Sprache ist, muss der Datentyp auch direkt bei der Deklaration angegeben werden. In Java gibt es acht besondere Datentypen, die primitiven Datentypen. Diese werden nicht durch ein Objekt repräsentiert, dadurch kann das System schneller mit ihnen arbeiten.
Name Minimum Maximum Größe in Bit
bool false true 1
char 0 65.535 16
byte -128 127 8
int -2.147.483.648 2.147.483.647 32
short -32.768 32.767 16
long -2^63 2^63-1 32
float 1,4E-45 3,4E+38 32
double 4,9E-324 1,7E+308 64
Es wird zwischen der Variablendeklaration und –Initialisierung unterschieden. Im Beispiel der float-Variablen 'f' sehen wir erst die Deklaration und in der nächsten Zeile die Initialisierung. Alle anderen Variablen werden in einer Zeile sowohl deklariert, als auch initialisiert. Initialisieren oder auch zuweisen von Werten geschieht durch ein '='. Dabei steht links vom '=' immer die Variable, der der Wert zugewiesen werden soll und rechts der zuzuweisende Wert.
Ebenfalls neu in diesem Code ist die Konkatenation. Mit einem ‘+’ verbinden wir Texte und Variablen zu einem String, den wir entweder wie in diesem Beispiel direkt ausgeben, oder in einer entsprechenden Variable speichern.

Dateneingabe

  • Code
  • Erklärung
  • Ergebnis

public class JavaExample {

	public static void main(String[] args) {
        int a;
        String str;

        System.out.println("Eingabe a:");
        a = new java.util.Scanner(System.in).nextInt();
        
        System.out.println("Eingabe str:");
        str = new java.util.Scanner(System.in).nextLine();
        
        System.out.printf("\nEingabe war: %s %s.", a, str);
	}
}

Die Dateneingabe ist im Vergleich zu C# oder C++ nicht ganz so offensichtlich. Die Eingabe über die Konsole wird mit new java.util.Scanner(System.in) eingeleitet und dann je nach Datentyp nextLine() für Zeichenketten, nextInt() für Integer oder nextDouble() für Double beendet.
Dabei ist darauf zu achten, dass die Variable vorher bereits deklariert wurde, und dass die Eingabe dem Datentyp der zu befüllenden Variable entsprechen muss. So kann die Eingabe 'Hallo' nicht in einem integer gespeichert werden.
Eine Neuerung an diesem Beispiel ist auch die Ausgabe der Variablen. Anstelle der Verknüpfung mit dem + kann auch %s als Platzhalter verwendet werden. Im Anschluss werden die Variablen in gewünschter Reihenfolge angegeben. Für welche Methode du dich entscheidest ist für den Anfang nicht von Belang.

Eine weitere kleine Neuerung ist das \n im letzten Statement. Dieses \n stellt einen einfachen Zeilenumbruch in der Console dar und kann an jeder Stelle innerhalb von Anführungszeichen verwendet werden. Dieses \n ist eins von einer Reihe an sogenannten Escapesequenzen.
Durch das vorangestellte Backslash ( \ ) lassen sich Zeichen darstellen die sonst im Programm zu Problemen führend würden.

Die wichtigsten dieser Zeichen sind:
\n – Zeilenumbruch
\‘ – Einfaches Anführungszeichen
\“ – Doppeltes Anführungszeichen
\\ - Backslash
\a – akustisches Signal (klassisches „Beep“)
\t – Tabulator
\xnn – Zeichen als Hexadezimalziffer (zB \x40 für @)
\ooo – Zeichen als Octalziffer (zB \100 für @)

Bedingte Anweisungen

  • Code
  • Erklärung
  • Ergebnis

    public class Main
    {
        public static void main (String[] args) 
        {
            int a = 13;
            int b = 20;
            boolean x = false;

            if (a < 20) 
                System.out.println("a ist kleiner als 20");
            else if  (a > b) 
                System.out.println("a ist groesser als b");

            if (x) 
                System.out.println("x = True");
            else 
            {
                System.out.println("Else wird ausgefuehrt");
                System.out.println("x = Falsch");
            }

            System.out.println(a < b ? a : b);
        }
    }


Bedingte Anweisungen ermöglichen es Codestellen nur unter definierten Umständen ausführen zu lassen. Die klassische bedingte Anweisung ist das If-Statement. In den runden Klammern erfolgt die Prüfung des Statements. Liefert dieses true (wahr) zurück, dann wird die nachfolgende Anweisung oder der nachfolgende Block {} ausgeführt. Mit else if lassen sich Bedingungen aneinander Reihen. Der Else Block wird dann ausgeführt, wenn keiner der vorherigen if Blöcke ausgeführt wurde. 
Vereinfacht lässt sich das mit WENN (if-Statement) - DANN (Anweisung wenn wahr) - SONST (else) übersetzen.
Die erste Prüfung im Beispiel liefert true, da a kleiner als 20 ist. Das folgende else if wird nicht ausgeführt. If(x) liefert false, da x mit false initialisiert wurde. Somit wird der Else-Block ausgeführt. 
Insbesondere bei Wertzuweisungen eignet sich eine weitere Form der bedingten Anweisung; dem einzigen ternären Operator in Java. Dieser ist im Letzten Beispiel dargestellt. Der Ausdruck ist folgendermaßen aufgebaut: WENN ? DANN : SONST  .

Logische Ausdrücke

  • Code
  • Erklärung
  • Ergebnis

public class JavaExample {

	public static void main(String[] args) {      
        int a = 13;
        boolean x = true;

        if (a > 10 && a < 20)
        	System.out.println("a liegt zwischen 10 und 20");

        if (a < 10 || x)
        	System.out.println("a ist kleiner als 10  ODER x = true ");
	}
}

Logische Ausdrücke sind Aussagen oder Bedingungen die am Ende true oder false liefern, deren Aussage also wahr oder falsch ist.
Per || lassen sich Ausdrücke Oder-Verknüpfen und per && lassen sich Ausdrücke Und-Verknüpfen. Dabei wird jeder Teilausdruck für sich selber bewertet, so dass der Ausdruck 3 > 2 && 5 == 6 false liefert da der zweite Teilausdruck falsch ist.
Derart verknüpfte Bedingungen können natürlich auch an anderen Stellen, wie zB der If-Anweisung verwendet werden.
Eine weitere Eigenschaft lässt sich mit einem ! (Rufzeichen) erzielen. Dieses wird als „Umkehrsymbol“ interpretiert. Aus !true wird also false und umgekehrt. Eine einfache übersicht bietet nachfolgende Tabelle. Leicht zu merken sind die Umstände, dass && - Verknüpfungen nur dann true liefern wenn alle Teilausdrücke true sind während || - Verknüpfungen nur dann false liefern wenn alle Teilausdrücke false sind.
Wahrheitstabelle

Schleifen

  • Code
  • Erklärung
  • Ergebnis

public class JavaExample {

	public static void main(String[] args) {      
		//FOR SCHLEIFE
        for (int i = 0; i < 10; i++)
        {
            System.out.println(i);
        }

        //WHILE SCHLEIFE
        int j = 0;
        while (j < 10)
        {
        	System.out.println(j);
            j = j + 1;
        }

        //DO SCHLEIFE
        int k = 0;
        do
        {
        	System.out.println(k);
            k = k + 1;
        } while (k < 10);
	}
}

Schleifen werden dazu verwendet um bestimmte Anweisungen wiederholt ausführen zu lassen. Typsiche Schleifen sind for, while und do. Jede der drei Schleifentypen sind untereinander austauschbar wobei die do-Schleife als einzige mindestens ein mal ausgeführt wird da die Prüfung erst am Ende der Schleife ausgeführt wird. Schleifen bestehen in der Regel aus dem Schleifenkopf in der geprüft wird ob der folgende Schleifeninhalt ausgeführt wird. So bedeutet for (int i=0; i<10; i++), dass die Variable i mit 0 beginnt und so lange i kleiner als 10 ist die Schleife ausgeführt wird. Danach wird i um 1 erhöht. Das passiert so lange bis i<10 false liefert. Wichtig ist hierbei, dass diese Bedingung auch tatsächlich irgendwann false liefert da man sonst in einer Endlosschleife landet.
Alle drei Schleifen liefern das selbe Ergebnis.
Diese Folgenden Grafiken verdeutlichen die Funktionsweise der Schleifen:
For-Schleife
For-Schleife
While-Schleife
While-Schleife
Do-Schleife
Do-Schleife

Arrays und Listen

  • Code
  • Erklärung
  • Ergebnis

import java.util.ArrayList;
import java.util.List;

public class JavaExample {
	
	public static void main(String[] args) {      
        //array mit 20 Plätzen
        int[] arr1 = new int[20];

        //Liste
        List list1 = new ArrayList();

        //array befüllen
        for (int i = 0; i < 20; i++)
	        arr1[i] = i;

        //array ausgeben
        for (int i = 0; i < 20; i++)
        	System.out.println(arr1[i]);

        //Die Methode Add() fügt bei einer Liste den Inhalt hinten an, remove() entfernt einen Eintrag
        list1.add(159);
        list1.add(368);
        System.out.println(list1);
	}
}

Als Array oder Liste bezeichnen wir einen Datentyp der sozusagen als Container für eine andere Variablen dient. So kann man zum Beispiel einem Array mit dem Namen ziffern 20 Zahlen speichern ohne dafür 20 integer-Variablen anlegen zu müssen.
Jeder dieser Container legt seine beinhaltenden Informationen unter einem fortlaufenden Index ab. So liegt der erste Wert auf Patz 0 (wir beginnen immer bei 0 an zu zählen) und z.B. der dritte Wert auf Platz 2. Referenziert wird dieser Platz - zum befüllen oder abrufen - per [INDEX]. Im nachfolgenden Beispiel sind zwei der häufigsten Listentypen vorgestellt. Das Array, das eine fixe Größe hat und der Vector mit dynamischer Größe. Der Beinhaltende Datentyp wird gleich bei der Deklarierung angegeben und kann nicht geändert werden. So kann ein integer-Array nur Variablen vom Typ integer enthalten.
Wichtig hierbei ist zu beachten, dass man in seinem Code keine Zugriffsverletzungen ausführt. So kann ein Array arr1 mit 10 Werten keinen Wert bei arr1[12] enthalten oder entgegennehmen.
Ebenfalls möglich ist es ein solches Array mehrdimensional darzustellen. Möchte man etwa ein Schachbrett in einem Array abbilden, könnte man ein zweidimensionales Array erstellen. Die Verwendung ist dabei gleich der eines eindimensionalen, allerdings mit einer weiteren Indexangabe.
Ein char-Array für unser Schachbrett könnte also z.B. als char schachbrett[8][8]; abgebildet werden.
Leicht lässt sich dies als ARRAYNAME[ZEILEN][SPALTEN] veranschaulichen. Arrays können aber durchaus mehrere Dimensionen besitzen, allerdings muss man bedenken, dass der benötigte Speicher exponentiell wächst. So benötigt z.B. ein char arr [100][365][24][60][60]; bereits über 3 Gigabyte Arbeitsspeicher.

Gerne wird ein solches Array per for-Schleife bearbeitet oder ausgegeben. Hierfür wird die Zählervariable der for-Schleife direkt für den Index des Arrays verwendet.

Funktionen

  • Code
  • Erklärung
  • Ergebnis

public class JavaExample {
	
    static void hallo()
    {
        System.out.println("Funktion 'hallo' aufgerufen");
    }

    static int add()
    {
        int a;
        int b;

        System.out.println("Eingabe a:");
        a =  new java.util.Scanner(System.in).nextInt();;

        System.out.println("Eingabe b:");
        b =  new java.util.Scanner(System.in).nextInt();

        return a + b;
    }
    
    public static void main(String[] args)
    {
        int ergebnis;

        System.out.println("Erster Funktionsaufruf");
        hallo();

        ergebnis = add();
        System.out.println("Ergebnis = " + ergebnis);
    }
}

Funktionen eignen sich hervorragend um häufig verwendete Codeabschnitte in einer eigenen Funktion (oder Methode) zu implementieren anstatt die gleichen Zeilen immer wieder zu schreiben. Somit sinkt der Schreib- und Wartungsaufwand.
Die erste Funktion kennen wir bereits. Nämlich die main-Funktion. Funktionen werden nach folgendem Schema deklariert: [Rückgabetyp] [Funktionsname] () {Anweisungen}. Optional kann auch ein [Zugriffsmodifier] wie z.B. public oder const vorangestellt werden. Der Rückgabetyp definiert den Typ der durch das return-Statement an die aufrufende Funktion zurückgegeben wird. Sobald das return Statement erreicht wird endet die Funktion, egal was danach noch kommen mag.
Die Rückgabetypen von Funktionen sind die gleichen wie sie für Variablen verwendet werden.
Einzig der Typ void hat keinen Rückgabetyp und auch kein return-Statement. So muss ein eine Funktion int getNumber() einen integer als return-Wert haben.

Parameterübergabe

  • Code
  • Erklärung
  • Ergebnis

public class JavaExample {

     static int add(int z1, int z2)
     {
         return z1 + z2;
     }

     static int add(int z1, int z2, int z3)
     {
         return z1 + z2 + z3;
     }
     
     public static void main(String[] args)
     {
         int ergebnis;

         System.out.println("Eingabe a und b:");
         int a =  new java.util.Scanner(System.in).nextInt();;
         int b =  new java.util.Scanner(System.in).nextInt();;

         ergebnis = add(a, b);

         System.out.println("Ergebnis von 2 Zahlen = " + ergebnis);
         System.out.println("Ergebnis von 3 Zahlen = " + add(a, b, 5));
     }
}

Damit Funktionen mit Variablen aus anderen Funktionen (z.B. aus main() ) arbeiten können, müssen diese übergeben werden. Die Anzahl, der Typ der Parameter und die Reihenfolge muss bei der Funktion definiert werden. Diese Reihenfolge muss bei dem Aufruf strikt eingehalten werden.
Obwohl der Funktionsname nur einmal im aktuellen Namespace verwendet werden darf, kann er mehrfach genutzt werden, wenn er sich zumindest in der Parameterliste unterscheidet. Dieser Vorgang wird überladung genannt.

Somit können die Funktionen int calculate(int a, int b) und int calculate(int a, int b, int c) im gleichen Namespace trotz gleichen Namens existieren. Bei dem Aufruf dieser Funktion wird automatisch erkannt welche der beiden Funktionen gemeint ist, je nach dem ob 2 oder 3 Parameter übergibst.
Wichtig zu wissen ist, dass Variablen nur innerhalb dieser Funktion gültig sind. Außerhalb der Funktion sind Variablen anderen Funktionen unbekannt.
Wie du siehst, kann die add() - Methode auch innerhalb unserer Ausgabezeile aufgerufen werden. Die Variable ergebnis wird bei dem zweiten add() - Aufruf allerdings nicht verändert.

Die aus C++ oder C# bekannte übergabe der Parameter als Referenz wird von Java nicht unterstützt. Hier wird jeder Parameter als Werteparameter übergeben (Call by value)