Java 11 - Neue Funktionen

Hallo da draußen, angehende Java-Programmierer! Ich freue mich sehr, Ihr Guide auf dieser aufregenden Reise in die Welt von Java 11 zu sein. Als jemand, der seit vielen Jahren Informatik unterrichtet, habe ich unzählige Schüler gesehen, die von kompletten Anfängern zu selbstbewussten Programmierern geworden sind. Also keine Sorge, wenn Sie von vorne anfangen – wir gehen Schritt für Schritt vor, und bald werden Sie Java-Code wie ein Profi schreiben!

Java-Steuersätze

Lassen Sie mit den Grundlagen beginnen. Steuersätze sind wie die Ampeln im Programmieren – sie lenken den Fluss Ihres Codes. In Java 11 haben wir einige schlaue Möglichkeiten, die Ausführung unseres Programms zu steuern.

If-Else-Anweisungen

Die if-else-Anweisung ist wahrscheinlich die häufigste Kontrollstruktur, die Sie verwenden werden. Es ist wie eine Entscheidung im echten Leben zu treffen. Hier ist ein einfaches Beispiel:

int alter = 18;
if (alter >= 18) {
System.out.println("Du kannst wählen!");
} else {
System.out.println("Entschuldigung, du bist zu jung zum Wählen.");
}

In diesem Code überprüfen wir, ob die Variable alter 18 oder älter ist. Wenn ja, drucken wir, dass die Person wählen kann. Wenn nicht, sagen wir ihnen, dass sie zu jung sind. Es ist so einfach!

Switch-Anweisungen

Switch-Anweisungen sind großartig, wenn Sie mehrere Bedingungen überprüfen müssen. Denken Sie daran als eine effizientere Möglichkeit, mehrere if-else-Anweisungen zu schreiben. Java 11 hat einige coole Verbesserungen an Switch-Anweisungen gebracht. Hier ist ein Beispiel:

String tag = "Montag";
switch (tag) {
case "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag" -> System.out.println("Wochentag");
case "Samstag", "Sonntag" -> System.out.println("Wochenende");
default -> System.out.println("Ungültiger Tag");
}

Diese Switch-Anweisung überprüft die Variable tag und druckt, ob es ein Wochentag oder Wochenende ist. Die Pfeilsyntax (->) ist neu in Java 11 und macht den Code kompakter.

Objektorientierte Programmierung

Objektorientierte Programmierung (OOP) ist ein grundlegendes Konzept in Java. Es ist wie das Bauen mit LEGO-Steinen – Sie erstellen verschiedene Objekte, die miteinander interagieren, um Ihr Programm zu formen.

Klassen und Objekte

Eine Klasse ist wie ein Bauplan für das Erstellen von Objekten. Hier ist eine einfache Klasse, die ein Auto darstellt:

public class Auto {
String marke;
String modell;
int jahr;

public void starteMotor() {
System.out.println("Vroom! Der " + jahr + " " + marke + " " + modell + " startet.");
}
}

Jetzt erstellen wir ein Objekt aus dieser Klasse:

Auto meinAuto = new Auto();
meinAuto.marke = "Toyota";
meinAuto.modell = "Corolla";
meinAuto.jahr = 2021;
meinAuto.starteMotor();

Wenn Sie diesen Code ausführen, wird er ausgeben: "Vroom! Der 2021 Toyota Corolla startet."

Java-Built-in-Klassen

Java kommt mit einem reichen Satz von integrierten Klassen, die unser Leben einfacher machen. Sehen wir uns einige an:

String-Klasse

Die String-Klasse wird verwendet, um Text zu manipulieren. Hier ist ein Beispiel:

String begrussung = "Hallo, Welt!";
System.out.println(begrussung.length());  // Gibt aus: 13
System.out.println(begrussung.toUpperCase());  // Gibt aus: HELLO, WORLD!

ArrayList-Klasse

ArrayList ist ein dynamisches Array, das wachsen oder schrumpfen kann:

import java.util.ArrayList;

ArrayList<String> obst = new ArrayList<>();
obst.add("Apfel");
obst.add("Banane");
obst.add("Kirsche");
System.out.println(obst);  // Gibt aus: [Apfel, Banane, Kirsche]

Java-Dateihandhabung

Dateihandhabung ist entscheidend für das Lesen und Schreiben von Dateien. Java 11 hat einige neue Methoden eingeführt, um dies einfacher zu machen:

import java.nio.file.Files;
import java.nio.file.Path;

