schule:csharp_in_10_minuten
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen angezeigt.
Beide Seiten der vorigen RevisionVorhergehende Überarbeitung | |||
schule:csharp_in_10_minuten [2015-05-18 19:54] – [C# in 10 Minuten] marco.bakera | schule:csharp_in_10_minuten [2017-04-19 08:39] (aktuell) – Externe Bearbeitung 127.0.0.1 | ||
---|---|---|---|
Zeile 1: | Zeile 1: | ||
+ | ====== C# in 10 Minuten ====== | ||
+ | Die wichtigsten Befehle in [[programmieren|C# | ||
+ | |||
+ | <file csharp Programm.cs> | ||
+ | |||
+ | // Kommentare werden mit // eingeleitet | ||
+ | // Sie spielen für das Programm keine Rolle und dienen nur der Erläuterung. | ||
+ | |||
+ | /* | ||
+ | | ||
+ | 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 ' | ||
+ | // 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 ' | ||
+ | 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 ' | ||
+ | // 4. übergeben der Methode als Parameter die Variable | ||
+ | |||
+ | // Wir können die Ausgabe schöner gestalten. | ||
+ | Console.WriteLine(" | ||
+ | // | ||
+ | // Mit dem Pluszeichen wird die Zeichenkette " | ||
+ | // Variablen ergänzt. | ||
+ | | ||
+ | // So können wir den Wert der Variablen um 1 erhöhen | ||
+ | eineVariable = eineVariable + 1; | ||
+ | // Das ' | ||
+ | // Es bedeutet vielmehr ' | ||
+ | |||
+ | // Eine Zeichenkette kann mit + zusammengesetzt werden. | ||
+ | Console.WriteLine(" | ||
+ | |||
+ | // 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 ' | ||
+ | if(eineVariable > 2) | ||
+ | { | ||
+ | Console.WriteLine(" | ||
+ | } | ||
+ | else | ||
+ | { | ||
+ | Console.WriteLine(" | ||
+ | } | ||
+ | // 1. Die Bedingung ist wahr | ||
+ | // 2. Die Bedingung ist falsch - also nicht wahr. | ||
+ | |||
+ | // Bedingungen können auch komplizierter sein. | ||
+ | // | ||
+ | // >= größer oder gleich | ||
+ | // | && bedeutet ' | ||
+ | // | | <= kleiner oder gleich | ||
+ | // v v v | ||
+ | if(eineVariable >= 0 && eineVariable <= 5) | ||
+ | { | ||
+ | Console.WriteLine(" | ||
+ | } | ||
+ | // Der else-Teil kann auch entfallen. | ||
+ | |||
+ | // Anweisungen können mit Schleifen wiederholt ausgeführt werden. | ||
+ | // | ||
+ | // (1) | ||
+ | while(eineVariable > 0) | ||
+ | { | ||
+ | Console.WriteLine(" | ||
+ | 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 | ||
+ | // | ||
+ | // | ||
+ | // 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(" | ||
+ | } | ||
+ | // 1 Die Variable i wird als Integer deklariert und mit dem Wert 0 | ||
+ | // | ||
+ | // 2 Die Bedingung wird geprüft. Ist sie erfüllt, wird die Schleife | ||
+ | // | ||
+ | // 3 Alle Anweisungen, | ||
+ | // | ||
+ | // 4 Zum Schluss wird Variable i um eins erhöht: i++ ist eine Kurzform für | ||
+ | // | ||
+ | // 5 Hinter die schließende Klammer ' | ||
+ | // | ||
+ | // 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 ' | ||
+ | // ' | ||
+ | // erläutert. | ||
+ | Person peterchen = new Person(); | ||
+ | |||
+ | // Wir rufen die Methode ' | ||
+ | peterchen.alterFestlegen(25); | ||
+ | //(1) | ||
+ | // | ||
+ | // 1 Name des Objektes: peterchen | ||
+ | // 2 Der Punkt kennzeichnet wieder einen Methodenaufruf | ||
+ | // 3 Der Name der Methode: alterFestlegen | ||
+ | // 4 Parameter des Methodenaufrufs: | ||
+ | | ||
+ | // 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(" | ||
+ | } | ||
+ | // Der Aufbau der Klasse Person ist weiter unten beschrieben. | ||
+ | // Dort ist festgeschrieben, | ||
+ | | ||
+ | } // <- Mit dieser schließenden Klammer endet die Main-Methode | ||
+ | } // <- Hier endet die Klasse Programm. | ||
+ | </ | ||
+ | |||
+ | ===== Klasse Peter ===== | ||
+ | <file csharp Person.cs> | ||
+ | // Klassen werden in separaten Dateien beschrieben, | ||
+ | // die Klasse selbst heißen. Ähnlich wie bei Objektkarten, | ||
+ | // mit einem Klassendiagramm grafisch beschrieben. | ||
+ | // | ||
+ | // |-----------------------| | ||
+ | // | Person | ||
+ | // |-----------------------| | ||
+ | // | alter: | ||
+ | // |-----------------------| | ||
+ | // | alterSetzen(): | ||
+ | // | istVolljaehrig(): | ||
+ | // | | | ||
+ | // |-----------------------| | ||
+ | // | ||
+ | // 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, | ||
+ | // sie tun sollen, wenn sie aufgerufen werden. | ||
+ | |||
+ | // (1) (2) (3) | ||
+ | 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 | ||
+ | // | ||
+ | // 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, | ||
+ | // 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; | ||
+ | } | ||
+ | } | ||
+ | </ |
schule/csharp_in_10_minuten.txt · Zuletzt geändert: 2017-04-19 08:39 von 127.0.0.1