Zum Inhalt springen

Umstieg auf IntelliJ IDEA

In Woche 1 haben wir mit Eclipse gearbeitet. In dieser Woche wechseln wir zu IntelliJ IDEA – der IDE, die in vielen Firmen gesetzt ist. Neuer Java-Stoff kommt in diesem Kapitel nicht dazu: Wir bauen ein kleines Programm mit dem, was du schon kannst, und lernen dabei die neue Umgebung kennen.

  • IntelliJ installieren und mit deinem JDK verbinden
  • ein Java-Projekt ohne Maven anlegen, starten und mit Argumenten aufrufen
  • die Begriffe Projekt und Modul den Begriffen aus Eclipse zuordnen
  • die wichtigsten Tastenkürzel von IntelliJ benutzen

Demo-Code: 16-verbrauch

⤓ demo-verbrauch.zip herunterladen

Der fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.

Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 16-verbrauch wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen. Die Startkonfiguration Verbrauch ist schon eingerichtet.

Enthält: Fahrt.java, Verbrauch.java

Auch IntelliJ installieren wir als ZIP-Datei, ohne Installer.

  1. Öffne jetbrains.com/idea/download und wähle bei Windows in der Auswahl neben dem Download-Knopf .zip statt .exe.

  2. Entpacke die ZIP-Datei nach C:\dev\tools\idea.

  3. Starte C:\dev\tools\idea\bin\idea64.exe und hefte IntelliJ an die Taskleiste an.

Eclipse und IntelliJ verwenden dieselben Wörter – aber nicht für dieselben Dinge:

Eclipse IntelliJ Bedeutung
Workspace – Eclipse: ein Ordner mit vielen Projekten in einem Fenster
Projekt Projekt IntelliJ: ein Ordner, ein Fenster pro Projekt
Projekt Modul ein Teil eines Projekts mit eigenem Quelltext und eigenem Classpath
.project, .classpath .idea\, *.iml Einstellungen der IDE im Projektordner
bin out übersetzte .class-Dateien

Einen Workspace gibt es in IntelliJ nicht. Ein Projekt ist einfach ein Ordner. Wir legen alle IntelliJ-Projekte in einen gemeinsamen Ordner:

C:\dev\intellij

Ein einfaches Projekt besteht aus genau einem Modul mit demselben Namen – dann merkst du vom Unterschied nichts. Mehrere Module bekommen wir erst mit Maven.

  1. Wähle im Startfenster New Project (später: File → New → Project…).

  2. Wähle links Java und fülle rechts aus:

    Feld Eintrag
    Name 16-verbrauch
    Location C:\dev\intellij
    Create Git repository kein Häkchen
    Build system IntelliJ
    JDK dein JDK 21 – siehe unten
    Add sample code kein Häkchen
  3. Steht bei JDK noch nichts: Öffne die Auswahl → Add JDK from disk… → wähle C:\dev\tools\jdk-21 → OK.

  4. Klicke auf Create.

Das Projekt öffnet sich in einem eigenen Fenster. Links im Fenster Project siehst du:

  • Ordner16-verbrauch
    • .idea\ Einstellungen von IntelliJ – nicht anfassen
    • src\ der Quelltext
    • 16-verbrauch.iml das Modul
  • OrdnerExternal Libraries
    • < 21 > das JDK

Wie in Eclipse beschränken wir uns auf Java 21. Mit dem JDK 21 steht der Sprachstand schon richtig – ein Blick schadet trotzdem nicht, denn mit einem neueren JDK wäre er höher:

  1. Öffne File → Project Structure… (Strg+Alt+Umschalt+S).
  2. Wähle links Project und stelle Language level auf 21.
  3. Klicke auf OK.
  1. Klicke mit rechts auf src → New → Package. Name: de.drv.fahrt → Enter.

  2. Klicke mit rechts auf das Package → New → Java Class. Name: Fahrt → Enter.

  3. Tippe die Klasse:

    Fahrt.java
    package de.drv.fahrt;
    /** Eine Fahrt mit der gefahrenen Strecke und dem dabei getankten Kraftstoff. */
    public class Fahrt {
    private final double kilometer;
    private final double liter;
    }

Den Konstruktor, die Getter und toString() musst du nicht von Hand schreiben. Setze den Cursor in die Klasse und drücke Alt+Einfg (Generate):

  • Constructor → beide Felder markieren → OK
  • Getter → beide Felder → OK

