Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- schule:csharp_in_10_minuten [2015-05-11 14:54] – [C# in 10 Minuten] marco.bakera
+++ schule:csharp_in_10_minuten [2017-04-19 06:39] (aktuell) – Externe Bearbeitung 127.0.0.1
@@ Zeile 1: / Zeile 1: @@
+====== 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.
+<file csharp Programm.cs>
+// 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.
+</file>
+===== Klasse Peter =====
+<file csharp Person.cs>
+// 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;
+  }
+}
+</file>