Erste Java-Programme kompilieren und starten

Ein erstes Java-Programm gibt dem Computer eine kurze Liste von Anweisungen. Die umgebende Klasse und die main-Methode zeigen Java, wohin diese Anweisungen gehören und wo die Ausführung beginnt.

Anweisungen in main platzieren

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

Die äußeren Klammern schließen den Klassenrumpf ein. Die inneren Klammern schließen den Methodenrumpf ein. Beim Start dieses Programms führt Java die erste Anweisung innerhalb von main aus. Weitere darunter stehende Anweisungen werden von oben nach unten ausgeführt. Wenn main endet, endet auch dieses kleine Programm.

Übernimm public static void main(String[] args) sorgfältig. Dabei erlaubt public dem Programmstarter, die Methode aufzurufen, static ermöglicht ihre Ausführung ohne vorherige Erzeugung eines Objekts und void besagt, dass die Methode kein Ergebnis zurückgibt. String[] args nimmt Wörter entgegen, die auf der Kommandozeile nach dem Programmnamen eingegeben werden. Du kannst eine Meldung ausgeben, ohne diese Wörter zu verwenden.

Satzzeichen und Namen abstimmen

Eine Anweisung wie System.out.println("Hi"); endet mit einem Semikolon. Zu einer öffnenden Klammer { gehört eine schließende Klammer }. Die oben gezeigten Klassen- und Methodenköpfe öffnen Blöcke; ersetze diese öffnenden Klammern nicht durch Semikolons. Rückst du die Anweisung gegenüber ihrem Methodenkopf um vier Leerzeichen ein, wird die Verschachtelung sichtbar.

Speichere public class Hello in Hello.java. Der Name der öffentlichen Klasse und der Teil vor .java müssen genau übereinstimmen, einschließlich der Großschreibung. Lautet die Deklaration public class Other, muss die Datei Other.java heißen. Eine Compilermeldung, dass die Klasse in einer anderen Datei deklariert werden sollte, weist auf diese Abweichung hin.

Java unterscheidet Groß- und Kleinschreibung. Der Name System muss mit einem großen S beginnen; system.out.println("Hi"); lässt sich nicht kompilieren. Eine Methode namens Main ist eine andere Methode als main. Eine Klasse, die nur Main enthält, lässt sich zwar kompilieren, aber der Programmstarter findet beim Ausführen die vorgesehene Einstiegsmethode nicht.

Code lesbar gestalten

Verwende eine Anweisung pro Zeile und vier Leerzeichen Einrückung für jede Klammerebene. Die meisten Leerzeichen und Zeilenumbrüche zwischen Codeelementen beeinflussen das Kompilieren nicht. Leerzeichen innerhalb von Text in Anführungszeichen beeinflussen die Ausgabe. Klassennamen stehen üblicherweise in PascalCase, wie bei TravelTime.

Ein Kommentar erklärt Menschen den Code. Java ignoriert alles, was in einer Zeile auf // folgt. Ein Blockkommentar beginnt mit /*, endet mit */ und kann sich über mehrere Zeilen erstrecken. Ein nützlicher Kommentar erklärt einen Grund, etwa // Convert hours to seconds neben einer Umrechnung, deren Zweck unklar sein könnte.

Die kürzere Form erkennen

Java 25 und spätere Versionen unterstützen auch eine kompakte Quelldatei:

void main() {
    IO.println("Hello, world!");
}

Diese Form lässt die explizite Klassendeklaration weg. IO.println gibt eine Zeile aus und IO.readln("Your name: ") zeigt eine Eingabeaufforderung und gibt die eingegebene Zeile zurück. Die klassische Klassenform funktioniert auch mit älteren Java-Versionen; beide Formen enthalten eine main-Methode, in der die Ausführung beginnt.

Quellcode schreiben und ein Programm ausführen sind getrennte Schritte. Java prüft und übersetzt zuerst deinen Code und führt ihn dann aus. Wenn du weißt, welcher Schritt fehlgeschlagen ist, kannst du entscheiden, wo du suchen musst.

Quellcode kompilieren, dann die Klasse starten

Quellcode ist der Text in einer .java-Datei. Der Compiler javac übersetzt gültigen Quellcode in Bytecode in einer .class-Datei. Die Java Virtual Machine (JVM) führt diesen Bytecode aus. Eine geeignete JVM ermöglicht es, denselben Bytecode auf verschiedenen Betriebssystemen auszuführen.

Öffne ein Terminal im Ordner, der Hello.java enthält, und gib ein:

javac Hello.java
java Hello

Der erste Befehl erstellt bei erfolgreicher Kompilierung Hello.class. Der zweite startet das Programm. Sein Argument ist der Klassenname ohne .class: Bei java Hello.class sucht der Programmstarter nach dem falschen Klassennamen und schlägt fehl.

Das JDK, das Java Development Kit, stellt beide Befehle bereit. Eine IDE, etwa IntelliJ IDEA, Eclipse, NetBeans oder Visual Studio Code mit Java-Unterstützung, kompiliert und startet das Programm, wenn du auf die entsprechende Schaltfläche klickst. Sie kann Fehler schon während der Eingabe markieren, aber es sind dennoch Fehler in derselben Sprache Java.

Seit Java 11 bietet der Quelldateimodus eine Abkürzung für ein einzelnes kleines Programm:

java Hello.java

Dies kompiliert den Quellcode im Arbeitsspeicher und führt ihn aus, ohne eine .class-Datei zu hinterlassen. Unterscheide die beiden Formen: java Hello startet eine kompilierte Klasse, während java Hello.java Quellcode startet.

Kompilierfehler lesen

Ein Kompilierfehler verhindert eine erfolgreiche Kompilierung. Ein fehlendes Semikolon kann zum Beispiel Folgendes auslösen:

Hello.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^

Die Meldung nennt Datei, Zeile und die Stelle, an der der Compiler das Problem bemerkt hat. Der eigentliche Fehler kann früher liegen: Ein nicht geschlossenes Anführungszeichen in einer Zeile kann spätere Zeilen durcheinanderbringen. Lies die markierte Zeile und die davor. Behebe den ersten gemeldeten Fehler und kompiliere erneut, bevor du mehrere andere Zeilen änderst. Eine Korrektur kann viele spätere Meldungen beseitigen.

