Java für Anfänger: Installation, Syntax und Beispiele

Java ist eine der gefragtesten Programmiersprachen der Welt. Laut dem TIOBE-Index ist sie seit mehr als zwei Jahrzehnten konstant unter den Top 3 der Sprachen.

Warum Java im Jahr 2025?

Bevor wir uns mit den technischen Details befassen, ist es wichtig zu verstehen, was Java zu einer relevanten Wahl macht. Diese Sprache wird in kritischen Systemen von Banken, Regierungsbehörden und großen Internetunternehmen verwendet. Netflix, Amazon, LinkedIn, Twitter — sie alle basieren auf Java.

Die wichtigsten Vorteile von Java für einen unerfahrenen Entwickler:

Write Once, Run Anywhere

In Java geschriebener Code läuft auf jeder Plattform, auf der JVM (Java Virtual Machine) installiert ist. Haben Sie eine Anwendung für macOS entwickelt? Sie funktioniert unverändert unter Windows und Linux.

Strenge Typisierung

Java zwingt Sie, Variablentypen explizit anzugeben, was zunächst überflüssig erscheinen mag, aber es lehrt Sie, vorhersehbaren und zuverlässigen Code zu schreiben. Viele Fehler werden Sie bereits in der Kompilierungsphase und nicht erst in der Produktion feststellen.

Riesiges Ökosystem

Millionen vorgefertigter Bibliotheken für jede Aufgabe. Müssen Sie mit JSON arbeiten? Es gibt Gson und Jackson. REST-API erstellen? Spring Boot erledigt das in zehn Minuten. Große Datenmengen verarbeiten? Apache Hadoop und Spark stehen Ihnen zur Verfügung.

Nachfrage auf dem Arbeitsmarkt

Die Nachfrage nach Java-Entwicklern ist konstant hoch und die Gehälter sind wettbewerbsfähig. Backend, Android, Datenverarbeitungssysteme – die Auswahl an Spezialisierungen ist riesig.

Installation und Einrichtung der Umgebung

Schritt 1: JDK installieren

JDK (Java Development Kit) ist ein Toolkit für die Java-Entwicklung. Im Jahr 2025 empfehle ich, mit der neuesten LTS-Version (Long-Term Support) zu beginnen. Zum Zeitpunkt des Schreibens ist dies Java 21.

Für Windows:

1. Laden Sie OpenJDK von Adoptium (Eclipse Temurin) oder Oracle JDK herunter

2. Führen Sie das Installationsprogramm aus

3. Fügen Sie den Pfad zu Java zur PATH-Umgebungsvariable hinzu

Für macOS:

# Mit Homebrew brew install openjdk@21 # Fügen Sie ~/.zshrc oder ~/.bash_profile export PATH="/opt/homebrew/opt/openjdk@21/bin:$PATH" hinzu

Für Linux (Ubuntu/Debian):

sudo apt update sudo apt install openjdk-21-jdk

Überprüfen Sie die Installation:

java -version javac -version

Sie sollten Informationen zur Java-Version sehen. Wenn keine Befehle gefunden werden, überprüfen Sie den PATH.

Schritt 2: Auswahl einer IDE

Für ernsthafte Arbeit mit Java benötigen Sie eine gute IDE. Drei Hauptoptionen:

IntelliJ IDEA - der unangefochtene Marktführer. Die Community Edition ist kostenlos und enthält alles, was Sie zum Erlernen von Java benötigen. Intelligente automatische Vervollständigung, integrierter Debugger, Git-Integration, Maven- und Gradle-Unterstützung von Anfang an.

Eclipse - ein alter Hase der Branche, völlig kostenlos. Etwas langsamer als IDEA, aber sehr funktional.

Visual Studio Code — eine leichte Version mit dem Plugin Extension Pack für Java. Geeignet, wenn Sie an VS Code gewöhnt sind, aber für Java ist es besser, eine vollwertige IDE zu verwenden.

Tipp: Ich empfehle, mit der IntelliJ IDEA Community Edition zu beginnen. Laden Sie es von der offiziellen JetBrains-Website herunter, installieren Sie es und schon kann es losgehen.

Struktur eines Java-Programms

Erstellen Sie das erste Projekt. In IntelliJ IDEA: File → New → Project → wählen Sie Java, geben Sie JDK an, erstellen Sie ein Projekt.

Jedes Java-Programm beginnt mit der Klasse und der Methode main:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java World!");
    }
}

Lassen Sie uns Zeile für Zeile analysieren:

public class HelloWorld - Klassendeklaration. In Java ist alles eine Klasse. Der Klassenname muss mit dem Dateinamen übereinstimmen (HelloWorld.java).

public static void main(String[] args) — Einstiegspunkt in das Programm.

• public — Methode ist von überall verfügbar

• static — Die Methode gehört zur Klasse, nicht zum Objekt

• void — Methode gibt nichts zurück

• String[] args — Array von Befehlszeilenargumenten

System.out.println() - Ausgabe von Text in die Konsole mit Zeilenumbruch.

Zum Kompilieren und Ausführen vom Terminal:

javac HelloWorld.java # Kompilieren in HelloWorld.class java HelloWorld # Programm starten

Grundlagen der Syntax: Variablen und Datentypen

Java ist eine stark typisierte Sprache. Jede Variable hat einen Typ, der bei der Deklaration angegeben wird:

