Java-Datentypen und Grundlegende Operationen

Einführung

Willkommen im Lab "Java Data Types and Basic Operations"! In diesem Lab werden wir uns mit den grundlegenden Bausteinen der Java-Programmierung befassen. Sie werden Ganzzahlen, Fließkommazahlen und Strings erkunden - die grundlegenden Datentypen, die die Grundlage für jedes Java-Programm bilden. Machen Sie sich keine Sorgen, wenn diese Begriffe Ihnen jetzt noch etwas fremd vorkommen; wir werden jedes Konzept Schritt für Schritt erklären und üben, wie man sie in echten Codebeispielen einsetzt.

Sie werden auch praktische Erfahrungen mit grundlegenden arithmetischen Operationen und Stringverkettung sammeln. Diese Fähigkeiten sind für jeden Java-Programmierer unerlässlich, und wenn Sie sie beherrschen, sind Sie gut gerüstet, um Ihre Programmierreise erfolgreich fortzusetzen.

Am Ende dieses Labs werden Sie ein solides Verständnis davon haben, wie man mit verschiedenen Datentypen in Java arbeitet, und Sie werden bereit sein, sich komplexeren Programmierherausforderungen zu stellen. Los geht's!

Skills Graph

Arbeiten mit Ganzzahlen

Beginnen wir unsere Reise, indem wir uns Ganzzahlen in Java ansehen. Ganzzahlen sind Zahlen ohne Dezimalstellen und werden in der Programmierung häufig zum Zählen, Indizieren und für viele andere Zwecke verwendet.

1. Öffnen Sie die Datei IntegerDemo.java im WebIDE-Editor. Sie werden den folgenden Code sehen:

   public class IntegerDemo {
       public static void main(String[] args) {
           // TODO: Declare an integer variable and print it
       }
   }

   Dies ist die Grundstruktur eines Java-Programms. Die main-Methode ist der Einstiegspunkt unseres Programms.

2. Jetzt ersetzen wir den TODO-Kommentar durch echten Code. Fügen Sie die folgenden Zeilen hinzu:

   int number = 42;
   System.out.println("The number is: " + number);

Lassen Sie uns diesen Code analysieren:

• int number = 42;: Diese Zeile erstellt eine Variable namens number vom Typ int (Ganzzahl) und weist ihr den Wert 42 zu.
• System.out.println("The number is: " + number);: Diese Zeile gibt eine Nachricht aus. Der +-Operator wird hier zur Stringverkettung verwendet, d. h., er kombiniert den Text "The number is: " mit dem Wert unserer number-Variable.

3. Gute Arbeit! Jetzt speichern Sie die Datei. In den meisten IDEs, einschließlich WebIDE, erfolgt das Speichern automatisch, aber es ist eine gute Gewohnheit, sicherzustellen, dass Ihre Datei gespeichert ist.

4. Als nächstes müssen wir unser Programm kompilieren. Das Kompilieren wandelt unseren menschenlesbaren Java-Code in eine Form um, die der Computer ausführen kann. Führen Sie diesen Befehl im Terminal aus:

   javac ~/project/IntegerDemo.java

   Wenn Sie keine Ausgabe sehen, ist das gute Nachricht! Das bedeutet, dass unser Code ohne Fehler kompiliert wurde.

5. Jetzt, da wir unser Programm kompiliert haben, lassen Sie es ausführen. Verwenden Sie diesen Befehl:

   java -cp ~/project IntegerDemo

   Hinweis: java -cp teilt Java mit, wo es die kompilierten Klassen-Dateien finden kann. In diesem Fall sagen wir Java, dass es im Verzeichnis ~/project suchen soll.

Oder Sie können in das Verzeichnis ~/project wechseln und das Programm mit folgendem Befehl ausführen:

cd ~/project
java IntegerDemo

Wenn alles korrekt funktioniert hat, sollten Sie die Ausgabe The number is: 42 sehen.

