static

Écrivez une classe Cup avec un champ static int tally et une méthode static void Mark() qui exécute tally = tally + 1;. Dans Pine, gardez Main et appelez Cup.Mark(); deux fois, puis écrivez Cup.tally. Gardez les deux types dans le même fichier d'enseignement pour que dotnet run reste simple. Lancez avec dotnet run. L'écran doit montrer une ligne : 2. La méthode tourne par le nom de la classe, pas par une variable d'objet. Partager un tally sur la classe est ce que cette page enseigne. Gardez la classe publique de démarrage nommée Pine.

Un membre qui appartient au nom de la classe

Sur la page méthodes d'instance vous appeliez j.bump() par une variable jar. Ici le champ et la méthode siègent sur Cup lui-même. Vous les atteignez comme Cup.Mark() et Cup.tally. Aucun new Cup(...) n'est requis pour cet appel sur cette page. Chaque appel à Mark ajoute un au même tally.
Ouvrez le fichier Pine. Le nom de la classe de démarrage reste Pine. Cette page ne renomme pas le démarreur. Supprimez tout reste Jar j = new Jar(3); si cette démo bump est encore tout ce que vous avez dans Main. Supprimez tout reste de classe Jar. Supprimez tout reste Tin. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas de frappe.
Hors des accolades de Pine — toujours dans le même fichier — écrivez public class Cup. À l'intérieur des accolades déclarez static int tally;. Puis écrivez la méthode static : static void Mark() { tally = tally + 1; }. Il n'y a pas de constructeur ni de champ d'instance sur cette page. Enregistrez le fichier avant de lancer.
L'en-tête de la méthode a besoin de static et de void. Le mot static marque le membre comme appartenant au nom de la classe. Le mot void signifie toujours que Mark ne renvoie pas de valeur à écrire. Gardez les deux mots dans cet ordre dans l'en-tête que vous tapez.

Pine appelle Mark sur le nom de la classe

Pine garde public static void Main(). À l'intérieur de Main, écrivez trois lignes dans l'ordre : Cup.Mark();, puis Cup.Mark(); encore, puis Console.WriteLine(Cup.tally);. Chaque appel ajoute un. L'écriture montre le compte partagé. Vous n'écrivez pas Jar j = new Jar(3); ni j.bump(); sur cette page. C'était la leçon méthodes d'instance.

Relisez le fichier conservé depuis le haut. using System; prépare les noms courts. public class Pine est le démarreur. public static void Main() est l'endroit où le runtime commence — Main est déjà static, c'est pourquoi le programme peut démarrer sans construire d'abord un objet Pine. L'appel Cup.Mark() entre dans Mark sur la classe. Le corps écrit tally = tally + 1. Le premier appel fait passer tally de 0 à 1. Le second le porte à 2. Puis Main écrit Cup.tally et l'écran montre 2.
Lancez avec dotnet run. Le programme écrit une ligne et s'arrête. Il n'attend pas que vous tapiez. Si dotnet run attend, ReadLine est encore dans le fichier. Supprimez cette ligne et gardez les deux appels Cup.Mark(); et l'écriture dans Pine, avec Mark dans Cup. L'écran montre 2. Si l'écran montre 4 ou 5, une démo Jar bump restante peut encore tourner. Si l'écran montre 0, les appels Mark peuvent manquer ou tourner après l'écriture.
Si vous écrivez Mark(); sans Cup. devant dans cette forme de Main, la compilation refuse sauf si vous ajoutez du câblage que cette page n'enseigne pas. Gardez Cup.Mark();. Si vous écrivez Cup c = new Cup(); puis ne parlez plus que des méthodes d'instance, vous avez quitté la leçon static. Le but de cette page est l'appel par le nom de la classe.

Comparé avec j.bump et avec un Jar restant