Laufzeitfehler und falsche Ergebnisse unterscheiden

Enthält eine ganzzahlige Variable divisor den Wert null, schlägt 5 / divisor während der Ausführung mit ArithmeticException: / by zero fehl. Die Rechenanweisung kann gültiger Quellcode sein, obwohl ihre Werte zur Laufzeit zum Fehler führen.

Ein Programm, das einen Mittelwert von 8 ausgibt, obwohl der korrekte Wert etwa 8,33 beträgt, hat einen Logikfehler. Keine Compilermeldung kann dir sagen, dass dies für deine Aufgabe das falsche Ergebnis ist. Teste mit bekannten Eingaben, prüfe Zwischenwerte und suche die erste falsche Berechnung.

Arbeite in einem kurzen Zyklus: bearbeiten, speichern, kompilieren, starten, testen. Das Speichern ist wichtig: Der Compiler liest die gespeicherte Datei, daher können ungespeicherte Änderungen das kompilierte Programm nicht verändern.

Ausgaben sind die erste Möglichkeit zu sehen, was ein Programm tut. Java lässt dich steuern, welche Zeichen ausgegeben werden und wo die nächste Zeile beginnt.

Die Ausgabeposition verfolgen

System.out.print(...) gibt seinen Wert aus und belässt die Ausgabeposition in derselben Zeile. System.out.println(...) gibt seinen Wert aus und beginnt dann eine neue Zeile. Ein Aufruf von System.out.println() mit leeren Klammern fügt nur einen Zeilenumbruch hinzu.

System.out.print("Hello");
System.out.print(", ");
System.out.println("world");
System.out.println("Bye");

Nach den ersten beiden Aufrufen steht die Ausgabeposition hinter dem Leerzeichen nach dem Komma. Der dritte fügt an dieser Stelle world hinzu und wechselt dann in eine neue Zeile. Die genaue Ausgabe lautet:

Hello, world
Bye

Java fügt zwischen Aufrufen keine Leerzeichen ein. Entfernst du das Leerzeichen in ", ", lautet die erste Zeile „Hello,world“. Ein leeres println() zwischen den letzten beiden Anweisungen würde eine Leerzeile zwischen den Meldungen erzeugen.

Zwischen Text und Wert unterscheiden

Ein Stringliteral ist Text in doppelten Anführungszeichen. Die Ausgabe von "7 * 6" zeigt den Text „7 * 6“. Die Ausgabe von 7 * 6 wertet die Multiplikation aus und zeigt „42“. Die Anführungszeichen sind Satzzeichen des Codes; sie werden nicht als Teil des Literals ausgegeben.

Enthält name den Wert „Ada“, zeigt System.out.println(name); entsprechend „Ada“, während System.out.println("name"); „name“ anzeigt. Verwende die Variable ohne Anführungszeichen, wenn du ihren gespeicherten Wert möchtest.

Einfache Anführungszeichen haben eine andere Aufgabe. 'A' ist ein einzelner char-Wert. 'Hello' kann keine Nachricht aus mehreren Zeichen enthalten und verursacht einen Kompilierfehler. Verwende "Hello" für diesen Text.

Sonderzeichen in einen String einfügen

Eine Escape-Sequenz beginnt mit einem umgekehrten Schrägstrich und steht für ein Zeichen innerhalb des Literals.

Zum Beispiel:

System.out.println("She said \"hi\"");
System.out.println("C:\\Users");

Diese Anweisungen zeigen She said "hi" und C:\Users in getrennten Zeilen. Die zusätzlichen umgekehrten Schrägstriche zeigen Java, wie das folgende Zeichen zu deuten ist; sie werden nicht alle in die Ausgabe übernommen.

Ein einzelner Aufruf kann auch mehrere Zeilen ausgeben:

System.out.println("Name:\tAda\nAge:\t36");

Der Tabulator trennt die Beschriftung vom Wert, und \n setzt das Alter in die nächste Zeile. Der println-Aufruf fügt außerdem einen eigenen abschließenden Zeilenumbruch hinzu. Ein Tabulator springt zu einem Tabstopp, daher hängt seine sichtbare Breite von der Ausgabeumgebung ab.

Ein gewöhnliches Stringliteral in Anführungszeichen muss in derselben Quellcodezeile geöffnet und geschlossen werden. Drückst du mittendrin die Eingabetaste, bleibt das Literal ungeschlossen. Um eine lange Nachricht auf mehrere Quellcodezeilen aufzuteilen, schreibe zwei vollständige, mit + verbundene Literale oder verwende getrennte Ausgabeaufrufe.

Eine Variable gibt einem Wert einen Namen, damit spätere Anweisungen ihn verwenden können. Ihr Datentyp sagt Java, welche Art von Wert sie enthalten kann; eine Zuweisung ändert den gespeicherten Wert.

Deklarieren und initialisieren

int age;
age = 36;

Die Deklaration führt age als int ein. Die Zuweisung speichert 36. Die kombinierte Form int age = 36; heißt Initialisierung. Einer lokalen Variablen muss ein Wert zugewiesen werden, bevor du sie ausliest. Deklarierst du int age; und gibst age sofort aus, erhältst du einen Fehler, dass die Variable möglicherweise nicht initialisiert wurde.

Deklariere einen Namen im selben Methodenrumpf nur einmal. Um seinen Wert später zu ändern, schreibe age = 37;, ohne int zu wiederholen. Ein zweites int age = 37; in diesem Rumpf versucht, dieselbe Variable erneut zu deklarieren.

Zuweisungen von rechts nach links lesen

Die rechte Seite von = wird zuerst berechnet. Dann speichert Java das Ergebnis in der Variablen auf der linken Seite:

int count = 5;
count = count + 1;

Die zweite Anweisung liest den aktuellen Wert 5, addiert 1 und speichert 6. Das Zeichen = bedeutet Zuweisung, keine mathematische Aussage, dass eine Zahl gleich sich selbst plus eins ist. Die linke Seite muss einen Speicherort für den Wert benennen; 36 = age; ist ungültig.

Eine Zuweisung kopiert den Wert zum jeweiligen Zeitpunkt:

int a = 5;
int b = a;
a = 10;

Nun enthält a den Wert 10 und b den Wert 5. Es gibt keine dauerhafte Verknüpfung, die b neu berechnet, wenn sich a ändert.

