Variablendeklaration und Variablentypen, Werte einlesen und ausgeben

Um mit Variablen zu arbeiten, müssen wir diese vorher deklarieren.

Das bedeutet, wir müssen für unsere Variable z.B. a einen Speicherplatz reservieren.

Beispiel:

string a;     // wir deklarieren die Variable a und teilen ihr mit, dass sie vom Typ String ist.

int zahl1, zahl2, zahl3, ergebnis;     // Deklaration mehrerer Variablen vom Typ Integer
 
int wert = 2;     // der Variablen wert vom Typ Integer wird der Wert 2 zugewiesen

Was sind eigentlich Variablen?

Variablen speichern Zahlen, Buchstaben oder Zeichenketten und stellen sie dem Programm zur Verfügung.

Beispiel:

Der Variable mit dem Namen Sum wird der Inhalt von Variable a + Variable b zugeordnet. In Sum wird der Wert 12 gespeichert.

Da in diesem Fall die Variablen ganzzahlige Werte enthalten, müssen wir die Variablen richtig deklarieren, also einem Datentyp zuordnen.

In unserem Beispiel wählen wir den Datentyp Integer (Int 32), welcher ganzzahlige Werte zwischen -2³¹ bis 2³¹ -1 speichern kann.

Als Programmcode sieht das so aus:

int Sum, a=10, b=2;     // Variablen werden als Integer deklariert.
     // a wird der Wert 10 und b der Wert 2 zugeordnet.

Sum = a + b;     // Sum speichert den Inhalt von a + b

Wertzuweisung von Variablen

Wir einer Variablen kein Wert zugewiesen, beschwert sich Visual C# bei der Ausführung mit einer Fehlermeldung.

Beispiele für Wertzuweisungen:

int maxWert = 10000;     // Weist der Variablen maxWert die Zahl 10000 zu. 
double messwert = 2.3;     // Weist der Variablen messwert vom Typ double die Zahl 2.3 zu.

string b;     // Deklariert die Variable b vom Typ String
b = "Ich bin eine Zeichenkette und daher ein String";     // Weist der Variable b die Zeichenkette "Ich bin eine Zeichenkette und daher ein String" zu.

In den folgenden Lektionen werden Variablentypen und Zuweisungen anhand verschiedener Programmbeispiele noch ausführlich beschrieben.

Datentypen in Visual C#

Typischerweise werden Variablen dazu verwendet, um z.B. Werte einzulesen, diese zu verarbeiten und auszugeben.

Dies geschieht mit der Klasse Console und deren Methoden z.B. ReadLine oder WriteLine.

Was ist eine Klasse?
Das soll uns an dieser Stelle noch nicht kümmern.

Ausgabe von Werten

Ausgabe mit Console.WriteLine

Wir schreiben ein Programm mit einer einfachen Ausgabe:

Console.WriteLine("Visual C# ist super!");
Console.ReadLine();

Ausgabe:

Visual C# ist super! 

Alles, was in der (" ") steht wird also ausgegeben.

Console.ReadLine(); benötigen wir, damit unser Programm an dieser Stelle anhält und auf eine Eingabe wartet. Ansonsten würde das Programm nach der Ausgabe beendet.

Wir schreiben ein kleines Programm, welches eine Zahl mit einer anderen Zahl multipliziert und das Ergebnis ausgibt:

int zahl1 = 3, zahl2 = 4, ergebnis;
ergebnis = zahl1 * zahl2;     //speichert 3 * 4, also 12 in ergebnis
Console.WriteLine("{0} mal {1} = {2}", zahl1, zahl2, ergebnis);
Console.ReadLine();

Ausgabe:

3 mal 4 = 12

Diesmal haben wir in (" ") sogenannte Platzhalter {0}, {1} , {2} für die Ausgabe der Werte unserer Variablen verwendet.
Die Variablen stehen nacheinander nach dem " jeweils getrennt von einem Beistrich.