Herzlichen Glückwunsch! Sie haben gerade Ihr erstes Java-Programm, das mit Ganzzahlen arbeitet, erstellt, kompiliert und ausgeführt. Wenn Sie auf Fehler gestoßen sind, machen Sie sich keine Sorgen - beim Programmieren ist das Beheben von Fehlern häufig erforderlich. Überprüfen Sie Ihren Code auf Tippfehler und stellen Sie sicher, dass Sie jeden Schritt sorgfältig befolgt haben.

Grundlegende arithmetische Operationen

Nachdem wir uns jetzt mit Ganzzahlen gut auskennen, wollen wir uns ansehen, wie man in Java grundlegende arithmetische Operationen durchführt. Diese Operationen bilden die Bausteine für komplexere Berechnungen in der Programmierung.

1. Ändern wir die Datei IntegerDemo.java, um einige arithmetische Operationen einzufügen. Ersetzen Sie ihren Inhalt durch den folgenden Code:

   public class IntegerDemo {
       public static void main(String[] args) {
           int number1 = 10;
           int number2 = 5;
   
           // TODO: Perform arithmetic operations and print the results
       }
   }

   Hier haben wir zwei Ganzzahlvariablen, number1 und number2, deklariert, die wir in unseren Berechnungen verwenden werden.

2. Jetzt ersetzen wir den TODO-Kommentar durch Code, der grundlegende arithmetische Operationen durchführt. Fügen Sie die folgenden Zeilen hinzu:

   int sum = number1 + number2;
   int difference = number1 - number2;
   int product = number1 * number2;
   int quotient = number1 / number2;
   
   System.out.println("Number 1: " + number1);
   System.out.println("Number 2: " + number2);
   System.out.println("Sum: " + sum);
   System.out.println("Difference: " + difference);
   System.out.println("Product: " + product);
   System.out.println("Quotient: " + quotient);

   Lassen Sie uns dies analysieren:

   • Wir führen vier grundlegende arithmetische Operationen durch: Addition (+), Subtraktion (-), Multiplikation (*) und Division (/).
   • Wir speichern jedes Ergebnis in einer neuen Variablen.
   • Schließlich geben wir alle Zahlen und Ergebnisse aus.

3. Speichern Sie Ihre Datei und kompilieren und führen Sie das Programm erneut mit den gleichen Befehlen wie zuvor aus:

   javac ~/project/IntegerDemo.java
   java -cp ~/project IntegerDemo

   Sie sollten eine Ausgabe sehen, die die ursprünglichen Zahlen und die Ergebnisse aller arithmetischen Operationen anzeigt.

   Number 1: 10
   Number 2: 5
   Sum: 15
   Difference: 5
   Product: 50
   Quotient: 2

   Haben Sie etwas Interessantes am Quotienten bemerkt? Obwohl 10 geteilt durch 5 gleich 2,0 ist, ist unser Ergebnis nur 2. Dies liegt daran, dass wenn Sie in Java zwei Ganzzahlen dividieren, das Ergebnis ebenfalls eine Ganzzahl ist. Jeder Dezimalteil wird abgeschnitten (nicht gerundet).

Experimentieren Sie mit diesem Programm! Versuchen Sie, die Werte von number1 und number2 zu ändern, um zu sehen, wie sich dies auf die Ergebnisse auswirkt. Dies ist eine großartige Möglichkeit, Ihr Verständnis dafür zu erweitern, wie die Arithmetik in Java funktioniert.

Arbeiten mit Fließkommazahlen

Nachdem wir Ganzzahlen beherrschen, wollen wir uns nun Fließkommazahlen ansehen. Dies sind Zahlen, die Dezimalstellen haben können, was es uns ermöglicht, Brüche oder genauere Messwerte darzustellen.

1. Öffnen Sie die Datei FloatDemo.java. Sie werden diesen Anfangscode sehen:

   public class FloatDemo {
       public static void main(String[] args) {
           // TODO: Declare and use floating-point numbers
       }
   }