Dazu schreiben wir zwei eigene Methoden und toString():

Fahrt.java (Ausschnitt)
/** Verbrauch in Litern pro 100 Kilometer. */
public double getVerbrauch() {
return liter / kilometer * 100;
}
/** Wie weit man mit diesem Verbrauch und einem vollen Tank kommt. */
public double reichweite(double tankinhalt) {
return tankinhalt / getVerbrauch() * 100;
}
@Override
public String toString() {
return String.format("%.1f km mit %.1f l – Verbrauch %.2f l/100 km", kilometer, liter, getVerbrauch());
}

Lege im selben Package die Klasse Verbrauch an. Tippe in der Klasse psvm (für public static void main) und drücke Tab – IntelliJ erzeugt die main-Methode. Genauso wird aus sout + Tab ein System.out.println();.

Verbrauch.java
package de.drv.fahrt;
public class Verbrauch {
public static void main(String[] args) {
if (args.length != 2) {
System.out.println("Aufruf: Verbrauch <Kilometer> <Liter>");
return;
}
double kilometer = Double.parseDouble(args[0]);
double liter = Double.parseDouble(args[1]);
Fahrt fahrt = new Fahrt(kilometer, liter);
System.out.println(fahrt);
System.out.printf("Reichweite mit 50 l: %.0f km%n", fahrt.reichweite(50));
}
}

Links neben public class Verbrauch steht ein grünes Dreieck. Klicke darauf → Run ‘Verbrauch.main()’. Unten öffnet sich das Fenster Run:

Terminal-Fenster
Aufruf: Verbrauch <Kilometer> <Liter>

Das Programm läuft – aber ohne Argumente.

IntelliJ hat beim Start eine Run Configuration namens Verbrauch angelegt. Du findest sie oben in der Werkzeugleiste neben dem grünen Dreieck.

  1. Öffne die Auswahl Verbrauch → Edit Configurations….
  2. Trage bei Program arguments ein: 523 38.7
  3. Klicke auf OK und starte mit Umschalt+F10.
Terminal-Fenster
523,0 km mit 38,7 l – Verbrauch 7,40 l/100 km
Reichweite mit 50 l: 676 km

Wieder gilt: Argumente mit Punkt, die Ausgabe von printf und String.format mit Komma – siehe Ein- und Ausgabe.

Die erste Zeile im Fenster Run ist der Befehl, mit dem IntelliJ das Programm gestartet hat. Klicke darauf, um ihn ganz zu sehen: java.exe aus deinem JDK, -classpath mit dem Ordner out\production\16-verbrauch und am Ende de.drv.fahrt.Verbrauch 523 38.7. Im Kern dein Befehl aus Woche 1.

Aufgabe Eclipse IntelliJ
Vervollständigen Strg+Leertaste Strg+Leertaste
Fehler beheben (Quick Fix) Strg+1 Alt+Enter
Code erzeugen (Konstruktor, Getter, toString) Alt+Umschalt+S Alt+Einfg
Formatieren Strg+Umschalt+F Strg+Alt+L
Imports aufräumen Strg+Umschalt+O Strg+Alt+O
Umbenennen Alt+Umschalt+R Umschalt+F6
Klasse oder Datei suchen Strg+Umschalt+T / R 2× Umschalt (Search Everywhere)
Zeile löschen Strg+D Strg+X
Zeile duplizieren Strg+Alt+↓ Strg+D
Starten / erneut starten Strg+F11 Umschalt+F10
Debuggen F11 Umschalt+F9
main-Methode main + Strg+Leertaste psvm + Tab
System.out.println() sysout + Strg+Leertaste sout + Tab

Lege ein neues Projekt 17-rechner an – mit denselben Einstellungen wie 16-verbrauch – und schreibe ein eigenes kleines Programm. Was es berechnet, entscheidest du. Ideen:

  • BMI: Gewicht und Größe → Body-Mass-Index und Einstufung
  • Raum: Länge, Breite, Höhe → Bodenfläche, Wandfläche, Volumen
  • Temperatur: Grad Celsius → Fahrenheit und Kelvin
  • Notenschnitt: beliebig viele Noten → Durchschnitt, beste und schlechteste
  • Geburtstag: Geburtsdatum → Alter in Jahren und Tage bis zum nächsten Geburtstag