Das Programm geht von links nach rechts vor:

• An der Stelle des Platzhalters {0}, wird der Wert für die Variable zahl1 ausgegeben.
• An der Stelle des Platzhalters {1}, wird der Wert für die Variable zahl2 ausgegeben.
• An der Stelle des Platzhalters {2}, wird der Wert für die Variable ergebnis ausgegeben.

Eine andere Art um Werte von Variablen auszugeben ist zum Beispiel folgende:

Console.WriteLine(zahl1 + " mal " + zahl2 + " = " + ergebnis);

Das Ergebnis 3 mal 4 = 12 ist ident, jedoch werden hier keine Platzhalter sondern die Variablen selbst für die Ausgabe genutzt.

Der Formatausdruck {}

ermöglicht auch die Formatierung der Ausgabe. {x,y}

• x ... nullbasierter Zähler
• y ... gibt die Breite der Ausgabe an (Unbesetzte Plätze werden durch Leerzeichen aufgefüllt)

int zahl1 = 3, zahl2 = 4, ergebnis;
ergebnis = zahl1 * zahl2;     //speichert 3 * 4, also 12 in ergebnis
Console.WriteLine("{0} mal {1} = {2}", zahl1, zahl2, ergebnis);
Console.ReadLine();

Ausgabe:

3 mal 4 = 12

Exponentialformat

int zahl1 = 3, zahl2 = 4, ergebnis;
ergebnis = zahl1 * zahl2;     //speichert 3 * 4, also 12 in ergebnis
Console.WriteLine("{0} mal {1} = {2:E}", zahl1, zahl2, ergebnis);
Console.ReadLine();

Ausgabe:

3 mal 4 =  1,200000E+001

Escape-Zeichen

Durch das Einfügen von Escape-Zeichen kann die Ausgabe noch weiter formatiert werden.

Beispiel:

Console.WriteLine("Visual C#\nist\nsuper!");
Console.ReadLine();

Durch Einfügen von \n erreicht man einen Zeilenvorschub.

Ausgabe:

Visual C#
ist
super!

weitere Escape-Zeichen in C#

Einlesen von Werten

Um einen Wert einzulesen verwenden wir die Methode ReadLine.

Console.ReadLine();     // liest immer einen String (Zeichenkette) ein!

Möchte man zum Beispiel eine Zahl einlesen und diese in eine Variable speichern, muss diese zuvor in den Typ Int, long, float ect. konvertiert werden.

Wir schreiben ein Programm, welches eine Zahl einliest und diese mit 5 multipliziert (Das Ergebnis soll wie gewohnt ausgegeben werden):

int zahl1, ergebnis;

Console.WriteLine("Bitte eine Zahl eingeben!");

zahl1 = Convert.ToInt32(Console.ReadLine());     // Der eingelesene Wert wird in Int32 konvertiert und in zahl1 gespeichert

ergebnis = zahl1 * 5;

Console.WriteLine("5 mal {0} = {1}", zahl1, ergebnis);

Console.ReadLine();

Methode GetType

Mit der Methode GetType haben wir die Möglichkeit, den Typ einer Variablen abzufragen, wenn wir den Wert der Variablen angeben.

Was eine Methode ist und wie eine Methode funktioniert soll uns an dieser Stelle noch nicht kümmern.
Nur so viel, eine Methode ist eine Art "kleines Programm", welche bestimmte Dinge ausführt.

GetType ist also eine Methode, welche den Variablentyp abfragen kann.

Beispiele:

Console.WriteLine(999.GetType());

Ausgabe:

System.Int32

Console.WriteLine('A'.GetType());

Ausgabe:

System.Char

Console.WriteLine("hallo".GetType());

Ausgabe:

System.String

Console.WriteLine(999.1234.GetType());

Ausgabe:

System.Double

Console.WriteLine(1.5.GetType());

Ausgabe:

System.Double