Einen Tausch nachvollziehen

Angenommen, first enthält 4 und second enthält 9. Die Folge first = second; second = first; verliert die 4 im ersten Schritt und lässt beide Werte bei 9. Sichere zuerst den ursprünglichen Wert:

int temp = first;
first = second;
second = temp;

Eine Ablauftabelle hält jede Variable nach jeder Anweisung fest. Für int x = 3; x = x * 2; x = x + 1; lauten die Werte zunächst 3, dann 6 und schließlich 7. Aktualisiere jeweils eine Zeile anhand der zuletzt gespeicherten Werte.

Nützliche Namen und feste Typen wählen

Namen dürfen Buchstaben, Ziffern, Unterstriche und Dollarzeichen enthalten. Sie dürfen weder mit einer Ziffer beginnen noch ein reserviertes Wort wie class sein. Groß- und Kleinschreibung sind wichtig: total und Total unterscheiden sich. Verwende aussagekräftige Namen in camelCase wie distanceKm oder secondsLeft.

Einer final-Variablen kann nur einmal ein Wert zugewiesen werden. final int SECONDS_PER_HOUR = 3600; gibt einem festen Umrechnungsfaktor einen klaren Namen. Eine erneute Zuweisung lässt sich nicht kompilieren. Konstanten verwenden üblicherweise großgeschriebene Wörter, die durch Unterstriche getrennt sind.

Seit Java 10 kann der Typ einer lokalen Variablen mit var aus ihrem Initialisierungswert abgeleitet werden. Bei var count = 10; wird int abgeleitet, bei var price = 2.5; ist es double. Der abgeleitete Typ bleibt fest. var count; schlägt fehl, weil es keinen Initialisierungswert gibt, aus dem ein Typ abgeleitet werden kann.

Der Datentyp eines Werts bestimmt seinen Wertebereich, die Schreibweise seiner Literale und die Berechnungen, die Java damit ausführen kann. Verwende int für gewöhnliche Anzahlen und double für gewöhnliche Messwerte und lerne auch die anderen primitiven Datentypen kennen.

Die acht primitiven Datentypen vergleichen

Endliche float-Werte reichen ungefähr von −3,4 × 10³⁸ bis +3,4 × 10³⁸; endliche double-Werte reichen ungefähr von −1,8 × 10³⁰⁸ bis +1,8 × 10³⁰⁸. Trotz dieser großen Wertebereiche lässt sich nicht jede Dezimalzahl darin exakt darstellen.

Ein char steht oft für ein einzelnes Zeichen, etwa 'A'. Manche Unicode-Zeichen benötigen zwei UTF-16-Codeeinheiten, daher kann ein einzelnes char nicht jedes mögliche Zeichen darstellen. 'A' hat den Zahlencode 65, 'a' den Wert 97 und '7' den Wert 55. Das Zeichen '7' ist etwas anderes als die ganze Zahl 7. Ein boolean ist keine Zahl: boolean active = 1; schlägt fehl.

Literale passend zu ihren Typen schreiben

Ein Literal schreibt einen Wert direkt in den Quellcode. 42 ist ein int-Literal, 42L ein long, 3.5 ein double und 3.5f ein float. Zeichenliterale verwenden einfache Anführungszeichen, Stringliterale doppelte. Die Namen primitiver Datentypen werden kleingeschrieben, während String mit einem Großbuchstaben beginnt.

Schreibe long large = 3000000000L;. Ohne das L ist dieses Ganzzahlliteral zu groß. Schreibe float rate = 3.5f;: Das einfache 3.5 hat den Typ double, den Java nicht stillschweigend zu float einengt. Eine passende ganzzahlige Konstante kann einen kleineren ganzzahligen Typ initialisieren: byte b = 100; lässt sich kompilieren, byte b = 200; jedoch nicht.

Unterstriche zwischen Ziffern machen ein Literal lesbar: 1_000_000 hat denselben Wert wie 1000000. Die wissenschaftliche Schreibweise verwendet e, wie in 1.5e3, was 1.500,0 bedeutet. Dezimalzahlen im Quellcode verwenden immer einen Punkt.

Den Wertebereich der Operation beachten

Bei einer Ganzzahlberechnung kann ohne Fehlermeldung ein Überlauf auftreten. Addierst du 1 zum größten int-Wert, springt das Ergebnis zum kleinsten int-Wert. Das Produkt 50_000 * 50_000 verwendet int-Arithmetik und ergibt -1794967296. In 50_000L * 50_000 ist ein Operand vom Typ long, daher ist das Produkt der korrekte Wert 2500000000.

Änderst du nur die aufnehmende Variable zu long, ist es zu spät, um ein int-Produkt zu korrigieren, bei dem bereits ein Überlauf aufgetreten ist. Wähle vor der Multiplikation einen Operanden mit einem ausreichend großen Wertebereich.

Gleitkommawerte haben eine andere Einschränkung. Viele Dezimalbrüche werden als binäre Näherungswerte gespeichert: 0.1 + 0.2 gibt 0.30000000000000004 aus. Formatiere solche Ergebnisse für die Anzeige. Bei exakten Geldberechnungen können ganze Centbeträge in einem long gespeichert werden; die Klasse BigDecimal ist eine weitere Möglichkeit für exakte Dezimalzahlen.

Ein String enthält Text, einschließlich Leerzeichen, Ziffern und Satzzeichen, oder auch gar keine Zeichen. Der Operator + kann diesen Text mit anderen Werten zu einer Nachricht verbinden.

Werte zu Text verbinden

String firstName = "Ada";
String lastName = "Lovelace";
System.out.println(firstName + " " + lastName);

Die Ausgabe lautet „Ada Lovelace“. Das mittlere Literal liefert das Leerzeichen. Ohne es würde firstName + lastName „AdaLovelace“ ergeben. Die Konkatenation fügt keine Trennzeichen für dich hinzu.

Konkatenation bedeutet, Werte zu einem neuen String zu verbinden. Ist einer der Operanden von + ein String, wandelt Java den anderen Wert in Text um und verbindet beide. So wird "Age: " + 36 zu „Age: 36“ und "Price: " + 2.5 zu „Price: 2.5“. Die Ziffern im Ergebnis sind nun Teil eines Textwerts.