String inhalt = "Hallo, Java 11!";
Path dateipfad = Path.of("beispiel.txt");
Files.writeString(dateipfad, inhalt);

String gelesenerInhalt = Files.readString(dateipfad);
System.out.println(gelesenerInhalt);  // Gibt aus: Hallo, Java 11!

Dieser Code schreibt eine Zeichenkette in eine Datei und liest sie dann wieder. Die Methoden writeString und readString sind neu in Java 11 und machen Datei-E/A viel einfacher.

Java-Fehler und Ausnahmen

Fehler und Ausnahmen sind wie die Buckel und Löcher auf der Straße des Programmierens. Java hilft uns, diese elegant zu handhaben:

try {
int ergebnis = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Ups! Du kannst nicht durch null teilen.");
} finally {
System.out.println("Dies wird immer ausgeführt, egal ob Fehler oder nicht.");
}

Dieser Code versucht, durch null zu teilen (was in Mathematik ein No-Go ist), fängt die resultierende Ausnahme und gibt eine freundliche Nachricht aus anstelle des Absturzes.

Java-Mehrfachthreading

Mehrfachthreading ist wie das Jonglieren – es ermöglicht Ihrem Programm, mehrere Dinge gleichzeitig zu tun. Hier ist ein einfaches Beispiel:

class MeinThread extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Wert " + i);
}
}
}

public class Haupt {
public static void main(String args[]) {
MeinThread t1 = new MeinThread();
MeinThread t2 = new MeinThread();
t1.start();
t2.start();
}
}

Dies erstellt zwei Threads, die gleichzeitig ausgeführt werden und ihre Thread-ID und einen Wert ausgeben.

Java-Synchronisation

Wenn mehrere Threads auf gemeinsame Ressourcen zugreifen, müssen wir sie synchronisieren, um Konflikte zu vermeiden. Es ist wie das Have von Ampeln an einer Kreuzung:

class Zaehler {
private int zaehler = 0;
public synchronized void inkrementiere() {
zaehler++;
}
public int getZaehler() {
return zaehler;
}
}

Das Schlüsselwort synchronized stellt sicher, dass nur ein Thread die inkrementiere-Methode zur selben Zeit ausführen kann.

Java-Netzwerk

Java macht es einfach, vernetzte Anwendungen zu erstellen. Hier ist ein einfacher Server, der auf Verbindungen hört:

import java.net.*;
import java.io.*;

public class EinfacherServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("Server hört auf Port 8080");
Socket socket = serverSocket.accept();
System.out.println("Client verbunden");
}
}

Dieser Server hört auf Port 8080 und gibt eine Nachricht aus, wenn ein Client sich verbindet.

Java-Sammlungen

Java-Sammlungen sind wie verschiedene Arten von Behältern zum Speichern von Objekten. Sehen wir uns einige an:

List

import java.util.*;

List<String> obst = new ArrayList<>();
obst.add("Apfel");
obst.add("Banane");
System.out.println(obst);  // Gibt aus: [Apfel, Banane]

Set

Set<Integer> zahlen = new HashSet<>();
zahlen.add(1);
zahlen.add(2);
zahlen.add(1);  // Duplikat, wird nicht hinzugefügt
System.out.println(zahlen);  // Gibt aus: [1, 2]

Map

Map<String, Integer> alter = new HashMap<>();
alter.put("Alice", 25);
alter.put("Bob", 30);
System.out.println(alter.get("Alice"));  // Gibt aus: 25

Java-Schnittstellen

Schnittstellen sind wie Verträge, die Klassen zustimmen zu befolgen. Hier ist ein Beispiel:

interface Tier {
void machGeraeusch();
}

class Hund implements Tier {
public void machGeraeusch() {
System.out.println("Wuff!");
}
}

class Katze implements Tier {
public void machGeraeusch() {
System.out.println("Miau!");
}
}

Sowohl Hund als auch Katze implementieren die Tier-Schnittstelle und stimmen zu, eine machGeraeusch-Methode bereitzustellen.

Java-Datenstrukturen

Datenstrukturen sind Möglichkeiten, Daten zu organisieren und zu speichern. Sehen wir uns eine einfache verkettete Liste an:

class Knoten {
int daten;
Knoten naechster;

Knoten(int d) { daten = d; }
}

