Differences

This shows you the differences between two versions of the page.

--- programmierung:variables_datatypes [2024/07/15 09:37] – [Deklaration und Initialisierung] swe
+++ programmierung:variables_datatypes [2025/12/20 14:53] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
 Variablen sind **Container**, um Daten/ Werte zu speichern.
-Der Begriff **Variable** leitet sich vom lateinischen //variabilis// ("veränderlich") ab. Das drückt sehr schön aus, was eine Variable ist:
+Der Begriff **Variable** leitet sich vom lateinischen *variabilis*
+("veränderlich") ab. Das drückt sehr schön aus, was eine Variable ist:
-**Eine Variable ist eine Container/Platzhalter für Daten, die sich verändern können. Der Name der Variable bleibt erhalten und ändert sich nicht**
+**Eine Variable ist eine Container/Platzhalter für Daten, die sich
+verändern können. Der Name der Variable bleibt erhalten und ändert sich
+nicht**
-Als Programmierer wirst du feststellen, dass du die Welt strukturieren musst und auf ihre kleinen und kleinsten Bausteine herunterbrichst. Dabei wirst du vielleicht bemerken, dass wir die Welt mit nur einer handvoll unterschiedlicher Datentypen beschreiben können.
+Als Programmierer wirst du feststellen, dass du die Welt strukturieren
+musst und auf ihre kleinen und kleinsten Bausteine herunterbrichst.
+Dabei wirst du vielleicht bemerken, dass wir die Welt mit nur einer
+handvoll unterschiedlicher Datentypen beschreiben können.
-Zunächst gibt es die Unterscheidung zwischen **primitiven** und **nicht-primitiven** Datentypen.
+Zunächst gibt es die Unterscheidung zwischen **primitiven** und
-===== Primitive Datentypen =====
+**nicht-primitiven** Datentypen. Dabei sind primitive Datentypen solche,
-''String'' - speichert Text. Immer umschlossen von Hochkommata/ Double quotes
+die bereits mit Java "out of the box" mitgeliefert werden. Sie sind die
+Grundbausteine, aus denen wir alle anderen Datentypen in Java basteln
+können. Diese anderen, "gebastelten", aus primitiven Datentypen
+zusammengesetzte Datentypen sind die berühmten **Klassen**.
-''int'' - speichert Integers/ Ganzzahlen.
+## Primitive Datentypen
-''float'' - speichert Kommazahlen.
+`String` - speichert Text. Immer umschlossen von Hochkommata/ Double
+quotes
-''boolean'' - speichert Wahrheitswerte wahr/falsch.
+`int` - speichert Integers/ Ganzzahlen.
-Mit diesen vier Datentypen kommen wir schon sehr weit. Bei den Zahlen-Datentypen gibt es noch weitere Untergruppen, die die Größe bzw. Präzision betreffen.
+`float` - speichert Kommazahlen.
-Zusätzlich gibt es noch den Datentyp\\
+`boolean` - speichert Wahrheitswerte wahr/falsch.
-''char'' - speichert Einzelbuchstaben. Umschlossen von Einfachen Hochkommata/ Single quotes.
+Mit diesen vier Datentypen kommen wir schon sehr weit. Bei den
+Zahlen-Datentypen gibt es noch weitere Untergruppen, die die Größe bzw.
+Präzision betreffen.
+Zusätzlich gibt es noch den Datentyp
-===== Datentypen und Größe =====
+`char` - speichert Einzelbuchstaben. Umschlossen von Einfachen
-Java ist eine **typisierte** Sprache, d.h., jeder Variable muss ein Datentyp zugewiesen werden. Das bewirkt, dass zum Einen nicht einfach in eine Variable, die das Alter einer Person speichern soll, die Adresse von der Person gespeichert werden kann. Gleichzeitig wird für die Variable im Speicher ein bestimmter Platz von einer **vorhersagbaren Größe** reserviert. Das ist einer der Gründe, warum Java-Programme recht flott sind.
+Hochkommata/ Single quotes.
-^ Daten-Typ  ^ Größe    ^ Beschreibung                                                                       ^
+## Datentypen und Größe
-| ''byte''       | 1 byte   | Stores whole numbers from -128 to 127                                              |
-| ''short''      | 2 bytes  | Stores whole numbers from -32,768 to 32,767                                        |
-| ''int''        | 4 bytes  | Stores whole numbers from -2,147,483,648 to 2,147,483,647                          |
-| ''long''       | 8 bytes  | Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807  |
-| ''float''      | 4 bytes  | Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits            |
-| ''double''     | 8 bytes  | Stores fractional numbers. Sufficient for storing 15 decimal digits                |
-| ''boolean''    | 1 bit    | Stores true or false values                                                        |
-| ''char''       | 2 bytes  | Stores a single character/letter or ASCII values                                   |
-===== Deklaration und Initialisierung =====
+Java ist eine **typisierte** Sprache, d.h., jeder Variable muss ein
+Datentyp zugewiesen werden. Das bewirkt, dass zum Einen nicht einfach in
+eine Variable, die das Alter einer Person speichern soll, die Adresse
+von der Person gespeichert werden kann. Gleichzeitig wird für die
+Variable im Speicher ein bestimmter Platz von einer **vorhersagbaren
+Größe** reserviert. Das ist einer der Gründe, warum Java-Programme recht
+flott sind.
-Variablen müssen in jeder Programmiersprache auf eine ganz bestimmte Art und Weise zunächst einmal **deklariert** und anschließend **initialisiert** werden.
+| Daten-Typ  | Größe    | Beschreibung    | Initialisierung                                                                   |
+|-|-|-|-|
+| `byte`       | 1 byte   | Ganzahlen von -128 bis 127                                              | |
+| `short`      | 2 bytes  | Ganzahlen von -32,768 bis 32,767                                      |  |
+| `int`        | 4 bytes  | Ganzahlen von -2,147,483,648 bis 2,147,483,647                          | |
+| `long`       | 8 bytes  | Ganzahlen von -9,223,372,036,854,775,808 bis 9,223,372,036,854,775,807 | |
+| `float`      | 4 bytes  | Gleitkommazahlen. Ausreichend für 6 bis 7 Stellen            |  `float f = 4.5f` Beachte: `float` endet mit einem angehängten **f**|
+| `double`     | 8 bytes  | Gleitkommazahlen. Ausreichend für 15 Stellen               | |
+| `boolean`    | 1 bit    | true oder false                                                        | |
+| `char`       | 2 bytes  | Einzelbuchstabe  |
+## Deklaration und Initialisierung
+Variablen müssen in jeder Programmiersprache auf eine ganz bestimmte Art
+und Weise zunächst einmal **deklariert** und anschließend
+**initialisiert** werden.
 In Java gehört zur Deklaration die Angabe des Datentypes
