Objekte

Schreibe eine Klasse namens Chip mit einer Methode beep, die ok schreibt. Die Methode ist auf dieser Seite nicht static. In Pine behalte Main und baue einen Chip mit Chip c = new Chip();, dann rufe c.beep(); auf. Halte beide Typen in derselben Lehrdatei, damit dotnet run einfach bleibt. Starte mit dotnet run. Der Bildschirm sollte eine Zeile zeigen: ok. Das Wort new baut ein Objekt aus der Klasse. Die Variable c hält dieses Objekt. Du rufst beep auf c auf, nicht auf dem bloßen Klassennamen. Genau dieses gebaute Objekt — und der Aufruf darüber — ist das Lehrziel dieser Seite. Behalte den öffentlichen Startklassennamen Pine.

Ein Objekt aus der Klasse

Eine Klasse ist weiterhin der benannte Typ. Ein Objekt ist ein Wert, der aus diesem Typ gebaut wird. Die Zeile new Chip() fordert C# auf, diesen Wert zu bauen. Du speicherst ihn in einer Variable vom Typ Chip und nutzt die Variable, um Methoden zu erreichen, die zu jedem Objekt gehören.
Öffne die Pine-Datei. Der Startklassenname bleibt Pine. Diese Seite benennt den Starter nicht um. Lösche jeden übrig gebliebenen Badge.show();-Aufruf, falls dieser static-Aufruf noch alles ist, was in Main steht. Lösche jeden down-Rekursionsteil. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Tippen.
Außerhalb der geschweiften Klammern von Pine — noch in derselben Datei — schreibe public class Chip. Innerhalb von Chip schreibe void beep() — ohne das Wort static in diesem Kopf. Der Körper ist eine Schreibzeile: Console.WriteLine("ok");. Behalte void. Die Methode gibt keine Zahl zurück. In Chip gibt es auf dieser Seite kein Main. Speichere die Datei vor dem Lauf.
Das erste Programm in der Box zeigt Chip allein, damit du den Typ klar liest. Die späteren Programme in der Box sind die behaltenen Formen, in denen Pine einen Chip baut, dann zwei.

Pine baut den Chip, dann ruft es beep auf

Pine behält public static void Main(). Innerhalb von Main schreibe zwei Zeilen: zuerst Chip c = new Chip();, dann c.beep();. Die erste Zeile deklariert eine Variable c vom Typ Chip und füllt sie mit einem neuen Objekt. Die zweite Zeile ruft beep auf diesem Objekt auf. Der Punkt steht nach dem Variablennamen, nicht allein nach dem Klassennamen. Auf dieser Seite schreibst du nicht Badge.show();. Das war der static-Aufruf aus der Klassen-Lektion.

Lies die behaltene Datei von oben. using System; bereitet kurze Namen vor. public class Pine ist der Starter. public static void Main() ist der Einstieg der Laufzeit. Der Ausdruck new Chip() baut ein Objekt. Dieses Objekt wird in c gespeichert. Der Aufruf c.beep() betritt beep für dieses Objekt. Die Methode schreibt ok und kehrt zurück. Dann endet Pine. Das Wort auf dem Bildschirm kam von der Methode des Objekts, nachdem new das Objekt gebaut hat.
Führe es mit dotnet run aus. Das Programm schreibt eine Zeile und stoppt. Es wartet nicht auf deine Eingabe. Wenn dotnet run wartet, steckt ReadLine noch in der Datei. Lösche diese Zeile und behalte in Pine Chip c = new Chip(); plus c.beep();, mit beep in Chip. Der Bildschirm zeigt ok. Zeigt der Bildschirm ready, läuft noch ein übrig gebliebener Badge.show();-Aufruf. Zeigt der Bildschirm die Buchstaben Chip, hat eine Schreibzeile Anführungszeichen: Console.WriteLine("Chip");. Installiere das .NET SDK nicht neu wegen eines Bildschirms mit der falschen Zeile.
Geh den Lauf noch einmal der Reihe nach durch. C# startet bei Pine.Main. Die erste Anweisung baut mit new Chip() ein Objekt und speichert es in c. Die zweite Anweisung ruft c.beep() auf. Innerhalb von beep schreibt WriteLine den Wert ok. Dann endet beep, und in Main bleibt nichts übrig — das Programm endet. Du hast Console.WriteLine("ok"); auf dieser Seite nicht in Pine gelegt. Du hast es unter Chip gelegt und über die Objektvariable angefordert.
Denk an die Klasse als Bauplan in der Datei und an das Objekt als ein gebautes Stück im Speicher für diesen Lauf. Jedes new Chip() baut ein weiteres Stück. Die Variable benennt das Stück, damit spätere Zeilen es erreichen. Ohne diesen Namen hat das gebaute Stück auf dieser Seite keinen Griff für beep.