class VerketteteListe {
Knoten kopf;

public void hinzufuegen(int daten) {
Knoten neuerKnoten = new Knoten(daten);
if (kopf == null) {
kopf = neuerKnoten;
} else {
Knoten aktueller = kopf;
while (aktueller.naechster != null) {
aktueller = aktueller.naechster;
}
aktueller.naechster = neuerKnoten;
}
}

public void drucken() {
Knoten aktueller = kopf;
while (aktueller != null) {
System.out.print(aktueller.daten + " ");
aktueller = aktueller.naechster;
}
System.out.println();
}
}

public class Haupt {
public static void main(String[] args) {
VerketteteListe liste = new VerketteteListe();
liste.hinzufuegen(1);
liste.hinzufuegen(2);
liste.hinzufuegen(3);
liste.drucken();  // Gibt aus: 1 2 3
}
}

Dieser Code implementiert eine einfache verkettete Listen-Datenstruktur.

Java-Sammlungsalgorithmen

Java bietet viele nützliche Algorithmen für das Arbeiten mit Sammlungen. Hier ist ein Beispiel für Sortieren:

import java.util.*;

List<Integer> zahlen = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5));
Collections.sort(zahlen);
System.out.println(zahlen);  // Gibt aus: [1, 1, 2, 3, 4, 5, 5, 6, 9]

Fortgeschrittenes Java

Wenn Sie fortschreiten, werden Sie auf fortgeschrittene Java-Konzepte stoßen. Ein solches Konzept sind Lambda-Ausdrücke, die in Java 8 eingeführt und in Java 11 weiter verbessert wurden:

List<Integer> zahlen = Arrays.asList(1, 2, 3, 4, 5);
zahlen.forEach(n -> System.out.println(n * 2));

Dieser Code verwendet einen Lambda-Ausdruck, um jede Zahl zu verdoppeln und sie auszugeben.

Java Verschiedenes

Java 11 hat mehrere verschiedene neue Funktionen eingeführt. Eine davon ist das var-Schlüsselwort für lokale Variablen-Typ-Inferenz:

var nachricht = "Hallo, Java 11!";
System.out.println(nachricht);

Der Compiler inferiert, dass nachricht ein String ist.

Java-APIs und Frameworks

Java hat ein umfangreiches Ökosystem von APIs und Frameworks. Ein beliebtes Framework ist Spring Boot. Hier ist ein einfaches "Hello World" Spring Boot-Anwendung:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class HelloWorldApplication {

public static void main(String[] args) {
SpringApplication.run(HelloWorldApplication.class, args);
}

@GetMapping("/")
public String hello() {
return "Hallo, Welt!";
}
}

Dies erstellt eine Webanwendung, die mit "Hallo, Welt!" antwortet, wenn Sie die Wurzel-URL besuchen.

Java-Klassenreferenzen

Java ermöglicht es Ihnen, Referenzen auf Klassen zur Laufzeit zu erhalten. Hier ist ein Beispiel:

Class<?> stringClass = String.class;
System.out.println(stringClass.getName());  // Gibt aus: java.lang.String

Java-Nützliche Ressourcen

Hier sind einige nützliche Ressourcen für das Lernen von Java:

1. Offizielle Java-Dokumentation von Oracle
2. Java-Kurs von Codecademy
3. Buch "Head First Java"
4. Stack Overflow, um Fragen zu stellen

Neue Funktionen

Java 11 hat mehrere neue Funktionen eingeführt. Hier ist eine Tabelle, die einige von ihnen zusammenfasst:

Funktion	Beschreibung
Lokale Variablen-Syntax für Lambda-Parameter	Erlaubt var in Lambda-Ausdrücken
Standard-HTTP-Client	Standardisierte HTTP-Client-API
Einzeldatei-Quellcode-Programme starten	Direkte Ausführung von Java-Quellcode-Dateien
String-Methoden	Neue Methoden wie isBlank(), lines(), strip() usw.
Datei-Methoden	Neue Methoden wie readString(), writeString()

Das ist es für unsere rasante Tour durch Java 11! Denken Sie daran, dass das Lernen zu programmieren wie das Lernen einer neuen Sprache ist – es erfordert Übung, Geduld und Ausdauer. Lassen Sie sich nicht entmutigen, wenn Sie nicht alles auf Anhieb verstehen. Bleiben Sie am Code, experimentieren Sie und vor allem – haben Sie Spaß! Bald werden Sie komplexe Java-Anwendungen schreiben und sich wundern, wie schwierig es am Anfang schien. Viel Spaß beim Programmieren!

Credits: Image by storyset