String beginnt mit einem großen S. Anders als die acht primitiven Datentypen ist es eine Klasse. string name = "Ada"; mit einem kleinen s lässt sich nicht kompilieren. Der leere String "" ist gültiger Text ohne Zeichen; er ist kein fehlender Wert.

Pluszeichen von links nach rechts verfolgen

Betrachte:

System.out.println("Sum: " + 2 + 3);

Das erste + verbindet den String und 2 zu „Sum: 2“. Das zweite verbindet diesen String und 3 zu „Sum: 23“. Sobald das laufende Ergebnis Text ist, verbindet das nächste + weiterhin Text.

Vergleiche drei Formen:

Setze Klammern, wenn eine Nachricht das Ergebnis einer Addition oder Subtraktion enthalten soll. Zum Beispiel ergibt "Diff: " + (5 - 2) „Diff: 3“. Ohne Klammern versucht "Diff: " + 5 - 2, 2 von einem String zu subtrahieren, und lässt sich nicht kompilieren.

Multiplikation und Division haben eine höhere Rangfolge als +. Der Ausdruck "Area: " + 4 * 5 berechnet zuerst das Produkt und ergibt „Area: 20“.

Eine Nachricht schrittweise aufbauen

String message = "Hi";
message += "!";

Die geänderte Variable enthält „Hi!“. Bei einem String hängt += Text an, indem es das verbundene Ergebnis wieder der Variablen zuweist. Du kannst eine kurze Nachricht mit mehreren Anweisungen zusammensetzen und am Ende einmal ausgeben.

Achte auf Zeichen. Zwei char-Operanden lösen keine String-Konkatenation aus. 'A' + 'B' addiert ihre Zahlencodes 65 und 66 und ergibt den int-Wert 131. Der leere String am Anfang verändert die Kette: "" + 'A' + 'B' erzeugt zuerst „A“, dann „AB“. Anführungszeichen bestimmen die Typen der Operanden und damit auch die Bedeutung von +.

Ein Ausdruck kombiniert Werte und liefert ein Ergebnis. Java wertet ihn gemäß der Operatorrangfolge aus; anschließend kann eine Anweisung das Ergebnis speichern oder ausgeben.

Rechenoperationen ausdrücklich schreiben

Die arithmetischen Operatoren sind +, -, *, / und %: Addition, Subtraktion, Multiplikation, Division und Divisionsrest. Bei int width = 4; und int height = 5; ergibt width * height den Wert 20.

Jede Multiplikation braucht *. Die aus der Algebra vertraute Form 2(3 + 4) ist in Java ungültig; schreibe 2 * (3 + 4). Java hat keinen arithmetischen Potenzoperator. 2 ^ 3 bedeutet eine bitweise Operation und ergibt 1, nicht 8. Um einen Wert zu quadrieren, schreibe x * x; für eine andere Potenz verwende Math.pow.

Erst die Rangfolge beachten, dann von links nach rechts lesen

Auf derselben Stufe werden diese arithmetischen Operatoren von links nach rechts gruppiert. 2 + 3 * 4 ist 14; (2 + 3) * 4 ist 20. In 10 - 4 - 3 ergibt die erste Subtraktion 6 und die zweite 3. In 24 / 4 * 2 ergibt die Division 6 und die Multiplikation 12. Um 4 * 2 als Divisor zu behandeln, wären Klammern nötig.

Einen Mittelwert korrekt berechnen

Angenommen, es gilt int a = 7, b = 8, c = 10;. Der Ausdruck a + b + c / 3 dividiert nur c. Durch die Ganzzahldivision ist 10 / 3 gleich 3, und die anschließenden Additionen ergeben 18.

(a + b + c) / 3 fasst die gesamte Summe 25 zusammen, aber beide Operanden von / sind ganze Zahlen. Das Ergebnis ist 8. Bei (a + b + c) / 3.0 bleibt der Nachkommateil erhalten und das Ergebnis ist 8.333333333333334.

Die Typen der Operanden bestimmen die Berechnung. Zwei int-Operanden ergeben ein int-Ergebnis. Ein double-Operand bewirkt, dass der andere numerische Operand in double umgewandelt wird, wie bei 5 * 2.0 mit dem Ergebnis 10.0. Die aufnehmende Variable ändert nicht, wie zuvor gerechnet wurde.

Einen gespeicherten Wert ändern

int total = 10;
total += 5;
total *= 2;
total--;

Die gespeicherten Werte lauten nacheinander 10, 15, 30 und 29. Für diese int-Operanden führt total += 5; dieselbe Änderung aus wie total = total + 5;. Die Operatoren -=, /= und %= verbinden ebenso eine Operation mit einer Zuweisung. count++; erhöht eine Variable um 1 und count--; verringert sie um 1. Als einzelne Anweisungen verwendet, lassen sich ihre Auswirkungen leicht nachvollziehen.

Ein Ausdruck wie a + b ändert keinen der beiden Operanden. Um sein Ergebnis zu verwenden, weise es zu oder übergib es an einen Ausgabeaufruf: int sum = a + b; oder System.out.println(a + b);. Die allein stehende Zeile a + b; lässt sich nicht kompilieren, weil Java diesen arithmetischen Ausdruck nicht als eigenständige Anweisung zulässt. Zuweisungen, Inkremente, Dekremente und Methodenaufrufe können allein stehen und Auswirkungen haben.

Die Ganzzahldivision beantwortet, wie viele vollständige Gruppen hineinpassen. Der Divisionsrest zeigt, was übrig bleibt. Zusammen teilen diese Operationen eine Größe in nützliche Teile auf.

Quotient und Rest voraussagen

Sind beide Operanden ganze Zahlen, schneidet / den Nachkommateil ab und bewegt sich damit in Richtung null. 7 / 2 ist 3, 2 / 3 ist 0 und -7 / 2 ist −3. Dies ist Abschneiden, kein Runden auf die nächste ganze Zahl.

Der Restoperator % gibt zurück, was nach der Division übrig bleibt. 17 / 5 ergibt 3 und 17 % 5 ergibt 2. Drei Gruppen zu je 5 ergeben 15, sodass 2 übrig bleiben. Für ganzzahlige Operanden und einen Divisor ungleich null stellt (a / b) * b + a % b mit der Ganzzahlarithmetik von Java den Wert a wieder her.

