Java Grundlagen

●

Grundlagen für die Programmiersprache Java

Klassen

public class Klassenname {
    //some code
    // Attribute
    // Methoden
}

Methoden

Wertrückgabe

public Datentyp methodenname(Datentyp parametername, ...) {
    //some code
    return Wert;
}

Wertrückgabe per Variable

public Datentyp methodenname(Datentyp parametername, ...) {
    //some code
    return variable;
}

Keine Wertrückgabe

public void methodenname(Datentyp parametername, ...) {
    //some code
}

Methodenaufruf aus Testklasse

methodenname(parametername, ...);

Methodenaufruf aus Objektklasse

Objektname.methodenname(parametername, ...);

Methodenaufruf in Objektklasse

this.methodenname(parametername, ...);

Variablen

Ohne Initialisierung

Datentyp variablenname;

Mit Initialisierung

Datentyp variablenname = Wert;

per Bedingung

Datentyp variablenname = Bedingung ? Wert_bei_true : Wert_bei_false

Wertzuweisung einer Variable aus Testklasse

variablenname = Wert;

Konstante

final Datentyp variablenname = Wert;

Array

Datentyp[] variablenname = new Datentyp[Anzahl];

Array mit Initialisierung

Datentyp[] variablenname = {Wert1, Wert2, ...};

Wertzuweisung eines Array-Elements aus Testklasse

variablenname[Arrayindex] = Wert;

Wertzuweisung einer Variable eines Objekts aus Testklasse

Objektname.variablenname = Wert;

Wertzuweisung eines Array-Elements eines Objekts

Objektname.variablenname[Arrayindex] = Wert;

Wertzuweisung einer Variable in Objektklasse

this.variablenname = Wert;

Wertzuweisung einer Variable eines Array-Objektes

Objektname[Arrayindex].variablenname = Wert;

Wertzuweisung eines Array-Elements eines Array-Objektes

Objektname[Arrayindex].variablenname[Arrayindex] = Wert;

Wertzuweisung eines Array-Elements in Objektklasse

this.variablenname[Arrayindex] = Wert;

ArrayLists

ArrayLists importieren

import java.util.ArrayList;

ArrayList erstellen

ArrayList<Datentyp> variablenname = new ArrayList<>();

ArrayList<Datentyp> variablenname = new ArrayList<Datentyp>();

ArrayList mit Initialisierung

ArrayList<Datentyp> variablenname = new ArrayList<>(List.of(Wert1, Wert2, ...));

Element zur ArrayList hinzufügen

variablenname.add(Wert);

Element in der ArrayList ändern

variablenname.set(Index, Wert);

Element aus der ArrayList entfernen

variablenname.remove(Index);

Element aus der ArrayList abrufen

Datentyp element = variablenname.get(Index);

ArrayList-Größe abrufen

int size = variablenname.size();

Überprüfen, ob die ArrayList leer ist

boolean isEmpty = variablenname.isEmpty();

ArrayList leeren

variablenname.clear();

Überprüfen, ob ein Element in der ArrayList enthalten ist

boolean contains = variablenname.contains(Wert);

Konstruktoren

Normal

Klassenname variablenname = new Klassenname(parametername, ...);

Array

Datentyp[] variablenname = new Datentyp[Anzahl];

for (int i = 0; i < Anzahl; i++) {
    variablenname[i] = new Datentyp(parametername, ...);
}

in Objectklasse

public Klassenname {

    klassenname(Datentyp parametername, ...) {
        //some code
    }
}

Kontrollstrukturen / Schleifen

if

if (Bedingung) {
    //some code
}

if else

if (Bedingung) {
    //some code
} else {
    //some code
}

if else if

if (Bedingung) {
    //some code
} else if (Bedingung) {
    //some code
} else {
    //some code
}

switch (case)

switch (Variable) {
    case Wert1:
        //some code
        break;
    case Wert2:
        //some code
        break;
    default:
        //some code
}

while

while (Bedingung) {
    //some code
}

do while

do {
    //some code
} while (Bedingung);

for

for (int i = 0; i < Anzahl; i++) {
    //some code
}

for each

for (Datentyp variablenname : Array) {
    //some code
}

Konsole

Ausgabe

System.out.println("Text");

Eingabe

import java.util.Scanner;

Klassenname {
        Scanner scanner = new Scanner(System.in);
        String eingabe = scanner.next();
        String eingabe = scanner.nextLine();
        int eingabe = scanner.nextInt();
        double eingabe = scanner.nextDouble();
        char eingabe = scanner.next().charAt(0);
}

Kommandozeilenargumente in Java

Syntax

public class MeineKlasse {
    public static void main(String[] args) {
        // Code zur Verwendung der Kommandozeilenargumente
    }
}

Beschreibung

Kommandozeilenargumente ermöglichen es, Werte an ein Java-Programm zu übergeben, wenn es gestartet wird. Die Argumente werden in Form von Zeichenketten (Strings) übergeben und stehen in der main-Methode des Programms als Array args zur Verfügung.

Verwendung

Um das Java-Programm mit Kommandozeilenargumenten auszuführen, geben Sie diese nach dem Befehl java gefolgt vom Klassennamen an. Die Argumente werden durch Leerzeichen getrennt.

java MeineKlasse argument1 argument2 argument3 ...

java -jar MeinProgramm.jar argument1 argument2 argument3 ...

In der main-Methode des Java-Programms können die übergebenen Argumente im Array args verarbeitet werden. Hier ein Beispiel, wie man alle übergebenen Argumente ausgibt:

public class MeineKlasse {
    public static void main(String[] args) {
        // Ausgabe aller übergebenen Argumente
        for (int i = 0; i < args.length; i++) {
            System.out.println("Argument " + i + ": " + args[i]);
        }
    }
}

public class MeinProgramm {
    public static void main(String[] args) {
            // Ausgabe der übergebenen Argumente mit einer Foreach-Schleife
            System.out.println("Übergebene Argumente:");
            int index = 0;
            for (String arg : args) {
                System.out.println("Argument " + index + ": " + arg);
                index++;
            }
        }
    }

Hinweis

Kommandozeilenargumente werden immer als Zeichenketten (Strings) übergeben. Wenn andere Datentypen benötigt werden, müssen sie entsprechend geparst oder konvertiert werden.
Wenn keine Argumente übergeben werden, ist das args-Array leer (mit der Länge 0). In diesem Fall wird die for-Schleife bzw. foreach-Schleife nicht ausgeführt und es erfolgt keine Ausgabe.