static

Escribe una clase Cup con un campo static int tally y un método static void Mark() que ejecuta tally = tally + 1;. En Pine, conserva Main y llama Cup.Mark(); dos veces, luego escribe Cup.tally. Mantén ambos tipos en el mismo archivo de enseñanza para que dotnet run siga siendo simple. Ejecuta con dotnet run. La pantalla debería mostrar una línea: 2. El método corre por el nombre de la clase, no por una variable de objeto. Compartir un tally en la clase es lo que enseña esta página. Mantén el nombre de la clase pública de inicio Pine.

Un miembro que pertenece al nombre de la clase

En la página de métodos de instancia llamaste j.bump() por una variable jar. Aquí el campo y el método se sientan en Cup misma. Los alcanzas como Cup.Mark() y Cup.tally. No necesitas new Cup(...) para esa llamada en esta página. Cada llamada a Mark suma uno al mismo tally.
Abre el archivo Pine. El nombre de la clase de inicio sigue siendo Pine. Esta página no renombra el iniciador. Borra cualquier Jar j = new Jar(3); sobrante si esa demo bump es todo lo que tienes en Main. Borra cualquier clase Jar sobrante. Borra cualquier resto de Tin. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura.
Fuera de las llaves de Pine — todavía en el mismo archivo — escribe public class Cup. Dentro de las llaves declara static int tally;. Luego escribe el método static: static void Mark() { tally = tally + 1; }. En esta página no hay constructor ni campo de instancia. Guarda el archivo antes de ejecutar.
La cabecera del método necesita static y void. La palabra static marca el miembro como perteneciente al nombre de la clase. La palabra void sigue significando que Mark no devuelve un valor para escribir. Conserva ambas palabras en ese orden en la cabecera que escribes.

Pine llama Mark en el nombre de la clase

Pine conserva public static void Main(). Dentro de Main, escribe tres líneas en orden: Cup.Mark();, luego otra vez Cup.Mark();, luego Console.WriteLine(Cup.tally);. Cada llamada suma uno. La escritura muestra el conteo compartido. En esta página no escribes Jar j = new Jar(3); ni j.bump();. Esa fue la lección de métodos de instancia.

Lee el archivo guardado desde arriba. using System; prepara nombres cortos. public class Pine es el iniciador. public static void Main() es donde arranca el tiempo de ejecución — Main ya es static, por eso el programa puede empezar sin construir un objeto Pine primero. La llamada Cup.Mark() entra en Mark en la clase. El cuerpo escribe tally = tally + 1. La primera llamada mueve tally de 0 a 1. La segunda lo lleva a 2. Luego Main escribe Cup.tally y la pantalla muestra 2.
Ejecútalo con dotnet run. El programa escribe una línea y para. No espera a que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén en Pine las dos llamadas Cup.Mark(); y la escritura, con Mark en Cup. La pantalla muestra 2. Si la pantalla muestra 4 o 5, puede que aún corra una demo sobrante de Jar bump. Si muestra 0, faltan las llamadas Mark o corren después de la escritura.
Si escribes Mark(); sin Cup. delante desde esta forma de Main, la compilación rechaza a menos que añadas más cableado que esta página no enseña. Mantén Cup.Mark();. Si escribes Cup c = new Cup(); y solo hablas otra vez de métodos de instancia, abandonaste la lección static. El objetivo de esta página es la llamada por nombre de clase.

Comparado con j.bump y con Jar sobrante

En la página de métodos de instancia, j.bump() necesitaba un objeto delante. Eso sigue funcionando cuando quieres un cambio en un jar. En esta página Cup.Mark() necesita el nombre de la clase delante. Un resto Jar j = new Jar(3); j.bump(); Console.WriteLine(j.fill); es otra lección. Para esta página mantén Cup, Pine y Cup.Mark();.
Podrías inventar después un método de instancia. Esta lección mantiene el contador compartido en la clase para que dos llamadas sin new sigan compartiendo un tally. Escribir Console.WriteLine(Cup); solo no muestra un 2 limpio. Escribe Console.WriteLine(Cup.tally); para ver el número guardado.

Un tally que comparte cada llamada Mark

No construyes dos cups para dos marcas en esta página. El primer Cup.Mark(); y el segundo Cup.Mark(); tocan el mismo campo static. Ese es el punto de static int tally. Si luego añades objetos, siguen compartiendo ese tally a menos que inventes otro diseño. Para el archivo de enseñanza bastan dos llamadas por nombre de clase.
Si la pantalla aún muestra 1, quizá solo hay una llamada Mark, o una escritura quedó entre las llamadas. Mantén ambas llamadas antes de Console.WriteLine(Cup.tally);. Si la pantalla muestra 7 u otro número sobrante, puede que una demo antigua de Tin o Jar siga en el archivo. Mantén Cup.Mark(); dos veces y la escritura en Cup.tally.

Errores que esconden la llamada static

Quitar static de Mark lo convierte en método de instancia. Entonces Cup.Mark(); desde Main falla la compilación y la página deja de enseñar la llamada por nombre de clase. Vuelve a poner static en el campo y en el método. Llamar solo j.bump(); porque el archivo Jar sigue abierto también esconde esta lección — borra esa demo de Main cuando practiques Cup.
Otra trampa es escribir solo Cup.tally = Cup.tally + 1; dentro de Main y nunca escribir Mark. Puede imprimir 2 tras dos asignaciones, pero salta la forma de método static que esta página quiere que escribas. Prefiere dos líneas Cup.Mark(); para que el cuerpo del método posea la suma. Si IntelliSense ofrece una llamada de instancia tras new Cup(), ignórala en este ejercicio y quédate con Cup.Mark();.

Lo que esta página deja para access

Esta página alcanza miembros por el nombre de la clase: Cup.Mark() y Cup.tally. Una página posterior — access — muestra palabras como public y private que controlan quién ve un miembro. Quédate con static aquí. No inventes palabras de acceso en cada línea a menos que ya las uses; el objetivo de la lección es la llamada por nombre de clase y el campo compartido.
No anides Cup dentro de las llaves de Pine. En esta página las dos clases son hermanas en el archivo. Si la compilación no encuentra Cup al compilar Pine, comprueba que public class Cup está en el mismo archivo. Si la pantalla muestra 0, Mark quizá nunca corrió — mantén las dos líneas Cup.Mark(); antes de la escritura. Si la compilación se queja de que Mark necesita un objeto, comprueba que la cabecera del método sigue incluyendo static.

Puedes declarar static int tally;, escribir static void Mark() { tally = tally + 1; }, y desde Pine.Main ejecutar Cup.Mark(); dos veces, luego escribir Cup.tally. Ejecuta con dotnet run. La pantalla muestra 2. El método static corrió en el nombre de la clase y cambió el campo compartido. Piensa en Mark como una acción que la clase misma puede hacer sin construir un cup primero. Pine sigue siendo la puerta que abres con dotnet run. La página siguiente es access, donde algunos miembros se abren o cierran a otro código a propósito.
Mantén static en el campo y en el método. Mantén el nombre de la clase antes de la llamada: Cup.Mark();. Mantén la escritura en Cup.tally. Esos tres hábitos son el punto de control de esta página antes de seguir. Deja fuera de Main demos sobrantes de j.bump() para que la pantalla no muestre por error un número de jar.