====== C# in 10 Minuten ======
Die wichtigsten Befehle in [[programmieren|C#]] und Beispiele für deren Anwendung findest du in dem folgenden Quelltext. Du kannst ihn direkt übersetzen und ausführen.
// Kommentare werden mit // eingeleitet
// Sie spielen für das Programm keine Rolle und dienen nur der Erläuterung.
/*
Längere Kommentare über mehrere Zeilen
sind auch möglich.
*/
// Mit using können Bilbiotheken eingebunden werden.
// In Sytem sind viele wichtige Standardfunktionen enthalten.
using System;
// Alle Programme sind in Klassen aufgeteilt. Wir beschreiben hier
// den Aufbau der Klasse 'Programm'. Alles, was zwischen { und } steht, gehört
// zu einer Klasse.
// WICHTIG: zu jeder öffnenden muss es eine schließende Klammer geben.
// Schreibe die Klammern am besten immer untereinander.
class Programm
{
// Die Main-Methode ist der Startpunkt jedes Programms. Sie wird als
// erstes ausgeführt. Methoden erkennen wir an den Klammern nach dem Namen.
public static void Main()
{
// Variablen haben immer einen Typ und einen Namen.
// Hier deklarieren wir eine Variable vom Typ Integer (Ganzzahl)
// mit dem Namen 'eineVariable'.
int eineVariable;
// Fast alle Anweisungen enden mit einem Semikolon (;).
// Nun können wir die Variable initialisieren und ihr einen Wert geben.
eineVariable = 2;
// Wir können Deklaration und Initialisierung auch in einer Zeile
// zusammenfassen.
int eineAndereVariable = 3;
// Wir geben den Wert der Variable eineVariable auf der Konsole aus -> 2
Console.WriteLine(eineVariable);
//(1) (2) (3) (4)
//
// 1. Die Klasse Console stellt Methoden für die Konsole bereit.
// 2. Mit einem Punkt wird auf Methoden der Klasse Console zugegriffen
// 3. Wir rufen eine Methoden mit Namen 'WriteLine' auf und
// 4. übergeben der Methode als Parameter die Variable
// Wir können die Ausgabe schöner gestalten.
Console.WriteLine("Die Variable hat den Wert " + eineVariable);
//
// Mit dem Pluszeichen wird die Zeichenkette "..." um den Wert der
// Variablen ergänzt.
// So können wir den Wert der Variablen um 1 erhöhen
eineVariable = eineVariable + 1;
// Das '=' funktioniert also nicht wie in der Mathematik.
// Es bedeutet vielmehr 'bekommt den Wert von'.
// Eine Zeichenkette kann mit + zusammengesetzt werden.
Console.WriteLine("Variable hat Wert " + eineVariable + " - um 1 erhöht");
// Mit if können wir entweder den einen (1) oder den anderen (2)
// Programmteil ausführen. Dazu müssen wir in Klammern eine Bedingung
// angeben.
// ACHTUNG: Hinter die schließende Klammer ')' darf kein Semikolon.
if(eineVariable > 2)
{
Console.WriteLine("Variable ist größer als 2"); // (1)
}
else
{
Console.WriteLine("Variable ist NICHT größer als 2"); // (2)
}
// 1. Die Bedingung ist wahr
// 2. Die Bedingung ist falsch - also nicht wahr.
// Bedingungen können auch komplizierter sein.
//
// >= größer oder gleich
// | && bedeutet 'und' also beides muss gelten
// | | <= kleiner oder gleich
// v v v
if(eineVariable >= 0 && eineVariable <= 5)
{
Console.WriteLine("Variable zwischen 0 und 5");
}
// Der else-Teil kann auch entfallen.
// Anweisungen können mit Schleifen wiederholt ausgeführt werden.
//
// (1)
while(eineVariable > 0)
{
Console.WriteLine("Variablenwert in Schleife " + eineVariable); // (2)
eineVariable = eineVariable - 1;
// (3)
}
// (4)
//
// 1 Eine Bedingung, die immer wieder überprüft wird. Ist sie wahr, so
// wird die Schleife ausgeführt und es geht bei 2 weiter. Falls nicht,
// setzt die Ausführung bei 4 fort. Hier wird geprüft, ob der Wert in
// eineVariable größer als 0 ist.
// ACHTUNG: Wie auch beim if, darf hinter der schließenden Klammer
// kein Semikolon.
// 2 Alle Anweisungen zwischen { und } werden ausgeführt. Der Wert der
// der Variablen wird ausgegeben und anschließend um 1 verringert.
// 3 Am Ende springen wir wieder zu 1 und prüfen erneut die Bedingung.
// 4 Die Schleife wurde beendet und es geht im Quelltext weiter.
//
// Ausgabe:
// Variablenwert in Schleife 3
// Variablenwert in Schleife 2
// Variablenwert in Schleife 1
// Mit for-Schleifen kann ein Anweisungsblock mehrere mal ausgeführt
// werden. Sie bieten sich an, wenn die Anzahl der Ausführungen
// feststeht.
//
// (1) (2) (4) (5)
for(int i=0; i<4; i++)
{
Console.WriteLine("i-Wert in for-Schleife " + i); // (3)
}
// 1 Die Variable i wird als Integer deklariert und mit dem Wert 0
// initialisiert. Diese Anweisung wird nur EIN MAL ausgeführt.
// 2 Die Bedingung wird geprüft. Ist sie erfüllt, wird die Schleife
// ausgeführt.
// 3 Alle Anweisungen, die ausgeführt werden sollen, stehen wieder
// zwischen { und }.
// 4 Zum Schluss wird Variable i um eins erhöht: i++ ist eine Kurzform für
// i=i+1. Danach wird mit der Prüfung der Bedingung in 2 fortgesetzt.
// 5 Hinter die schließende Klammer ')' darf kein Semikolon.
//
// Ausgabe:
// i-Wert in for-Schleife 0
// i-Wert in for-Schleife 1
// i-Wert in for-Schleife 2
// i-Wert in for-Schleife 3
// Wir können auch eigene Klassen bauen und daraus Objekte erzeugen.
// Hier erstellen wir mit 'new' ein Objekt mit Namen 'peterchen' vom Typ
// 'Person'. Der Aufbau der Klasse wird im Abschnitt weiter unten
// erläutert.
Person peterchen = new Person();
// Wir rufen die Methode 'alterFestlegen' auf und übergeben den Wert 25.
peterchen.alterFestlegen(25);
//(1) (2) (3) (4)
//
// 1 Name des Objektes: peterchen
// 2 Der Punkt kennzeichnet wieder einen Methodenaufruf
// 3 Der Name der Methode: alterFestlegen
// 4 Parameter des Methodenaufrufs: 25
// Wir haben nun ein Objekt mit der folgenden Objektkarte erstellt
//
// |------------------|
// | peterchen |
// |------------------|
// | alter = 25 |
// |------------------|
// | alterFestlegen() |
// | istVolljaehrig() |
// |------------------|
// Legen wir noch eine weitere Person lisa mit der folgenden Objektkarte an
//
// |------------------|
// | lisa |
// |------------------|
// | alter = 22 |
// |------------------|
// | alterSetzen() |
// | istVolljaehrig() |
// |------------------|
Person lisa = new Person();
lisa.alterFestlegen(22);
// Nun können wir mit Hilfe einer weiteren Methode prüfen,
// ob die Person volljährig ist.
if( peterchen.istVolljaehrig() )
{
Console.WriteLine("Peterchen ist kein Kind mehr.");
}
// Der Aufbau der Klasse Person ist weiter unten beschrieben.
// Dort ist festgeschrieben, welche Methoden es gibt und was sie tun.
} // <- Mit dieser schließenden Klammer endet die Main-Methode
} // <- Hier endet die Klasse Programm.
===== Klasse Peter =====
// Klassen werden in separaten Dateien beschrieben, die genauso wie
// die Klasse selbst heißen. Ähnlich wie bei Objektkarten, werden sie
// mit einem Klassendiagramm grafisch beschrieben.
//
// |-----------------------|
// | Person | (1)
// |-----------------------|
// | alter:int | (2)
// |-----------------------|
// | alterSetzen():void | (3)
// | istVolljaehrig():bool |
// | |
// |-----------------------|
//
// 1 Der Name der Klasse. Er wird groß geschrieben.
// 2 Die Attribute der Klasse. Darin können wir uns Werte merken, wie
// z.B. das Alter. Erst kommt der Name, dann ein Doppelpunkt und
// dann der Typ.
// 3 Unten stehen die Methoden. Nach dem Namen und den Klammern kommt
// auch hier ein Doppelpunkt gefolgt von dem Type des Rückgabewertes.
// Dies werden wir gleich noch im Quelltext genauer sehen.
class Person
{
// Oben in der Klasse stehen die Attribute.
// Objekte vom Typ Person haben nur das Attribut alter.
int alter;
// Nach den Attributen folgen die Methoden. Wir haben zwei Methoden
// alterFestlegen und istVolljaehrig. Wir müssen noch beschreiben, was
// sie tun sollen, wenn sie aufgerufen werden.
// (1) (2) (3) (4) (5)
public void alterFestlegen(int dasAlter)
{
alter = dasAlter; // (6)
}
// 1 Wer darf die Methode ausführen? Bei public darf es jeder.
// 2 Welchen Typ liefert die Methode als Rückgabe? Bei void gibt es keine
// Rückgabe. Wir wollen hier nur etwas festlegen und nichts abfragen.
// 3 Der Name der Methode
// 4 Zwischen ( und ) folgen die Parameter. Zunächst der Typ und dann
// 5 der Name des Parameters
// 6 Was die Methoden machen soll, steht zwischen { und }. Hier setzen wir
// den Wert des Attributes alter auf den Wert, der im Parameter übergeben
// wird. Alle Methoden können auf die Attribute zugreifen.
// Nun haben wir eine Methoden mit einem Rückgabewert vom Typ bool. Das ist
// ein Wahrheitswert, der als Wert nur true oder false sein kann.
// Es gibt keine Parameter.
public bool istVolljaehrig()
{
// Das Ergebnis der Prüfung, ob alter größer als 18 ist, merken wir uns in der
// Variablen erwachsen.
bool erwachsen = alter > 18;
// Mit return verlassen wir die Methode und geben den Wert von erwachsen -
// also true oder false - zurück.
return erwachsen;
}
}