-''type variableName = value;''
+`type variableName = value;`
-Der **Variablentyp** und -natürlich- der **Variablen-Name** (der Name, unter dem eine Variable für den Rest des Programms angesprochen wird) müssen bekannt gemacht werden:
+Der **Variablentyp** und -natürlich- der **Variablen-Name** (der Name,
-<code java>
+unter dem eine Variable für den Rest des Programms angesprochen wird)
+müssen bekannt gemacht werden:
+``` java
 int myNum = 5;
 float myFloatNum = 5.99f;
@@ Line 52: / Line 81: @@
 boolean myBool = true;
 String myText = "Hello";
-</code>
+```
-Im Anschluss muss dieser Variablen ein Wert zugewiesen werden - sie wird **initialisiert**.
+Im Anschluss muss dieser Variablen ein Wert zugewiesen werden - sie wird
+**initialisiert**.
-Dieser Prozess kann auch in 2 Schritten stattfinden: Erst Deklaration, später dann Initialisierung:
+Dieser Prozess kann auch in 2 Schritten stattfinden: Erst Deklaration,
+später dann Initialisierung:
-<code java>
+``` java
 String name;
 ...
 name = "Bugs Bunny";
-</code>
+```
+## Ausgabe von Gleitkommazahlen
+Wie auch am Taschenrechner, ergibt eine Rechnung wie `1 / 3 = 0,3333333`
+eine unendliche Zahl von Nachkommastellen. Oftmals ist dieser Effekt
+aber unerwünscht.
+Wenn du nun bsp. eine Berechnung mit Währungen anstellst, möchtest du
+mit Sicherheit nur 2 Nachkommastellen haben. Dies bekommst du natürlich
+hin durch den Einsatz von `System.out.printf()` - beachte das `printf()`
+anstelle des altbekannten `print()` oder `println()`
-===== Klasse =====
+Durch die kryptische Zeile
-**Hier nochmal der Hinweis mit der Großschreibung von Klassen und Dateien. Glaub mir, es hat seinen Grund.**
+`System.out.printf(“Betrag: %2.2f Euro”, betrag)` gibst du den Wert, der
+in der Variable `betrag` gespeichert ist auf 2 Nachkommastellen und
+selbst wenn die Zahl kleiner sein sollte mit mindestens 2 führenden
+Ziffern aus.
-<file java  Wunderbar.java>
+Beachte: In der Programmierwelt ist der Punkt `.` das Kommazeichen - die
+Zahlen heißen auf englisch halt auch **Floating-Point-Numbers**.
+## Klasse
+**Hier nochmal der Hinweis mit der Großschreibung von Klassen und
+Dateien. Glaub mir, es hat seinen Grund.**
+``` java
 public class Wunderbar{
     public static void main(String[] args){
@@ Line 76: / Line 126: @@
     }
 }
-</file>
+```
+\<WRAP center round tip 100%\> Wie du siehts sind sowohl im Dateinamen
+`Wunderbar.java` als auch im Klassen-Namen `public class Wunderbar` die
+Bezeichner **Wunderbar** groß geschrieben.
-<WRAP center round tip 100%>
+Ich wiederhole: **Datei-Namen und Klassen-Namen sind groß geschrieben
-Wie du siehts sind sowohl im Dateinamen ''Wunderbar.java'' als auch im Klassen-Namen ''public class Wunderbar'' die Bezeichner **Wunderbar** groß geschrieben.
+und stimmen exakt überein!** Tue dir einfach den Gefallen, und schreib
+niemals, niemals, never ever einen Klassen-Namen oder einen Datei-Namen
+klein. Deine Nerven werden es dir danken ;) \</WRAP\>
-Ich wiederhole: **Datei-Namen und Klassen-Namen sind groß geschrieben und stimmen exakt überein!** Tue dir einfach den Gefallen, und schreib niemals, niemals, never ever einen Klassen-Namen oder einen Datei-Namen klein. Deine Nerven werden es dir danken ;)
-</WRAP>