Métodos de instancia

Escribe una clase Jar con un campo int llamado fill, un constructor Jar(int n) que pone fill = n;, y un método de instancia void bump() que ejecuta fill = fill + 1;. En Pine, conserva Main y construye un jar con Jar j = new Jar(3);, llama j.bump();, luego escribe j.fill. 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: 4. El método corre en ese único objeto y cambia su campo. Llamar un método a través de la variable de objeto es lo que enseña esta página. Mantén el nombre de la clase pública de inicio Pine.

Un método que pertenece al objeto

En las páginas de métodos anteriores llamabas un nombre desde Main sin un objeto delante. Aquí el método se sienta en la clase, pero lo alcanzas por una variable jar: j.bump(). Esa llamada usa los campos del jar que j nombra. Un segundo jar guarda su propio fill.
Abre el archivo Pine. El nombre de la clase de inicio sigue siendo Pine. Esta página no renombra el iniciador. Borra cualquier resto de Tin t = new Tin(7); si esa llamada de la página this es todo lo que aún tienes en Main. Borra cualquier resto de la clase 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 Jar. Dentro de las llaves declara int fill;. Escribe el constructor Jar(int n) { fill = n; } con nombres distintos para que esta página no necesite this. Luego escribe el método de instancia: void bump() { fill = fill + 1; }. En esta página no hay Main dentro de Jar. Guarda el archivo antes de ejecutar.
La cabecera del método necesita void porque bump no devuelve un valor para escribir. El constructor sigue sin void — mantén esa diferencia clara.

Pine construye un jar y llama bump

Pine conserva public static void Main(). Dentro de Main, escribe tres líneas en orden: Jar j = new Jar(3);, luego j.bump();, luego Console.WriteLine(j.fill);. El constructor guarda 3. La llamada j.bump() suma uno. La escritura muestra el valor nuevo. En esta página no escribes Tin t = new Tin(7);. Esa fue la lección this.

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. La expresión new Jar(3) construye un jar y guarda 3 en fill. La llamada j.bump() entra en bump en ese mismo objeto. El cuerpo escribe fill = fill + 1, así que fill pasa a ser 4. Luego Main escribe j.fill y la pantalla muestra 4.
Ejecútalo con dotnet run. El programa escribe una línea y para. No espera a que tú escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén en Pine new Jar(3), j.bump() y la escritura, con bump en Jar. La pantalla muestra 4. Si la pantalla muestra 7, aún corre una demo sobrante de Tin. Si la pantalla muestra 3, la llamada bump puede faltar o correr después de la escritura.
Si escribes bump(); sin j. delante, la compilación rechaza en esta forma de Main. El método de instancia necesita un objeto. Si escribes Jar.bump(); como si fuera una llamada static, esa es la idea de la lección siguiente — no de esta página. Mantén j.bump();.

Comparado con this y con asignación simple de campo

En la página this guardabas un campo dentro del constructor con nombres coincidentes. Eso sigue funcionando. Esta página añade un método que puedes llamar después, cuando el objeto ya existe. Un resto Tin t = new Tin(7); con this.size = size; es otra lección. Para esta página mantén Jar y Pine y j.bump();.
Todavía podrías escribir j.fill = j.fill + 1; en Main. Esta lección mueve ese cambio dentro de bump para que el objeto lleve la acción. Escribir Console.WriteLine(j); solo no muestra un 4 limpio. Escribe Console.WriteLine(j.fill); para ver el número guardado.

Dos bumps en un jar

Puedes llamar j.bump(); dos veces antes de escribir. Empieza con new Jar(3), un bump hasta 4, otro bump hasta 5, luego escribe. Esa comprobación cabe en una segunda demo pequeña de Pine.

Ejecuta otra vez con dotnet run. La pantalla debería mostrar 5. Cada llamada a bump corrió en el mismo objeto y sumó uno más. Escribir Jar k = j; no construye un segundo objeto — usa dos llamadas new Jar(...) cuando quieras dos fills separados. Para esta página, dos bumps en un jar bastan para ver el método correr dos veces.
Si la pantalla aún muestra 3, pueden faltar las llamadas bump o Main puede escribir antes de llamarlas. Si muestra 7 u otro número sobrante, puede quedar una demo antigua de Tin en el archivo. Mantén new Jar(3) y las llamadas bump.

Qué deja esta página para static

Esta página llama el método a través de un objeto: j.bump(). Una página posterior — static — muestra métodos y campos que pertenecen al nombre de la clase mismo sin un objeto delante. Quédate con la llamada de instancia aquí. No inventes static void bump() en esta página a menos que ya lo sepas; el objetivo de la lección es la llamada en el objeto.
No anides Jar dentro de las llaves de Pine. En esta página las dos clases se sientan como hermanas en el archivo. Si la compilación no encuentra Jar al compilar Pine, comprueba que public class Jar está en el mismo archivo. Si la pantalla muestra 0, el constructor puede no guardar, o bump puede no correr nunca — mantén Jar(int n) { fill = n; } y j.bump(); antes de la escritura.

Puedes declarar int fill;, escribir Jar(int n) { fill = n; } y void bump() { fill = fill + 1; }, y desde Pine.Main ejecutar Jar j = new Jar(3);, j.bump();, luego escribir j.fill. Ejecuta con dotnet run. La pantalla muestra 4. El método de instancia corrió en ese objeto y cambió su campo. Piensa en bump como una acción que el jar puede hacer después de existir. Pine sigue siendo la puerta que abres con dotnet run. La página siguiente es static, donde algunos miembros pertenecen al nombre de la clase sin necesitar una variable de objeto delante.
Mantén void en el método, no en el constructor. Mantén el objeto delante de la llamada: j.bump();. Mantén la escritura en j.fill. Esos tres hábitos son el punto de control de esta página antes de seguir.