Das Vorzeichen eines Divisionsrests ungleich null richtet sich nach dem linken Operanden: -7 % 3 ist −1, während 7 % -3 gleich 1 ist. Für nicht negative ganze Zahlen ist n % 2 bei geraden Werten 0 und bei ungeraden Werten 1.

Sekunden in größere Einheiten aufteilen

Beginne mit 3725 Sekunden:

int totalSeconds = 3725;
int hours = totalSeconds / 3600;
int secondsAfterHours = totalSeconds % 3600;
int minutes = secondsAfterHours / 60;
int seconds = secondsAfterHours % 60;

Die erste Division ergibt 1 volle Stunde. Der Rest beträgt 125 Sekunden. Die Division dieses Rests durch 60 ergibt 2 Minuten, wobei 5 Sekunden übrig bleiben. Das Ergebnis ist 1 h 2 min 5 s. Setzt du die Gesamtsumme wieder zusammen, erhältst du 3600 Sekunden plus 120 Sekunden plus 5 Sekunden, also 3725.

Verwende den Rest nach dem Abziehen der Stunden, um die Minuten innerhalb der aktuellen Stunde zu bestimmen. Eine Division der ursprünglichen Gesamtzahl durch 60 würde alle 62 vollen Minuten ergeben, einschließlich der bereits als Stunde gezählten Minuten.

Dieselben Operatoren extrahieren Dezimalziffern aus einer nicht negativen ganzen Zahl. 4827 % 10 ergibt die letzte Ziffer 7; 4827 / 10 ergibt die verbleibenden vorderen Ziffern 482.

Volle Gruppen und ausreichend Behälter unterscheiden

Für 50 Eier und Schachteln für jeweils 12 Eier ergibt 50 / 12 4 volle Schachteln und 50 % 12 2 übrige Eier. Um alle Eier unterzubringen, ist eine fünfte Schachtel nötig. Für nicht negative Anzahlen und positive Schachtelgrößen rundet der ganzzahlige Ausdruck (count + size - 1) / size die Anzahl der Behälter auf, sofern bei der Addition kein Überlauf auftritt. Für dieses Beispiel ergibt (50 + 12 - 1) / 12 den Wert 5.

Vor der Division für Nachkommateile sorgen

Eine double-Zielvariable kann einen abgeschnittenen Nachkommateil nicht wiederherstellen. Mache vor der Division einen Operanden zu double, wenn du den Nachkommateil brauchst.

Division oder Restbildung durch die ganze Zahl null wirft während der Ausführung eine ArithmeticException. Gleitkommadivision verhält sich anders: 5.0 / 0 ergibt Infinity, -5.0 / 0 ergibt -Infinity und 0.0 / 0 ergibt NaN, was „keine Zahl“ bedeutet. Ein Ergebnis kann daher unbrauchbar sein, auch wenn die Ausführung nicht stoppt.

Dezimalrechnung ist für Messwerte und Mittelwerte nützlich. Die Klasse Math bietet fertige Berechnungen; durch Runden kannst du festlegen, wie du ein Ergebnis speicherst oder darstellst.

Nachkommateile erhalten und Näherungswerte erkennen

150 / 2.5 ergibt 60.0, die Geschwindigkeit in km/h bei einer Strecke von 150 km und einer Zeit von 2,5 Stunden. Da ein Operand vom Typ double ist, bleibt bei der Division ein Nachkommateil erhalten, wenn einer entsteht. Gewöhnliche double-Werte ohne Nachkommateil werden mit einer Nachkommastelle ausgegeben, etwa 60.0.

Ein double speichert viele Dezimalwerte als binäre Näherungswerte. Daher gibt 1.1 * 3 den Wert 3.3000000000000003 aus und 10.0 / 3 den Wert 3.3333333333333335. Rechne mit dem ungerundeten Wert weiter und runde ihn bei der Ausgabe.

Große oder kleine Werte können in wissenschaftlicher Schreibweise ausgegeben werden. 1.23456789E7 steht für 12.345.678,9 und 1.0E-4 für 0,0001. Für positive endliche Werte wird von 0,001 bis ausschließlich 10.000.000 die gewöhnliche Schreibweise verwendet. Die wissenschaftliche Schreibweise ändert die Darstellung, nicht den zugrunde liegenden Wert.

Nützliche Math-Methoden aufrufen

Math gehört zu java.lang, daher ist kein Import nötig.

Math.sqrt und Math.pow geben double zurück. Die Konstante Math.PI beträgt ungefähr 3,141592653589793. Für einen Kreis mit dem Radius 2,5 cm ergibt Math.PI * 2.5 * 2.5 den Wert 19.634954084936208 cm², also etwa 19,63 cm². Für ein rechtwinkliges Dreieck mit Katheten von 3 cm und 4 cm addiert Math.sqrt(3 * 3 + 4 * 4) zuerst die quadrierten Katheten zu 25 und ergibt dann 5.0 cm.

Eine Rundungsrichtung wählen

round wählt die nächste ganze Zahl; Werte genau in der Mitte werden in Richtung positiver Unendlichkeit gerundet. floor rundet in Richtung negativer Unendlichkeit ab; ceil rundet in Richtung positiver Unendlichkeit auf. Bei negativen Zahlen bedeutet „abwärts“ einen stärker negativen Wert, daher ergibt das Abrunden von −2,7 den Wert −3,0.

Für ein double-Argument gibt Math.round einen long zurück. Speichere das Ergebnis in einem long oder wandle es ausdrücklich um, wenn ein int passend ist: int rounded = (int) Math.round(2.7); speichert 3. floor und ceil geben double-Werte zurück.

Um einen gespeicherten Wert auf zwei Nachkommastellen zu runden, verwende Math.round(12.3456 * 100) / 100.0, was 12.35 ergibt. Durch das Multiplizieren liegen die Hundertstel an der Grenze zu den ganzen Zahlen. Die Division durch 100.0 skaliert mittels Gleitkommadivision zurück; eine Division durch die ganze Zahl 100 würde den Nachkommateil abschneiden und 12 ergeben. Muss nur der ausgegebene Text gerundet werden, kann printf den ursprünglichen Wert direkt formatieren.

Java wandelt einen numerischen Wert manchmal automatisch um. Andere Umwandlungen brauchen einen expliziten Cast. Ein Cast ändert den Typ eines Werts an einer bestimmten Stelle in einem Ausdruck, daher beeinflusst seine Position das Ergebnis.

