≪ View Page

Differences

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

Link to this comparison view

Next revision		Previous revision
programmierung:variables_datatypes [2024/07/07 21:15] – created sweprogrammierung:variables_datatypes [2025/12/20 14:53] (current) – external edit 127.0.0.1
Line 1: Line 1:
-===== Klasse ===== +Variablen sind **Container**, um Daten/ Werte zu speichern.
-**Hier nochmal der Hinweis mit der Großschreibung von Klassen und Dateien. Glaub mir, es hat seinen Grund.**+
  
-Hierfür verwendet Java das Konzept einer **Klasse**.+Der Begriff **Variable** leitet sich vom lateinischen *variabilis* 
 +("veränderlich") ab. Das drückt sehr schön aus, was eine Variable ist:
  
-<file java  Wunderbar.java>+**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. 
 + 
 +Zunächst gibt es die Unterscheidung zwischen **primitiven** und 
 +**nicht-primitiven** Datentypen. Dabei sind primitive Datentypen solche, 
 +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**. 
 + 
 +## Primitive Datentypen 
 + 
 +`String` - speichert Text. Immer umschlossen von Hochkommata/ Double 
 +quotes 
 + 
 +`int` - speichert Integers/ Ganzzahlen. 
 + 
 +`float` - speichert Kommazahlen. 
 + 
 +`boolean` - speichert Wahrheitswerte wahr/falsch. 
 + 
 +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 
 + 
 +`char` - speichert Einzelbuchstaben. Umschlossen von Einfachen 
 +Hochkommata/ Single quotes. 
 + 
 +## Datentypen und Größe 
 + 
 +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. 
 + 
 +| 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;` 
 + 
 +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: 
 + 
 +``` java 
 +int myNum = 5; 
 +float myFloatNum = 5.99f; 
 +char myLetter = 'D'; 
 +boolean myBool = true; 
 +String myText = "Hello"; 
 +``` 
 + 
 +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: 
 + 
 +``` java 
 +String name; 
 +... 
 +name = "Bugs Bunny"; 
 +``` 
 + 
 +## 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()` 
 + 
 +Durch die kryptische Zeile 
 +`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. 
 + 
 +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 class Wunderbar{
     public static void main(String[] args){     public static void main(String[] args){
Line 10: 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>