static

Schreibe eine Klasse Cup mit einem static-Feld int tally und einer static-Methode void Mark(), die tally = tally + 1; ausführt. In Pine behältst du Main und rufst Cup.Mark(); zweimal auf, dann schreibst du Cup.tally. Halte beide Typen in derselben Lehrdatei, damit dotnet run einfach bleibt. Starte mit dotnet run. Der Bildschirm sollte eine Zeile zeigen: 2. Die Methode läuft über den Klassennamen, nicht über eine Objektvariable. Ein gemeinsames tally auf der Klasse lehrt diese Seite. Behalte den öffentlichen Startklassennamen Pine.

Ein Mitglied, das zum Klassennamen gehört

Auf der Instanzmethoden-Seite hast du j.bump() über eine jar-Variable aufgerufen. Hier sitzen Feld und Methode auf Cup selbst. Du erreichst sie als Cup.Mark() und Cup.tally. Für diesen Aufruf brauchst du auf dieser Seite kein new Cup(...). Jeder Aufruf von Mark addiert eins zum selben tally.
Öffne die Pine-Datei. Der Startklassenname bleibt Pine. Diese Seite benennt den Starter nicht um. Lösche jedes übrig gebliebene Jar j = new Jar(3);, falls die bump-Demo noch alles in Main ist. Lösche jede übrig gebliebene Jar-Klasse. Lösche jeden Tin-Rest. 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 Cup. Innerhalb der Klammern deklariere static int tally;. Dann schreibe die static-Methode: static void Mark() { tally = tally + 1; }. Auf dieser Seite gibt es weder Konstruktor noch Instanzfeld. Speichere die Datei vor dem Lauf.
Die Methodenkopfzeile braucht sowohl static als auch void. Das Wort static markiert das Mitglied als zum Klassennamen gehörend. Das Wort void bedeutet weiterhin, dass Mark keinen Wert zum Schreiben zurückgibt. Behalte beide Wörter in dieser Reihenfolge in der Kopfzeile, die du tippst.

Pine ruft Mark über den Klassennamen auf

Pine behält public static void Main(). Innerhalb von Main schreibst du drei Zeilen der Reihe nach: Cup.Mark();, dann noch einmal Cup.Mark();, dann Console.WriteLine(Cup.tally);. Jeder Aufruf addiert eins. Die Schreibzeile zeigt die gemeinsame Zählung. Auf dieser Seite schreibst du weder Jar j = new Jar(3); noch j.bump();. Das war die Instanzmethoden-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 — Main selbst ist schon static, deshalb kann das Programm ohne ein Pine-Objekt zuerst beginnen. Der Aufruf Cup.Mark() betritt Mark an der Klasse. Der Körper schreibt tally = tally + 1. Der erste Aufruf bewegt tally von 0 auf 1. Der zweite auf 2. Dann schreibt Main Cup.tally und der Bildschirm zeigt 2.
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 die beiden Cup.Mark(); und die Schreibzeile, mit Mark in Cup. Der Bildschirm zeigt 2. Zeigt der Bildschirm 4 oder 5, läuft vielleicht noch eine übrig gebliebene Jar-bump-Demo. Zeigt der Bildschirm 0, fehlen die Mark-Aufrufe oder sie laufen nach der Schreibzeile.
Schreibst du Mark(); ohne Cup. davor aus dieser Form von Main, lehnt der Build ab, es sei denn, du fügst Verdrahtung hinzu, die diese Seite nicht lehrt. Behalte Cup.Mark();. Schreibst du Cup c = new Cup(); und sprichst dann nur noch von Instanzmethoden, hast du die static-Lektion verlassen. Das Ziel dieser Seite ist der Aufruf über den Klassennamen.

Verglichen mit j.bump und übrig gebliebenem Jar

Auf der Instanzmethoden-Seite brauchte j.bump() ein Objekt davor. Das funktioniert weiterhin, wenn du eine Änderung an einem jar willst. Auf dieser Seite braucht Cup.Mark() den Klassennamen davor. Ein übrig gebliebenes Jar j = new Jar(3); j.bump(); Console.WriteLine(j.fill); ist eine andere Lektion. Für diese Seite behalte Cup, Pine und Cup.Mark();.
Du könntest später noch eine Instanzmethode erfinden. Diese Lektion hält den gemeinsamen Zähler auf der Klasse, sodass zwei Aufrufe ohne new ein tally teilen. Console.WriteLine(Cup); allein zeigt kein sauberes 2. Schreibe Console.WriteLine(Cup.tally);, um die gespeicherte Zahl zu sehen.