Automatisch erweiternd umwandeln

Der wichtigste Pfad erweiternder numerischer Umwandlungen ist byte → short → int → long → float → double. Auch char wird erweiternd in int und weiter umgewandelt. Zum Beispiel speichert double d = 5; den Wert 5.0, und jeder int-Wert passt exakt in einen long.

Eine erweiternde Umwandlung in einen Gleitkommatyp kann Genauigkeit verlieren. Bei der Umwandlung von int zu float, von long zu float und von long zu double kann eine große ganze Zahl gerundet werden. Die Umwandlung eines int in einen double ist exakt. Zum Beispiel wird (float) 16777217 zu 1.6777216E7, was für 16.777.216 steht.

Eine einengende Typumwandlung mit Cast durchführen

Ein Cast schreibt den Zieltyp in Klammern vor den Wert:

int n = (int) 3.99;

Das gespeicherte Ergebnis ist 3. Ohne (int) weist Java die Zuweisung des double-Literals an einen int zurück. Bei der Umwandlung eines endlichen double-Werts innerhalb des Wertebereichs in eine ganze Zahl wird in Richtung null abgeschnitten: Auch (int) -3.99 ergibt −3. Abschneiden unterscheidet sich vom Runden; (int) Math.round(3.99) ergibt 4.

Einengende Typumwandlungen benötigen im Allgemeinen einen Cast. Eine nützliche Ausnahme erlaubt es, einen byte, short oder char mit einem passenden konstanten ganzzahligen Ausdruck zu initialisieren. Daher ist byte b = 100; ohne (byte) gültig. Für eine nicht konstante int-Variable gilt diese Ausnahme für die Zuweisung von Konstanten nicht allein deshalb, weil ihr aktueller Wert passt.

Den Cast vor die Operation setzen, die ihn braucht

Es gelten int sum = 25; und int count = 3;.

Ein Cast bindet stärker als Multiplikation und Division. Klammern bestimmen, ob er für einen Operanden oder eine abgeschlossene Berechnung gilt. Ein Cast nach einer Ganzzahldivision kann abgeschnittene Informationen nicht wiederherstellen.

Änderungen an Zeichen und kleinen ganzen Zahlen voraussagen

(int) 'A' ergibt den Zeichencode 65. Die Addition von 1 zu 'A' ergibt den int-Wert 66. Um das gesamte Ergebnis wieder in ein Zeichen umzuwandeln, schreibe (char) ('A' + 1); das ergibt 'B'. Ohne die äußeren Klammern um die Summe würde der Cast nur für 'A' gelten.

Bei einer einengenden Umwandlung zwischen ganzzahligen Typen bleiben nur die unteren Bits erhalten. (byte) 200 wird zu −56; (int) 3_000_000_000L wird zu −1294967296. Ein Cast erlaubt die Umwandlung, prüft aber nicht, ob der Ausgangswert passt.

Eine zusammengesetzte Zuweisung enthält eine Umwandlung in den Typ der linken Seite. Bei int x = 10; berechnet x += 2.7; den Wert 12,7 und engt ihn zu 12 ein. Die einfache Zuweisung x = x + 2.7; schlägt fehl, weil ihre rechte Seite vom Typ double ist.

Text kann Ziffern enthalten, ohne eine Zahl zu sein. Um mit eingegebenem oder gespeichertem Text zu rechnen, parse ihn in einen numerischen Typ. Um eine Nachricht zu erstellen, wandle einen numerischen Wert wieder in Text um.

Text vor dem Rechnen parsen

Der Ausdruck "42" + 1 ergibt „421“. Da der linke Operand ein String ist, führt + eine Konkatenation aus. Integer.parseInt("42") + 1 ergibt 43, weil das Parsen vor der Addition einen int liefert.

String first = "12";
String second = "30";
int total = Integer.parseInt(first) + Integer.parseInt(second);

Hier enthält total den Wert 42. Das Verbinden der ursprünglichen Strings würde „1230“ ergeben. Wähle die Umwandlung danach, wie der Wert verwendet werden soll, und nicht danach, ob seine Zeichen zufällig wie Zahlen aussehen.

Integer.parseInt(text) gibt einen int zurück; Long.parseLong(text) gibt einen long zurück. Integer.valueOf("42") gibt ein Integer-Objekt zurück, das Java automatisch in int umwandelt, wenn ein int benötigt wird. Für eine direkte Umwandlung von Text in int drückt parseInt das beabsichtigte Ergebnis klar aus.

Dezimalzahlen und Wahrheitswerte parsen

Double.parseDouble("3.75") gibt den double-Wert 3,75 zurück. Das Textformat verwendet auf jedem Computer unabhängig von den Regionseinstellungen einen Dezimalpunkt. Double.parseDouble("3,5") schlägt fehl. Auch Java-Quellcodeliterale verwenden einen Punkt, obwohl Methoden zum Einlesen über die Tastatur einem Gebietsschema folgen können.

Boolean.parseBoolean(text) folgt einer eigenen Regel: Die Methode gibt true für „true“ in beliebiger Groß- und Kleinschreibung zurück, etwa für „TRUE“. Jeder andere Text ergibt false, auch „yes“. Ein allgemeines bejahendes Wort wird nicht als wahr interpretiert.

Ungültigen Zahlentext erkennen

Ungültiger Zahlentext verursacht während der Programmausführung eine NumberFormatException. Integer.parseInt("4.5") schlägt fehl, weil Dezimaltext keine Darstellung einer ganzen Zahl ist. Auch Integer.parseInt("") und Integer.parseInt(" 42") schlagen fehl. Die Ausnahmemeldung nennt den Text, der nicht umgewandelt werden konnte.

Wie Leerraum behandelt wird, hängt von der Parsing-Methode ab. Double.parseDouble ignoriert Leerzeichen am Anfang und Ende, Integer.parseInt dagegen nicht. Wähle beim Einlesen von Nutzereingaben Testeingaben, die diese Unterschiede sichtbar machen.

Ein praktisches Eingabemuster liest eine ganze Zeile und parst sie:

int age = Integer.parseInt(scanner.nextLine());
double height = Double.parseDouble(scanner.nextLine());

Jeder Aufruf verbraucht seine gesamte Zeile einschließlich des Zeilenendes. Das hält Text- und Zahleneingaben einheitlich und vermeidet, Token und ganze Zeilen gemischt einzulesen.

