static

Escreva uma classe Cup com um campo static int tally e um método static void Mark() que executa tally = tally + 1;. Em Pine, mantenha Main e chame Cup.Mark(); duas vezes, depois escreva Cup.tally. Mantenha os dois tipos no mesmo arquivo de ensino para dotnet run continuar simples. Execute com dotnet run. A tela deve mostrar uma linha: 2. O método roda pelo nome da classe, não por uma variável de objeto. Compartilhar um tally na classe é o que esta página ensina. Mantenha a classe pública inicial chamada Pine.

Um membro que pertence ao nome da classe

Na página métodos de instância você chamou j.bump() por uma variável jar. Aqui o campo e o método ficam em Cup mesmo. Você os alcança como Cup.Mark() e Cup.tally. Não há new Cup(...) necessário para essa chamada nesta página. Cada chamada a Mark soma um ao mesmo tally.
Abra o arquivo Pine. O nome da classe inicial permanece Pine. Esta página não renomeia o iniciador. Apague qualquer resto Jar j = new Jar(3); se essa demo bump ainda for tudo o que você tem em Main. Apague qualquer resto de classe Jar. Apague qualquer resto Tin. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação.
Fora das chaves de Pine — ainda no mesmo arquivo — escreva public class Cup. Dentro das chaves declare static int tally;. Depois escreva o método static: static void Mark() { tally = tally + 1; }. Não há construtor nem campo de instância nesta página. Salve o arquivo antes de executar.
O cabeçalho do método precisa de static e de void. A palavra static marca o membro como pertencente ao nome da classe. A palavra void ainda significa que Mark não devolve um valor para escrever. Mantenha as duas palavras nessa ordem no cabeçalho que você digita.

Pine chama Mark no nome da classe

Pine mantém public static void Main(). Dentro de Main, escreva três linhas nesta ordem: Cup.Mark();, depois Cup.Mark(); de novo, depois Console.WriteLine(Cup.tally);. Cada chamada soma um. A escrita mostra a contagem compartilhada. Você não escreve Jar j = new Jar(3); nem j.bump(); nesta página. Isso era a lição métodos de instância.

Leia o arquivo guardado desde o topo. using System; prepara nomes curtos. public class Pine é o iniciador. public static void Main() é onde o runtime começa — Main já é static, por isso o programa pode iniciar sem construir um objeto Pine primeiro. A chamada Cup.Mark() entra em Mark na classe. O corpo escreve tally = tally + 1. A primeira chamada leva tally de 0 a 1. A segunda leva a 2. Depois Main escreve Cup.tally e a tela mostra 2.
Execute com dotnet run. O programa escreve uma linha e para. Não espera você digitar. Se dotnet run ficar esperando, ReadLine ainda está no arquivo. Apague essa linha e mantenha as duas chamadas Cup.Mark(); e a escrita em Pine, com Mark em Cup. A tela mostra 2. Se a tela mostrar 4 ou 5, uma demo Jar bump restante pode ainda estar rodando. Se a tela mostrar 0, as chamadas Mark podem faltar ou rodar depois da escrita.
Se você escrever Mark(); sem Cup. na frente nesta forma de Main, a compilação recusa a menos que adicione mais fiação que esta página não ensina. Mantenha Cup.Mark();. Se você escrever Cup c = new Cup(); e só falar de métodos de instância de novo, saiu da lição static. O objetivo desta página é a chamada pelo nome da classe.

Comparado com j.bump e com um Jar restante

Na página métodos de instância, j.bump() precisava de um objeto na frente. Isso ainda funciona quando você quer uma mudança em um jar. Nesta página Cup.Mark() precisa do nome da classe na frente. Um resto Jar j = new Jar(3); j.bump(); Console.WriteLine(j.fill); é outra lição. Para esta página mantenha Cup e Pine e Cup.Mark();.
Você ainda pode inventar um método de instância depois. Esta lição mantém o contador compartilhado na classe para que duas chamadas sem new ainda compartilhem um tally. Escrever só Console.WriteLine(Cup); não mostra um 2 limpo. Escreva Console.WriteLine(Cup.tally); para ver o número guardado.

Um tally compartilhado por cada chamada Mark

Você não constrói dois cups para obter duas marcas nesta página. A primeira Cup.Mark(); e a segunda Cup.Mark(); tocam o mesmo campo static. Esse é o sentido de static int tally. Se depois adicionar objetos, eles ainda compartilham aquele tally a menos que invente outro desenho. Para o arquivo de ensino, duas chamadas pelo nome da classe bastam.
Se a tela ainda mostrar 1, só uma chamada Mark pode estar presente, ou uma escrita pode ficar entre as chamadas. Mantenha as duas chamadas antes de Console.WriteLine(Cup.tally);. Se a tela mostrar 7 ou outro número restante, uma demo antiga Tin ou Jar pode ainda estar no arquivo. Mantenha Cup.Mark(); duas vezes e a escrita em Cup.tally.

Erros que escondem a chamada static

Deixar static fora de Mark vira método de instância. Então Cup.Mark(); a partir de Main falha na compilação, e a página deixa de ensinar a chamada pelo nome da classe. Coloque static de volta no campo e no método. Chamar só j.bump(); porque o arquivo Jar ainda está aberto também esconde esta lição — apague essa demo de Main quando praticar Cup.
Outra armadilha é escrever só Cup.tally = Cup.tally + 1; dentro de Main e nunca escrever Mark. Isso pode imprimir 2 depois de duas atribuições, mas pula a forma de método static que esta página quer que você digite. Prefira duas linhas Cup.Mark(); para o corpo do método ser dono da soma. Se o IntelliSense oferecer chamada de instância depois de new Cup(), ignore para este exercício e fique com Cup.Mark();.

O que esta página deixa para access

Esta página alcança membros pelo nome da classe: Cup.Mark() e Cup.tally. Uma página depois — access — mostra palavras como public e private que controlam quem pode ver um membro. Fique com static aqui. Não invente palavras-chave de access em toda linha a menos que já as use; o objetivo da lição é a chamada pelo nome da classe e o campo compartilhado.
Não aninhe Cup dentro das chaves de Pine. Nesta página as duas classes ficam como irmãs no arquivo. Se a compilação não achar Cup ao compilar Pine, verifique que public class Cup está no mesmo arquivo. Se a tela mostrar 0, Mark pode nunca rodar — mantenha as duas linhas Cup.Mark(); antes da escrita. Se a compilação disser que Mark precisa de objeto, verifique que o cabeçalho do método ainda inclui static.

Você pode declarar static int tally;, escrever static void Mark() { tally = tally + 1; }, e a partir de Pine.Main rodar Cup.Mark(); duas vezes, depois escrever Cup.tally. Execute com dotnet run. A tela mostra 2. O método static rodou no nome da classe e mudou o campo compartilhado. Veja Mark como uma ação que a classe mesma pode fazer sem construir um cup primeiro. Pine continua sendo a porta que você abre com dotnet run. A próxima página é access, onde alguns membros são abertos ou fechados a outro código de propósito.
Mantenha static no campo e no método. Mantenha o nome da classe antes da chamada: Cup.Mark();. Mantenha a escrita em Cup.tally. Esses três hábitos são o checkpoint desta página antes de seguir. Deixe demos restantes j.bump() fora de Main para a tela não mostrar um número de jar por engano.