Ein tally, das jeder Mark-Aufruf teilt

Du baust auf dieser Seite keine zwei cups, um zwei Markierungen zu bekommen. Der erste Cup.Mark(); und der zweite Cup.Mark(); berühren dasselbe static-Feld. Darum geht es bei static int tally. Wenn du später Objekte hinzufügst, teilen sie weiterhin dieses eine tally, es sei denn, du erfindest ein anderes Design. Für die Lehrdatei reichen zwei Aufrufe über den Klassennamen.
Zeigt der Bildschirm noch 1, ist vielleicht nur ein Mark-Aufruf da oder eine Schreibzeile zwischen den Aufrufen. Behalte beide Aufrufe vor Console.WriteLine(Cup.tally);. Zeigt der Bildschirm 7 oder eine andere Restzahl, steckt vielleicht noch eine ältere Tin- oder Jar-Demo in der Datei. Behalte Cup.Mark(); zweimal und die Schreibzeile auf Cup.tally.

Fehler, die den static-Aufruf verstecken

Fehlt static an Mark, wird es eine Instanzmethode. Dann scheitert Cup.Mark(); aus Main am Build, und die Seite lehrt den Klassennamen-Aufruf nicht mehr. Setze static auf Feld und Methode zurück. Nur j.bump(); aufzurufen, weil die Jar-Datei noch offen ist, versteckt diese Lektion ebenfalls — lösche diese Demo aus Main, wenn du Cup übst.
Eine Falle ist, nur Cup.tally = Cup.tally + 1; in Main zu schreiben und nie Mark. Nach zwei Zuweisungen kann das 2 ausgeben, aber es überspringt die static-Methodenform, die du auf dieser Seite tippen sollst. Bevorzuge zwei Zeilen Cup.Mark();, damit der Methodenkörper die Addition besitzt. Bietet IntelliSense nach new Cup() einen Instanzaufruf an, ignoriere das für diese Übung und bleibe bei Cup.Mark();.

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

Diese Seite erreicht Mitglieder über den Klassennamen: Cup.Mark() und Cup.tally. Eine spätere Seite — access — zeigt Wörter wie public und private, die steuern, wer ein Mitglied sehen darf. Bleibe hier bei static. Erfinde nicht an jeder Zeile Zugriffsschlüsselwörter, es sei denn, du nutzt sie schon; das Lernziel ist der Klassennamen-Aufruf und das gemeinsame Feld.
Verschachtle Cup nicht innerhalb der Klammern von Pine. Auf dieser Seite sitzen die beiden Klassen als Geschwister in der Datei. Findet der Build Cup beim Kompilieren von Pine nicht, prüfe, ob public class Cup in derselben Datei steht. Zeigt der Bildschirm 0, lief Mark vielleicht nie — behalte beide Cup.Mark();-Zeilen vor der Schreibzeile. Beschwert sich der Build, dass Mark ein Objekt braucht, prüfe, ob die Methodenkopfzeile noch static enthält.

Du kannst static int tally; deklarieren, static void Mark() { tally = tally + 1; } schreiben und aus Pine.Main Cup.Mark(); zweimal laufen lassen, dann Cup.tally schreiben. Starte mit dotnet run. Der Bildschirm zeigt 2. Die static-Methode lief auf dem Klassennamen und änderte das gemeinsame Feld. Sieh Mark als Aktion, die die Klasse selbst ohne cup zuerst ausführen kann. Pine bleibt die Tür, die du mit dotnet run öffnest. Die nächste Seite ist access, wo manche Mitglieder absichtlich für anderen Code offen oder geschlossen sind.
Behalte static auf Feld und Methode. Behalte den Klassennamen vor dem Aufruf: Cup.Mark();. Behalte die Schreibzeile auf Cup.tally. Diese drei Gewohnheiten sind der Checkpoint dieser Seite, bevor du weitergehst. Lass übrig gebliebene j.bump()-Demos aus Main, damit der Bildschirm nicht versehentlich eine jar-Zahl zeigt.