public class DataTypes {
    public static void main(String[] args) {
        // Ganze Zahlen
        byte smallNumber = 127;           // -128 bis 127
        short mediumNumber = 32000;       // -32,768 bis 32,767
        int regularNumber = 1000000;      // -2^31 bis 2^31-1
        long bigNumber = 9000000000L;     // -2^63 bis 2^63-1 (L am Ende!)
        
        // Gleitkommazahlen
        float price = 19.99f;             // 32-Bit (f am Ende!)
        double precise = 3.14159265359;   // 64-Bit, Standard
        
        // Symbole und Zeichen
        char grade = 'A';                 // Ein Zeichen
        String name = "Java Developer";   // Zeile (Objekt!)
        
        // Logischer Typ
        boolean isActive = true;
        boolean hasErrors = false;
        
        // Fazit
        System.out.println("Name: " + name);
        System.out.println("Price: $" + price);
        System.out.println("Active: " + isActive);
    }
}

Wichtige Nuancen

String ist ein Objekt, keine Primitiven. Strings in Java sind unveränderlich (immutable). Jede Verkettungsoperation erzeugt eine neue Zeichenfolge.

Automatische Typumwandlung arbeitet sicher von klein nach groß:

int x = 100;
long y = x;  // OK, int passt in long
double z = y; // OK, long passt in double

Die umgekehrte Richtung erfordert eine explizite Umwandlung:

double pi = 3.14;
int rounded = (int) pi;  // Explizite Umwandlung, der Bruchteil wird verworfen

Operatoren und Kontrollstrukturen

Bedingte Operatoren

public class ControlFlow {
    public static void main(String[] args) {
        int score = 85;
        
        // If-else
        if (score >= 90) {
            System.out.println("Excellent!");
        } else if (score >= 70) {
            System.out.println("Good");
        } else if (score >= 50) {
            System.out.println("Satisfactory");
        } else {
            System.out.println("Needs improvement");
        }
        
        // Switch (moderne Syntax Java 14+)
        String day = "Monday";
        String mood = switch (day) {
            case "Monday" -> "Beginning of the week";
            case "Friday" -> "It's almost the weekend!";
            case "Saturday", "Sunday" -> "Weekend!";
            default -> "Ordinary day";
        };
        System.out.println(mood);
        
        // Ternärer Operator
        String result = score >= 50 ? "Passed" : "Fail";
    }
}

Zyklen

public class Loops {
    public static void main(String[] args) {
        // Für - wenn wir die Anzahl der Iterationen kennen
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }
        
        // Während - während die Bedingung wahr ist
        int count = 0;
        while (count < 3) {
            System.out.println("Count: " + count);
            count++;
        }
        
        // Do-while - wird mindestens einmal ausgeführt
        int num = 10;
        do {
            System.out.println("Number: " + num);
            num--;
        } while (num > 5);
        
        // Verbessert für (für Sammlungen und Arrays)
        int[] numbers = {1, 2, 3, 4, 5};
        for (int n : numbers) {
            System.out.println(n);
        }
    }
}

Arrays und Sammlungen

Arrays in Java haben eine feste Größe:

public class ArraysExample {
    public static void main(String[] args) {
        // Ankündigung und Initialisierung
        int[] numbers = new int[5];  // Array von 5 Elementen
        numbers[0] = 10;
        numbers[1] = 20;
        
        // Sofort mit Werten
        String[] names = {"Alice", "Bob", "Charlie"};
        
        // Zweidimensionales Array
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // Durchsuchung
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
        
        // Oder einfacher
        for (String name : names) {
            System

Für dynamische Strukturen verwenden wir Sammlungen:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList - dynamisches Array
        List<String> cities = new ArrayList<>();
        cities.add("Moscow");
        cities.add("St. Petersburg");
        cities.add("Kazan");
        cities.remove("Kazan");
        
        System.out.println("Size: " + cities.size());
        System.out.println("First: " + cities.get(0));
        
        // HashMap - Schlüsselwert
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 28);
        
        System.out.println("Bob's age: " + ages.get("Bob"));
        
        // HashMap-Durchlauf
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        
        // HashSet - einzigartige Elemente
        Set<Integer> uniqueNumbers = new HashSet<>();
        uniqueNumbers.add(1);
        uniqueNumbers.add(2);
        uniqueNumbers.add(2);  // Duplikat, wird nicht hinzugefügt
        
        System.out.println("Set Size: " + uniqueNumbers.size()); // 2
    }
}

Objektorientierte Programmierung

Java ist eine reine OOP-Sprache. Alles ist ein Objekt (außer Primitiven).

// Bestimmung der Klasse
public class User {
    // Felder (Eigenschaften)
    private String name;
    private int age;
    private String email;
    
    // Konstrukteur
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    // Getter und Setter
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    // Methoden
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Email: " + email);
    }
    
    public boolean isAdult() {
        return age >= 18;
    }
}

// Anwendung
public class Main {
    public static void main(String[] args) {
        User user = new User("Alexey", 25, "alex@example.com");
        user.displayInfo();
        
        if (user.isAdult()) {
            System.out.println(user.getName() + " adult");
        }
    }
}

Java ist nicht nur eine Sprache, sondern ein ganzes Ökosystem.

Fangen Sie klein an, schreiben Sie jeden Tag Code, nehmen Sie an Kursen teil Kodike und Schließen Sie sich uns an zu unserer freundlichen Entwickler-Community in Telegram-Kanal. Nach drei Monaten regelmäßiger Übung werden Sie sicher in Java schreiben können, und nach sechs Monaten können Sie sich für eine Stelle als Junior-Entwickler bewerben. Viel Erfolg beim Lernen!