Sur la page méthodes d'instance, j.bump() avait besoin d'un objet devant. Cela marche encore quand vous voulez un changement sur un seul jar. Sur cette page Cup.Mark() a besoin du nom de la classe devant. Un reste Jar j = new Jar(3); j.bump(); Console.WriteLine(j.fill); est une autre leçon. Pour cette page gardez Cup et Pine et Cup.Mark();.
Vous pourriez encore inventer une méthode d'instance plus tard. Cette leçon garde le compteur partagé sur la classe pour que deux appels sans new partagent encore un tally. Écrire seulement Console.WriteLine(Cup); ne montre pas un 2 propre. Écrivez Console.WriteLine(Cup.tally); pour voir le nombre stocké.

Un tally partagé par chaque appel Mark

Vous ne construisez pas deux cups pour obtenir deux marques sur cette page. Le premier Cup.Mark(); et le second Cup.Mark(); touchent tous deux le même champ static. C'est le sens de static int tally. Si vous ajoutez des objets plus tard, ils partagent encore ce tally sauf si vous inventez un autre design. Pour le fichier d'enseignement, deux appels par le nom de la classe suffisent.
Si l'écran montre encore 1, un seul appel Mark est peut-être présent, ou une écriture peut se trouver entre les appels. Gardez les deux appels avant Console.WriteLine(Cup.tally);. Si l'écran montre 7 ou un autre nombre restant, une ancienne démo Tin ou Jar peut encore être dans le fichier. Gardez Cup.Mark(); deux fois et l'écriture sur Cup.tally.

Erreurs qui masquent l'appel static

Laisser static hors de Mark en fait une méthode d'instance. Alors Cup.Mark(); depuis Main échoue à la compilation, et la page n'enseigne plus l'appel par le nom de la classe. Remettez static sur le champ et sur la méthode. N'appeler que j.bump(); parce que le fichier Jar est encore ouvert masque aussi cette leçon — supprimez cette démo de Main quand vous pratiquez Cup.
Un autre piège est d'écrire seulement Cup.tally = Cup.tally + 1; dans Main sans jamais écrire Mark. Cela peut imprimer 2 après deux assignations, mais cela évite la forme de méthode static que cette page veut que vous tapiez. Préférez deux lignes Cup.Mark(); pour que le corps de la méthode possède l'addition. Si IntelliSense propose un appel d'instance après new Cup(), ignorez-le pour cet exercice et restez avec Cup.Mark();.

Ce que cette page laisse à access

Cette page atteint les membres par le nom de la classe : Cup.Mark() et Cup.tally. Une page plus tard — access — montre des mots comme public et private qui contrôlent qui peut voir un membre. Restez avec static ici. N'inventez pas de mots-clés d'access sur chaque ligne sauf si vous les utilisez déjà ; le but de la leçon est l'appel par le nom de la classe et le champ partagé.
Ne imbriquez pas Cup dans les accolades de Pine. Sur cette page les deux classes siègent comme sœurs dans le fichier. Si la compilation ne trouve pas Cup en compilant Pine, vérifiez que public class Cup se trouve dans le même fichier. Si l'écran montre 0, Mark peut ne jamais tourner — gardez les deux lignes Cup.Mark(); avant l'écriture. Si la compilation dit que Mark a besoin d'un objet, vérifiez que l'en-tête de la méthode inclut encore static.

Vous pouvez déclarer static int tally;, écrire static void Mark() { tally = tally + 1; }, et depuis Pine.Main lancer Cup.Mark(); deux fois, puis écrire Cup.tally. Lancez avec dotnet run. L'écran montre 2. La méthode static a tourné sur le nom de la classe et a changé le champ partagé. Voyez Mark comme une action que la classe elle-même peut faire sans construire d'abord un cup. Pine reste la porte que vous ouvrez avec dotnet run. La page suivante est access, où certains membres sont ouverts ou fermés à d'autres code volontairement.
Gardez static sur le champ et sur la méthode. Gardez le nom de la classe avant l'appel : Cup.Mark();. Gardez l'écriture sur Cup.tally. Ces trois habitudes sont le point de contrôle de cette page avant de passer à la suite. Laissez les démos restantes j.bump() hors de Main pour que l'écran ne montre pas un nombre de jar par erreur.