Métodos de instância

Escreva uma classe Jar com um campo int chamado fill, um construtor Jar(int n) que faz fill = n;, e um método de instância void bump() que executa fill = fill + 1;. Em Pine, mantenha Main e construa um jar com Jar j = new Jar(3);, chame j.bump();, depois escreva j.fill. Mantenha os dois tipos no mesmo arquivo de ensino para dotnet run continuar simples. Execute com dotnet run. A tela deve mostrar uma linha: 4. O método roda naquele único objeto e muda o campo dele. Chamar um método pela variável do objeto é o que esta página ensina. Mantenha a classe pública inicial chamada Pine.

Um método que pertence ao objeto

Nas páginas de métodos anteriores você chamava um nome a partir de Main sem objeto na frente. Aqui o método fica na classe, mas você o alcança pela variável jar: j.bump(). Essa chamada usa os campos do jar que j nomeia. Um segundo jar guardaria o próprio fill.
Abra o arquivo Pine. O nome da classe inicial permanece Pine. Esta página não renomeia o iniciador. Apague qualquer resto Tin t = new Tin(7); se aquela chamada da página this ainda for tudo o que você tem em Main. Apague qualquer resto de classe 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 Jar. Dentro das chaves declare int fill;. Escreva o construtor Jar(int n) { fill = n; } com nomes diferentes para esta página não precisar de this. Depois escreva o método de instância: void bump() { fill = fill + 1; }. Não há Main em Jar nesta página. Salve o arquivo antes de executar.
O cabeçalho do método precisa de void porque bump não devolve um valor para escrever. O construtor ainda não tem void — mantenha essa diferença clara.

Pine constrói um jar e chama bump

Pine mantém public static void Main(). Dentro de Main, escreva três linhas nesta ordem: Jar j = new Jar(3);, depois j.bump();, depois Console.WriteLine(j.fill);. O construtor guarda 3. A chamada j.bump() soma um. A escrita mostra o valor novo. Você não escreve Tin t = new Tin(7); nesta página. Essa era a lição this.

Leia o arquivo guardado de cima. using System; prepara nomes curtos. public class Pine é o iniciador. public static void Main() é onde o runtime começa. A expressão new Jar(3) constrói um jar e guarda 3 em fill. A chamada j.bump() entra em bump naquele mesmo objeto. O corpo escreve fill = fill + 1, então fill vira 4. Depois Main escreve j.fill e a tela mostra 4.
Execute com dotnet run. O programa escreve uma linha e para. Não espera você digitar. Se dotnet run esperar, ReadLine ainda está no arquivo. Apague essa linha e mantenha new Jar(3), j.bump(), e a escrita em Pine, com bump em Jar. A tela mostra 4. Se a tela mostrar 7, uma demo Tin restante ainda está rodando. Se a tela mostrar 3, a chamada bump pode estar faltando ou rodando depois da escrita.
Se você escrever bump(); sem j. na frente, a compilação recusa nesta forma de Main. O método de instância precisa de um objeto. Se você escrever Jar.bump(); como se fosse uma chamada static, essa é a ideia da lição seguinte — não desta página. Mantenha j.bump();.

Comparado com this e com atribuição simples de campo

Na página this você guardava um campo dentro do construtor com nomes combinados. Isso ainda funciona. Esta página acrescenta um método que você pode chamar depois, quando o objeto já existe. Um resto Tin t = new Tin(7); com this.size = size; é outra lição. Para esta página mantenha Jar e Pine e j.bump();.
Você ainda poderia escrever j.fill = j.fill + 1; em Main. Esta lição move essa mudança para dentro de bump para o objeto carregar a ação. Escrever só Console.WriteLine(j); não mostra um 4 limpo. Escreva Console.WriteLine(j.fill); para ver o número guardado.

Dois bumps num jar

Você pode chamar j.bump(); duas vezes antes de escrever. Comece com new Jar(3), um bump até 4, outro bump até 5, depois escreva. Essa checagem cabe numa pequena segunda demo pine.

Execute de novo com dotnet run. A tela deve mostrar 5. Cada chamada a bump rodou no mesmo objeto e somou mais um. Escrever Jar k = j; não constrói um segundo objeto — use duas chamadas new Jar(...) quando quiser dois fills separados. Para esta página, dois bumps num jar bastam para ver o método rodar duas vezes.
Se a tela ainda mostrar 3, as chamadas bump podem estar faltando ou Main ainda escrever antes de chamá-las. Se mostrar 7 ou outro número restante, uma demo Tin antiga pode ainda estar no arquivo. Mantenha new Jar(3) e as chamadas bump.

O que esta página deixa para static

Esta página chama o método pelo objeto: j.bump(). Uma página depois — static — mostra métodos e campos que pertencem ao próprio nome da classe sem objeto na frente. Fique com a chamada de instância aqui. Não invente static void bump() nesta página a menos que você já a conheça; o objetivo da lição é a chamada no objeto.
Não aninhe Jar dentro das chaves de Pine. Nesta página as duas classes ficam como irmãs no arquivo. Se a compilação não encontrar Jar ao compilar Pine, confira que public class Jar está no mesmo arquivo. Se a tela mostrar 0, o construtor pode estar sem a guarda, ou bump nunca roda — mantenha Jar(int n) { fill = n; } e j.bump(); antes da escrita.

Você pode declarar int fill;, escrever Jar(int n) { fill = n; } e void bump() { fill = fill + 1; }, e a partir de Pine.Main rodar Jar j = new Jar(3);, j.bump();, depois escrever j.fill. Execute com dotnet run. A tela mostra 4. O método de instância rodou naquele objeto e mudou o campo. Pense em bump como uma ação que o jar pode fazer depois de existir. Pine continua a porta que você abre com dotnet run. A próxima página é static, onde alguns membros pertencem ao nome da classe sem precisar de uma variável de objeto na frente.
Mantenha void no método, não no construtor. Mantenha o objeto antes da chamada: j.bump();. Mantenha a escrita em j.fill. Esses três hábitos são o ponto de verificação desta página antes de seguir.