Eine Zahl in Text umwandeln

String.valueOf(42), Integer.toString(42) und "" + 42 ergeben alle den String „42“. Double.toString(2.50) ergibt „2.5“. Die ursprüngliche Dezimalschreibweise bleibt nicht an der gespeicherten Zahl haften, daher fügt diese Umwandlung keine abschließende Null hinzu, um sie zu erhalten.

Verwende String.format, wenn du gespeicherten Text mit einer festen Anzahl von Nachkommastellen brauchst. Verwende printf, wenn du den formatierten Text direkt ausgeben möchtest. Weder ein numerischer Cast noch eine einfache Konkatenation sorgt für eine feste Anzeige mit zwei Nachkommastellen.

Tastatureingaben kommen als Text an. Ein Scanner kann eine ganze Zeile, ein einzelnes Wort oder ein in eine Zahl umgewandeltes Wort einlesen. Entscheide dich für eine einheitliche Vorgehensweise, bevor du Eingaben abfragst.

Einen Scanner erstellen und eine Zeile einlesen

import java.util.Scanner;

public class Greeting {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("What is your name? ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

Der Import steht vor der Klasse. Die Anweisung zum Erstellen steht innerhalb von main und verbindet den Scanner mit System.in. Ein Scanner reicht für dieses Programm. nextLine() wartet auf die eingegebene Zeile und gibt ihren Text ohne Zeilenumbruch zurück. Die Eingabe „Ada“ führt dazu, dass die letzte Anweisung „Hello, Ada!“ ausgibt. Durch print bei der Eingabeaufforderung steht die Eingabe neben der Frage.

Zwischen Zeilen und Token wählen

Bei „Ada Lovelace“ gibt next() „Ada“ zurück. Ein anschließendes nextLine() gibt „ Lovelace“ einschließlich des führenden Leerzeichens zurück. Zwei nextInt()-Aufrufe können „3 4“ aus einer Zeile einlesen. Ein Zahlentoken, das nicht zur Methode passt, etwa „4.5“ oder „abc“ für nextInt(), verursacht eine InputMismatchException.

Das ungelesene Zeilenende berücksichtigen

Angenommen, die nutzende Person gibt „30“ ein, drückt die Eingabetaste, gibt dann „Ada Lovelace“ ein und drückt erneut die Eingabetaste. Dieser Code liest den Namen nicht wie beabsichtigt ein:

int age = scanner.nextInt();
String name = scanner.nextLine();

nextInt() verbraucht 30, lässt aber das Zeilenende stehen. nextLine() verbraucht sofort den leeren Rest derselben Zeile, sodass name gleich "" ist. Füge scanner.nextLine(); zwischen den beiden Anweisungen ein, um diesen Rest zu verwerfen, bevor der Name in der nächsten Zeile eingelesen wird.

Eine andere Lösung besteht darin, jede Antwort mit nextLine() einzulesen und Zahlenzeilen zu parsen: int age = Integer.parseInt(scanner.nextLine());. So vermeidest du den Wechsel zwischen zwei verschiedenen Eingabeeinheiten.

Die Dezimalkonvention klären

nextDouble() folgt dem Gebietsschema des Scanners, anfangs dem Standardgebietsschema des Computers für die Formatierung. Ein Gebietsschema mit Dezimalkomma akzeptiert in diesem Beispiel „3,5“ als Dezimalzahl und weist „3.5“ zurück. Um Dezimalzahlen einheitlich mit Punkt einzulesen, ergänze import java.util.Locale; und erstelle:

Scanner scanner = new Scanner(System.in).useLocale(Locale.US);

Auch das Einlesen einer ganzen Zeile mit Double.parseDouble(scanner.nextLine()) verwendet einen Punkt. Eine Änderung des Scanner-Gebietsschemas ändert weder Java-Quellcodeliterale noch das Gebietsschema späterer printf-Aufrufe.

Lies Werte in der Reihenfolge ein, in der die Eingabeaufforderungen danach fragen. Fragst du nach einem Namen und dann nach einem Alter, muss der erste Leseaufruf den Namen speichern. Ein falsch platzierter Leseaufruf kann Daten in die falsche Variable schreiben oder einen Umwandlungsfehler auslösen.

Formatierte Ausgabe steuert, wie Werte innerhalb einer Nachricht erscheinen. printf kann eine feste Anzahl von Nachkommastellen anzeigen, einen Zeilenumbruch hinzufügen und Werte in Spalten ausrichten, ohne ihre gespeicherten Werte zu ändern.

Platzhalter und Werte aufeinander abstimmen

Ein Formatstring enthält gewöhnlichen Text sowie Spezifizierer, die mit % beginnen. Jeder Spezifizierer, der einen Wert benötigt, nimmt den nächsten Wert nach dem Formatstring:

System.out.printf("%s is %d years old%n", "Ada", 36);

Dies gibt „Ada is 36 years old“ aus und beginnt eine neue Zeile. %s zeigt Text oder einen anderen Wert als Text an, %d eine ganze Zahl wie einen int oder long und %f einen Gleitkommawert. %n fügt einen Zeilenumbruch ein, ohne einen Wert zu verbrauchen. %% gibt ein Prozentzeichen aus.

printf fügt nicht automatisch einen Zeilenumbruch hinzu. Nimm %n auf, wenn die nächste Ausgabe in einer neuen Zeile beginnen soll. Auch die gewöhnliche Escape-Sequenz \n steht innerhalb von Java-Text für ein Zeilenumbruchzeichen; %n ist das plattformspezifische Zeilentrennzeichen des Formatierers.

Nachkommastellen für die Anzeige festlegen

Das einfache %f gibt sechs Stellen nach dem Dezimaltrennzeichen aus: Die Formatierung von 2.5 ergibt „2.500000“. Die Genauigkeitsangabe in %.2f fordert zwei Stellen an:

System.out.printf("Total: %.2f%n", 12.3456);

Bei US-Formatierung lautet die Ausgabe „Total: 12.35“. Der Wert wird im angezeigten Text gerundet. Eine Variable mit dem Wert 12,3456 enthält nach der Ausgabe weiterhin diesen Rechenwert.

Bei System.out.printf("%d items at %.2f each, total %.2f%n", 3, 1.5, 3 * 1.5); füllen die Werte die drei Platzhalter der Reihe nach. Bei US-Einstellungen lautet die Ausgabe „3 items at 1.50 each, total 4.50“.

Felder mit einer Breite ausrichten

Eine Feldbreite ist eine Mindestgröße. %5d richtet eine ganze Zahl innerhalb von mindestens fünf Zeichen rechtsbündig aus; %-6s richtet Text innerhalb von mindestens sechs Zeichen linksbündig aus. %6.1f kombiniert die Feldbreite 6 mit einer Nachkommastelle.

System.out.printf("[%5d][%-6s][%6.1f]%n", 42, "Ada", 9.25);

Bei US-Einstellungen lautet die genaue Ausgabe [ 42][Ada ][ 9.3]. Die eckigen Klammern machen die Auffüllung sichtbar. Ein Wert, der länger als seine Feldbreite ist, wird dennoch vollständig ausgegeben; die Feldbreite schneidet keine Zeichen ab.

Ein nicht passender Spezifizierer verursacht einen Laufzeitfehler. printf("%d%n", 2.5) lässt sich kompilieren, wirft aber eine IllegalFormatConversionException, weil %d eine ganze Zahl erwartet. Zu wenige übergebene Werte wie in printf("%d %d%n", 2) verursachen eine MissingFormatArgumentException.

Zwischen Ausgabe und gespeichertem Text wählen

String.format wendet dieselben Formatierungsregeln an, gibt aber einen String zurück:

String line = String.format("%.1f km", 12.345);

Bei US-Einstellungen enthält line den Wert „12.3 km“; diese Anweisung hat nichts ausgegeben.

Beide Formatierungsmethoden verwenden das Standardgebietsschema, sofern du keines übergibst. Ergänze import java.util.Locale; und verwende dann System.out.printf(Locale.US, "%.2f%n", 12.3456);, um „12.35“ statt des bei einem Gebietsschema mit Dezimalkomma üblichen „12,35“ sicherzustellen. Auch String.format kann Locale.US als erstes Argument erhalten. Die Ausgabe eines double mit println verwendet unabhängig vom Formatierungsgebietsschema einen Punkt.

Ein vollständiges Berechnungsprogramm verbindet drei Phasen: Eingaben einlesen, damit rechnen und Ergebnisse ausgeben. Planst du vor dem Tippen die Werte und ihre Einheiten, kannst du leichter Datentypen wählen und das Ergebnis testen.

Ein Fahrzeitprogramm planen

Die Eingaben sind die Strecke in Kilometern und die Durchschnittsgeschwindigkeit in km/h. Strecke geteilt durch Geschwindigkeit ergibt die Zeit in Stunden. Beide Messwerte brauchen double, damit bei der Division ein Nachkommateil erhalten bleiben kann. Die Ausgabe erfolgt in ganzen Stunden und Minuten, gerundet auf die nächste Minute.

import java.util.Scanner;

public class TravelTime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Distance (km): ");
        double distance = Double.parseDouble(scanner.nextLine());
        System.out.print("Speed (km/h): ");
        double speed = Double.parseDouble(scanner.nextLine());
        int totalMinutes = (int) Math.round(distance / speed * 60);
        int hours = totalMinutes / 60;
        int minutes = totalMinutes % 60;
        System.out.println("Travel time: " + hours + " h " + minutes + " min");
    }
}

