Métodos de instância em Java

Escreva uma classe Jar em Jar.java 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 Desk.java, construa um jar com Jar j = new Jar(3);, chame j.bump();, depois imprima j.fill. Compile ambos os ficheiros e execute java Desk. O ecrã deve mostrar uma linha: 4. O método corre nesse único objeto e muda o seu campo. Chamar um método através da variável do objeto é o que esta página ensina.

Um método que pertence ao objeto

Nas páginas de métodos anteriores você chamava um nome a partir de main sem objeto à frente. Aqui o método está na classe, mas você chega a ele através de uma variável jar: j.bump(). Essa chamada usa os campos do jar que j nomeia. Um segundo jar manteria o seu próprio fill.
Crie Jar.java primeiro. A linha public class é public class Jar. Não deixe um nome de classe antigo Tin ou Box aqui. Dentro das chavetas 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.java. Guarde antes de compilar. O cabeçalho do método precisa de void porque bump não devolve um valor para imprimir. O construtor ainda não tem void — mantenha essa diferença clara.

Desk constrói um jar e chama bump

Crie Desk.java na mesma pasta. A linha public class é public class Desk. Dentro de main, escreva três linhas por ordem: Jar j = new Jar(3);, depois j.bump();, depois System.out.println(j.fill);. O construtor guarda 3. A chamada j.bump() soma um. A impressão mostra o novo valor.
Mantenha Desk como a classe que tem main. Não coloque main dentro de Jar nesta lição. Se um ficheiro Lab restante da página this ainda está na pasta, não execute java Lab nesta lição — execute java Desk depois de compilar Jar.java e Desk.java.

Da pasta que guarda ambos os ficheiros, execute javac Jar.java Desk.java. Você pode compilar Jar.java primeiro e Desk.java em seguida quando ambos estiverem completos. Quando parênteses, chavetas e ponto e vírgula coincidem, javac não escreve linha própria. Depois execute java Desk — não java Desk.java, e não java Jar. Tire o final .java do comando de execução. Arranque a classe que tem main. Os mesmos comandos funcionam no Windows e no macOS.
O programa deve imprimir uma linha e parar: 4. Não deve pedir que você digite. Se o terminal esperar entrada do teclado, uma chamada nextLine de um exercício antigo ainda está num ficheiro. Apague essa chamada e mantenha new Jar(3), j.bump(), e a impressão em Desk, com bump em Jar.
Percorra a execução uma vez. A Java começa em Desk.main. A expressão new Jar(3) constrói um jar e guarda 3 em fill. A chamada j.bump() entra em bump nesse mesmo objeto. O corpo escreve fill = fill + 1, por isso fill passa a 4. Depois main imprime j.fill e o ecrã mostra 4.
Se você escrever bump(); sem j. à frente, javac 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 direta de campo

Na página this você guardava um campo dentro do construtor com nomes iguais. Isso ainda funciona. Esta página acrescenta um método que você pode chamar mais tarde, depois de o objeto já existir. Um demo restante Tin t = new Tin(7); com this.size = size; é outra lição. Para esta página mantenha Jar e Desk 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. Imprimir só j com System.out.println(j); não mostra um 4 limpo. Imprima j.fill para ver o número guardado.

Dois bumps num jar

Você pode chamar j.bump(); duas vezes antes de imprimir. Comece com new Jar(3), bump uma vez até 4, bump de novo até 5, depois imprima. Essa verificação cabe num pequeno segundo demo Desk.

Compile e execute de novo: javac Jar.java Desk.java, depois java Desk. O ecrã deve mostrar 5. Cada chamada a bump correu 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 correr duas vezes.
Se o ecrã ainda mostrar 3, as chamadas bump podem faltar ou main ainda pode imprimir antes de as chamar. Se mostrar 7 ou outro número restante, um demo Tin antigo pode ainda estar no ficheiro. Mantenha new Jar(3) e as chamadas bump.

O que isto deixa para static

Esta página chama o método através de um objeto: j.bump(). Uma página posterior — static — mostra métodos e campos que pertencem ao próprio nome da classe sem objeto à frente. Fique aqui com a chamada de instância. Não invente static void bump() nesta página a menos que já o conheça; o objetivo da lição é a chamada no objeto.
Se javac não encontrar Jar ao compilar Desk.java, verifique que Jar.java está na mesma pasta e que a linha da classe é public class Jar. Se o ecrã mostrar 0, o construtor pode estar sem a guarda, ou bump nunca corre — mantenha Jar(int n) { fill = n; } e j.bump(); antes da impressão.
Quando a pasta ainda guarda Tin.java ou Lab.java da página this, deixe-os ou apague-os só se confundirem o seu comando de compilação. Execute java Desk depois de compilar o par Jar e Desk desta lição.

Antes de static

Você pode declarar int fill;, escrever Jar(int n) { fill = n; } e void bump() { fill = fill + 1; }, e a partir de Desk executar Jar j = new Jar(3);, j.bump();, depois imprimir j.fill. Compile ambos os ficheiros e execute java Desk. O ecrã mostra 4. O método de instância correu nesse objeto e mudou o seu campo. A próxima página é static, onde alguns membros pertencem ao nome da classe sem precisar de uma variável de objeto à frente.
Mantenha void no método, não no construtor. Mantenha o objeto antes da chamada: j.bump();. Mantenha a impressão em j.fill. Esses três hábitos são o ponto de controlo desta página antes de avançar.