2. Ersetzen wir den TODO-Kommentar durch Code, der die Verwendung von Fließkommazahlen demonstriert:

   double pi = 3.14159;
   System.out.println("The value of pi is approximately: " + pi);
   
   double radius = 5.0;
   double area = pi * radius * radius;
   System.out.println("The radius of the circle is: " + radius);
   System.out.println("The area of the circle is: " + area);
   
   // Demonstrating precision
   double result = 0.1 + 0.2;
   System.out.println("0.1 + 0.2 = " + result);

   Lassen Sie uns dies analysieren:

   • Wir verwenden den double-Typ für Fließkommazahlen. Er bietet uns mehr Genauigkeit als der float-Typ.
   • Wir definieren pi und verwenden es, um die Fläche eines Kreises zu berechnen.
   • Der letzte Teil demonstriert ein Besonderheit der Fließkommaarithmetik, die Anfängern oft überrascht.

3. Speichern Sie Ihre Datei und kompilieren und führen Sie das Programm aus:

   javac ~/project/FloatDemo.java
   java -cp ~/project FloatDemo

   Sie sollten eine Ausgabe ähnlich dieser sehen:

   The value of pi is approximately: 3.14159
   The radius of the circle is: 5.0
   The area of the circle is: 78.53975
   0.1 + 0.2 = 0.30000000000000004

   Haben Sie etwas Merkwürdiges an der letzten Zeile bemerkt? Obwohl wir wissen, dass 0,1 + 0,2 genau 0,3 ergeben sollte, gibt unser Programm einen leicht anderen Wert aus. Dies liegt daran, wie Computer Dezimalzahlen im Binärsystem darstellen. Dies ist eine häufige Verwirrungsquelle für neue Programmierer, aber in den meisten praktischen Anwendungen spielt diese winzige Abweichung keine Rolle.

Fließkommazahlen ermöglichen es uns, mit einem viel größeren Wertebereich als mit Ganzzahlen zu arbeiten, einschließlich sehr großer und sehr kleiner Zahlen. Sie sind für wissenschaftliche Berechnungen, Grafik und viele andere Anwendungen unerlässlich.

Arbeiten mit Strings

Unser letztes Thema in diesem Lab sind Strings. In der Programmierung ist ein String eine Folge von Zeichen, wie Wörter oder Sätze. Strings sind für die Arbeit mit Text in unseren Programmen von entscheidender Bedeutung.

1. Öffnen Sie die Datei StringDemo.java. Sie werden diesen Anfangscode sehen:

   public class StringDemo {
       public static void main(String[] args) {
           // TODO: Declare and manipulate strings
       }
   }

2. Ersetzen wir den TODO-Kommentar durch Code, der verschiedene String-Operationen demonstriert:

   String greeting = "Hello";
   String name = "Alice";
   
   // String concatenation
   String message = greeting + ", " + name + "!";
   System.out.println(message);
   
   // String length
   System.out.println("The length of the message is: " + message.length());
   
   // Accessing characters in a string
   System.out.println("The first character is: " + message.charAt(0));
   
   // Converting to uppercase
   System.out.println("Uppercase message: " + message.toUpperCase());
   
   // Substring
   System.out.println("First five characters: " + message.substring(0, 5));

   Lassen Sie uns dies analysieren:

   • Wir erstellen Strings mit doppelten Anführungszeichen.
   • Wir können Strings mithilfe des +-Operators verketten (verbinden).
   • Strings in Java verfügen über viele nützliche Methoden wie length(), charAt(), toUpperCase() und substring().
   • Strings sind "null-indiziert", was bedeutet, dass das erste Zeichen an Position 0 steht.

3. Speichern Sie Ihre Datei und kompilieren und führen Sie das Programm aus:

   javac ~/project/StringDemo.java
   java -cp ~/project StringDemo

   Sie sollten eine Ausgabe sehen, die verschiedene String-Operationen demonstriert:

   Hello, Alice!
   The length of the message is: 13
   The first character is: H
   Uppercase message: HELLO, ALICE!
   First five characters: Hello

Strings in Java sind unglaublich vielseitig und verfügen über viele integrierte Methoden, um sie zu manipulieren. Wenn Sie Ihre Java-Reise fortsetzen, werden Sie noch viele weitere nützliche String-Operationen entdecken.