Für 150 km bei 80 km/h ergibt die Division 1,875 Stunden. Die Multiplikation mit 60 ergibt 112,5 Minuten. Math.round gibt den long-Wert 113 zurück, und der Cast wandelt ihn in int um. Ganzzahldivision und Divisionsrest ergeben dann 1 Stunde und 53 Minuten. Die Ausgabe lautet „Travel time: 1 h 53 min“.

Wären Strecke und Geschwindigkeit beide vom Typ int, würde 150 / 80 * 60 den Wert 60 ergeben. Der Nachkommateil verschwindet bei der Division, noch vor der Multiplikation. Die Wahl der Datentypen gehört in den Plan und nicht nur in die abschließende Ausgabeanweisung.

Anzeige und Berechnung getrennt wählen

Für eine Gesamtrechnung von 87,60, die auf 4 Personen aufgeteilt wird, speichere die Summe in double und die Anzahl in int. double share = total / people; ergibt 21,9. Bei US-Formatierung gibt System.out.printf("Each person pays %.2f%n", share); „Each person pays 21.90“ aus. Die Formatierung liefert die zweite Nachkommastelle, ohne die Berechnung zu ändern.

Für die ganzzahligen Punktzahlen 7, 8 und 10 ergibt double average = (a + b + c) / 3.0; den Wert 8.333333333333334, der mit %.2f als „8.33“ angezeigt wird. Die Klammern fassen die Summe zusammen und der Dezimaldivisor erhält den Nachkommateil.

Mit bekannten Ergebnissen testen

Berechne erwartete Ergebnisse, bevor du das Programm ausführst. Für die Fahrzeit sollten 120 km bei 60 km/h die Ausgabe 2 h 0 min ergeben. Eine Strecke von 0 km bei positiver Geschwindigkeit sollte 0 h 0 min ergeben. Probiere Eingaben nahe einer Rundungsgrenze und größere gültige Strecken aus, um mehr als nur die einfachste Berechnung zu prüfen.

Beziehe null, negative und große Eingaben ein, wenn du das Verhalten des Programms prüfst. Entscheide, ob jede Eingabe für die Aufgabe sinnvoll ist. Eine Anzahl von null Personen führt bei total / people zu Infinity, wenn total ein double-Wert ungleich null ist; Ganzzahldivision durch null wirft eine ArithmeticException. Eine erfolgreiche Ausführung allein belegt noch kein brauchbares Ergebnis.

Weicht die Ausgabe von deiner Erwartung ab, gib Zwischenwerte aus oder verfolge sie in einer Tabelle. Suche den ersten falschen Wert, korrigiere die verantwortliche Anweisung und führe die bekannten Tests erneut aus. Vergleiche neben Zahlen auch Leerzeichen und Beschriftungen.

Verwende Namen wie totalMinutes, benannte Konstanten wie MINUTES_PER_HOUR, Einheiten in Eingabeaufforderungen und kurze Kommentare, die den Zweck einer Berechnung erklären.