Warum der Aufruf über c geht, nicht über Chip allein

Auf der Klassen-Seite konnte eine static-Methode als Badge.show() mit dem Typnamen aufgerufen werden. Hier hat beep kein Wort static. C# erwartet zuerst ein Objekt. Chip.beep(); ohne Objekt passt nicht zu dieser Anfängerform. Baue mit new, behalte das Ergebnis in einer Variable, dann rufe über diese Variable auf.
Schreibst du nur new Chip(); und speicherst es nie, hast du trotzdem ein Objekt gebaut, aber keinen Namen mehr, um beep aufzurufen. Auf dieser Seite behalte die Variable: Chip c = new Chip(); dann c.beep();. Die Variable ist der Weg zum Objekt, nachdem new fertig ist.
Ein übrig gebliebener static-Demo kann Main verwirren. Eine Datei, die noch Badge.show(); aufruft, ist die Form der vorherigen Lektion. Für diese Seite behalte Chip und Pine und die new-Zeile. Du brauchst hier kein Badge.

Zwei Objekte, zwei Beeps

Du kannst mehr als ein Objekt aus derselben Klasse bauen. Jedes new Chip() erzeugt ein eigenes Objekt. Jedes Objekt kann beep für sich ausführen. Der Klassentext ist gemeinsam; die Objekte sind nicht derselbe Wert.

Führe erneut mit dotnet run aus. Der Bildschirm sollte zwei Zeilen zeigen: ok, dann ok. Die erste Zeile kam von a. Die zweite kam von b. Beide nutzten denselben beep-Methodentext in Chip, aber jeder Aufruf lief auf einem anderen mit new gebauten Objekt.
Zeigt der Bildschirm nur ein ok, prüfe, ob beide Aufrufe da sind und ob beide Variablen mit new gebaut wurden. Chip b = a; baut kein zweites Objekt; es lässt b auf dasselbe Objekt wie a zeigen. Diese Idee kommt später. Auf dieser Seite nutze zwei new Chip()-Ausdrücke, wenn du zwei Objekte willst.
Du kannst die Variable von c in unit umbenennen, wenn du magst: Chip unit = new Chip(); dann unit.beep();. Der Bildschirm bleibt ok, solange der Methodenkörper dieses Wort schreibt. Der Variablenname gehört dir; der Typname Chip und der Ausdruck new Chip() müssen weiterhin zusammenpassen.

Was diese Seite für Felder übrig lässt

Diese Seite speichert noch keine Zahl und kein Wort im Chip. Felder — Namen, die Daten auf jedem Objekt halten — sind die nächste Seite. Hier existiert das Objekt nach new, und die Instanzmethode beep schreibt nur. Das reicht, um die Trennung zwischen Klasse als Typ und einem Objekt als gebautem Wert zu sehen.
Verschachtele Chip nicht in den Klammern von Pine. Auf dieser Seite sitzen die beiden Klassen als Geschwister in der Datei. Methoden von Chip sitzen in Chip. Main sitzt in Pine. Du kannst das geschriebene Wort in beep auf ping ändern und erneut laufen lassen. Der Bildschirm sollte dem String folgen, den du in Chip gesetzt hast. Die new- und Aufrufform in Pine bleibt gleich.
Wenn der Build Chip beim Übersetzen von Pine nicht findet, prüfe, dass public class Chip in derselben Datei steht und die Klassenzeile wirklich Chip sagt. Schreibt der Lauf nichts, bestätige, dass Main nach der new-Zeile noch c.beep(); aufruft und dass beep noch WriteLine enthält.

Du kannst Chip mit void beep() schreiben, ein Objekt mit Chip c = new Chip(); bauen und c.beep(); aus Pine.Main aufrufen. Starte mit dotnet run. Der Bildschirm zeigt ok. Ein zweites new Chip() baut ein weiteres Objekt, das für sich beep kann. Denk an Chip als Bauplan und an jedes new Chip() als ein gebautes Stück, das du benennen kannst. Pine bleibt die Tür, die du mit dotnet run öffnest. Die nächste Seite sind Felder, wo jedes Objekt eigene gespeicherte Daten zu halten beginnt.