Alles zusammenführen

Im letzten Schritt wollen wir ein Programm erstellen, das alles, was wir gelernt haben, zusammenbringt. Wir werden einen einfachen Temperaturumrechner erstellen, der Ganzzahlen, Fließkommazahlen und Strings verwendet.

1. Öffnen Sie die Datei TemperatureConverter.java. Sie werden diesen Anfangscode sehen:

   public class TemperatureConverter {
       public static void main(String[] args) {
           // TODO: Implement temperature conversion
       }
   }

2. Ersetzen Sie den TODO-Kommentar durch den folgenden Code:

   int fahrenheit = 98;
   double celsius = (fahrenheit - 32) * 5.0 / 9.0;
   
   String message = fahrenheit + "°F is equal to " + celsius + "°C";
   System.out.println(message);
   
   // Rounding to two decimal places
   double roundedCelsius = Math.round(celsius * 100.0) / 100.0;
   String formattedMessage = String.format("%d°F is equal to %.2f°C", fahrenheit, roundedCelsius);
   System.out.println(formattedMessage);
   
   // Converting the other way
   celsius = 37.0;
   fahrenheit = (int) (celsius * 9.0 / 5.0 + 32);
   System.out.println(celsius + "°C is approximately " + fahrenheit + "°F");

   Dieses Programm demonstriert:

   • Die Verwendung sowohl des int- als auch des double-Typs
   • Die Durchführung von Berechnungen mit verschiedenen Typen
   • Die Stringverkettung für die Ausgabe
   • Die Verwendung der Math.round()-Methode zum Runden
   • Die Verwendung von String.format() für eine bessere Kontrolle über die Ausgabeformatierung
   • Das Casten (Typumwandlung) eines double in einen int (bei der zweiten Umrechnung)

3. Speichern, kompilieren und führen Sie das Programm aus:

   javac ~/project/TemperatureConverter.java
   java -cp ~/project TemperatureConverter

   Sie sollten eine Ausgabe sehen, die Temperaturumrechnungen mit unterschiedlicher Genauigkeit zeigt:

   98°F is equal to 36.666666666666664°C
   98°F is equal to 36.67°C
   37.0°C is approximately 98°F

Dieses abschließende Programm bringt alle Konzepte zusammen, die wir behandelt haben: Ganzzahlen, Fließkommazahlen, Strings, arithmetische Operationen und Typumwandlungen. Es führt auch einige neue Konzepte wie Runden und formatierte Ausgabe ein, die Ihnen bei Ihrer Java-Programmierreise sehr nützlich sein werden.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab "Java Data Types and Basic Operations" (Java-Datentypen und Grundlegende Operationen) abgeschlossen. Lassen Sie uns zusammenfassen, was Sie gelernt haben:

1. Arbeiten mit Ganzzahlen und Durchführen von grundlegenden arithmetischen Operationen
2. Verwenden von Fließkommazahlen für genauere Berechnungen
3. Manipulieren von Strings und Durchführen von Stringverkettungen
4. Kombinieren verschiedener Datentypen in einem praktischen Programm (Temperaturumrechner)
5. Verwenden von grundlegenden Formatierungs- und Rundungsoperationen

Diese Fähigkeiten bilden die Grundlage der Java-Programmierung und werden unerlässlich sein, wenn Sie Ihre Reise in der Softwareentwicklung fortsetzen. Denken Sie daran, dass Programmieren eine Fähigkeit ist, die sich durch Übung verbessert. Zögern Sie nicht, mit den hier gelernten Konzepten zu experimentieren. Versuchen Sie, die Programme zu ändern, Werte zu verändern oder neue Berechnungen hinzuzufügen.

Wenn Sie vorwärts gehen, werden Sie auf diesen Grundlagen aufbauen, um komplexere und leistungsfähigere Programme zu erstellen. Bleiben Sie am Programmieren, lernen Sie weiter und am wichtigsten: haben Sie Spaß! Sie sind auf dem guten Weg, ein Java-Experte zu werden.