Arbeite die Stufen der Reihe nach ab – so weit du kommst:

  1. Grundlage: Das Programm liest seine Werte aus den Programmargumenten, rechnet und gibt das Ergebnis mit printf oder String.format formatiert aus. Starte es über eine eigene Run Configuration.

  2. Eigene Klasse: Die Werte und die Rechnung stecken in einer eigenen Klasse mit Feldern, Konstruktor, Methoden und toString() – so wie Fahrt. Das Hauptprogramm erzeugt nur noch das Objekt und gibt es aus. Lass dir Konstruktor und Getter mit Alt+Einfg erzeugen.

  3. Robust: Fehlen Argumente, zeigt das Programm, wie es aufgerufen wird. Ist ein Argument keine Zahl, kommt eine verständliche Meldung statt einer NumberFormatException. Ungültige Werte (etwa eine Größe von 0) lehnt der Konstruktor mit einer IllegalArgumentException ab.

  4. Für Schnelle: Gib zusätzlich eine Tabelle aus – zum Beispiel den BMI für verschiedene Gewichte bei gleicher Größe. Richte die Spalten mit Feldbreiten wie %6.1f sauber aus.

Lösung

Eine mögliche Lösung für die Idee BMI, mit allen vier Stufen. Die Einstufung ist eine einfache if-Kette: Weil die Grenzen von unten nach oben geprüft werden, reicht jeweils ein Vergleich.

Messung.java
package de.drv.bmi;
/** Gewicht und Körpergröße einer Person – daraus ergibt sich der Body-Mass-Index. */
public class Messung {
private final double gewicht;
private final double groesse;
/**
* @param gewicht in Kilogramm
* @param groesse in Metern
*/
public Messung(double gewicht, double groesse) {
if (gewicht <= 0 || groesse <= 0) {
throw new IllegalArgumentException("Gewicht und Größe müssen größer als 0 sein.");
}
this.gewicht = gewicht;
this.groesse = groesse;
}
public double getBmi() {
return gewicht / (groesse * groesse);
}
/** Einstufung nach der Tabelle der Weltgesundheitsorganisation (vereinfacht). */
public String getEinstufung() {
double bmi = getBmi();
if (bmi < 18.5) {
return "Untergewicht";
} else if (bmi < 25) {
return "Normalgewicht";
} else if (bmi < 30) {
return "Übergewicht";
} else {
return "Adipositas";
}
}
@Override
public String toString() {
return String.format("%.1f kg bei %.2f m: BMI %.1f (%s)", gewicht, groesse, getBmi(), getEinstufung());
}
}
Lösung
Terminal-Fenster
72,5 kg bei 1,80 m: BMI 22,4 (Normalgewicht)
Gewicht BMI Einstufung
50 kg 15,4 Untergewicht
60 kg 18,5 Normalgewicht
70 kg 21,6 Normalgewicht
80 kg 24,7 Normalgewicht
90 kg 27,8 Übergewicht
100 kg 30,9 Adipositas
110 kg 34,0 Adipositas

Die beiden catch-Blöcke stehen in dieser Reihenfolge, weil NumberFormatException eine Unterklasse von IllegalArgumentException ist. Umgekehrt würde der zweite Block nie erreicht – das lehnt schon der Compiler ab.

BmiRechner.java
package de.drv.bmi;
public class BmiRechner {
public static void main(String[] args) {
if (args.length != 2) {
System.out.println("Aufruf: BmiRechner <Gewicht in kg> <Größe in m>");
System.out.println("Beispiel: BmiRechner 72.5 1.80");
return;
}
Messung messung;
try {
messung = new Messung(Double.parseDouble(args[0]), Double.parseDouble(args[1]));
} catch (NumberFormatException e) {
System.out.println("Bitte Zahlen mit Punkt angeben, z. B. 72.5 – nicht: " + e.getMessage());
return;
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
System.out.println(messung);
// Für Schnelle: dieselbe Größe mit anderen Gewichten als Tabelle
System.out.println();
System.out.printf("%8s %6s %s%n", "Gewicht", "BMI", "Einstufung");
for (int gewicht = 50; gewicht <= 110; gewicht += 10) {
Messung zeile = new Messung(gewicht, Double.parseDouble(args[1]));
System.out.printf("%5d kg %6.1f %s%n", gewicht, zeile.getBmi(), zeile.getEinstufung());
}
}
}