Методы экземпляра

Напишите класс Jar с полем int по имени fill, конструктором Jar(int n), который делает fill = n;, и методом экземпляра void bump(), который выполняет fill = fill + 1;. В Pine оставьте Main и постройте один jar через Jar j = new Jar(3);, вызовите j.bump();, затем напишите j.fill. Держите оба типа в одном учебном файле, чтобы dotnet run оставался простым. Запустите через dotnet run. На экране должна появиться одна строка: 4. Метод выполняется на том одном объекте и меняет его поле. Вызов метода через переменную объекта — вот чему учит эта страница. Публичный стартовый класс оставьте с именем Pine.

Метод, который принадлежит объекту

На более ранних страницах про методы вы вызывали имя из Main без объекта впереди. Здесь метод сидит на классе, но вы добираетесь до него через переменную jar: j.bump(). Этот вызов использует поля того jar, который называет j. Второй jar держал бы свой собственный fill.
Откройте файл Pine. Имя стартового класса остаётся Pine. Эта страница стартер не переименовывает. Удалите остаток Tin t = new Tin(7);, если именно такой вызов со страницы this всё ещё занимает весь Main. Удалите любой остаток класса Tin. Удалите любую строку ReadLine. В файле, который вы оставляете, нет ожидания ввода.
Вне фигурных скобок Pine — но всё ещё в том же файле — напишите public class Jar. Внутри фигурных скобок объявите int fill;. Напишите конструктор Jar(int n) { fill = n; } с разными именами, чтобы этой странице не нужен был this. Затем напишите метод экземпляра: void bump() { fill = fill + 1; }. На этой странице в Jar нет Main. Сохраните файл перед запуском.
Заголовок метода нуждается в void, потому что bump не возвращает значение для записи. У конструктора по-прежнему нет void — держите эту разницу ясной.

Pine строит jar и вызывает bump

У Pine остаётся public static void Main(). Внутри Main напишите три строки по порядку: Jar j = new Jar(3);, затем j.bump();, затем Console.WriteLine(j.fill);. Конструктор сохраняет 3. Вызов j.bump() добавляет единицу. Запись показывает новое значение. На этой странице вы не пишете Tin t = new Tin(7);. То был урок про this.

Прочитайте оставляемый файл сверху. using System; готовит короткие имена. public class Pine — стартер. public static void Main() — место, где среда выполнения начинает работу. Выражение new Jar(3) строит jar и сохраняет 3 в fill. Вызов j.bump() входит в bump на том же объекте. Тело пишет fill = fill + 1, поэтому fill становится 4. Затем Main пишет j.fill, и экран показывает 4.
Запустите через dotnet run. Программа пишет одну строку и останавливается. Она не ждёт, пока вы что-то наберёте. Если dotnet run ждёт, в файле всё ещё есть ReadLine. Удалите эту строку и оставьте в Pine new Jar(3), j.bump() и запись, а в Jar — bump. Экран показывает 4. Если экран показывает 7, всё ещё выполняется остаточное демо Tin. Если экран показывает 3, вызов bump может отсутствовать или идти после записи.
Если написать bump(); без j. впереди, сборка в этой форме Main откажется. Методу экземпляра нужен объект. Если написать Jar.bump(); как будто это статический вызов, то это идея следующего урока — не этой страницы. Держите j.bump();.

Сравнение с this и простым присваиванием поля

На странице this вы сохраняли поле внутри конструктора при совпадающих именах. Это по-прежнему работает. Эта страница добавляет метод, который можно вызвать позже, когда объект уже существует. Остаток Tin t = new Tin(7); с this.size = size; — другой урок. Для этой страницы держите Jar и Pine и j.bump();.
Вы всё ещё могли бы написать j.fill = j.fill + 1; в Main. Этот урок переносит то изменение внутрь bump, чтобы объект нёс действие. Написание только Console.WriteLine(j); не показывает чистую 4. Напишите Console.WriteLine(j.fill);, чтобы увидеть сохранённое число.

Два bump на одном jar

Вы можете вызвать j.bump(); дважды перед записью. Начните с new Jar(3), один bump до 4, ещё один до 5, затем запишите. Эта проверка умещается в небольшое второе демо Pine.

Запустите снова через dotnet run. Экран должен показать 5. Каждый вызов bump шёл на том же объекте и добавлял ещё единицу. Написание Jar k = j; не строит второй объект — используйте два вызова new Jar(...), когда нужны два отдельных fill. Для этой страницы двух bump на одном jar достаточно, чтобы увидеть метод дважды.
Если экран всё ещё показывает 3, вызовы bump могут отсутствовать или Main всё ещё пишет до них. Если показывает 7 или другое остаточное число, в файле может оставаться старое демо Tin. Держите new Jar(3) и вызовы bump.

Что эта страница оставляет для static

Эта страница вызывает метод через объект: j.bump(). Более поздняя страница — static — показывает методы и поля, которые принадлежат самому имени класса без объекта впереди. Здесь оставайтесь с вызовом экземпляра. Не изобретайте static void bump() на этой странице, если уже не знаете его; цель урока — вызов на объекте.
Не вкладывайте Jar внутрь фигурных скобок Pine. На этой странице два класса сидят как соседи в файле. Если сборка не находит Jar при компиляции Pine, проверьте, что public class Jar лежит в том же файле. Если экран показывает 0, у конструктора может не быть сохранения, или bump никогда не выполняется — держите Jar(int n) { fill = n; } и j.bump(); перед записью.

Вы можете объявить int fill;, написать Jar(int n) { fill = n; } и void bump() { fill = fill + 1; }, и из Pine.Main выполнить Jar j = new Jar(3);, j.bump();, затем написать j.fill. Запустите через dotnet run. Экран показывает 4. Метод экземпляра выполнился на том объекте и изменил его поле. Думайте о bump как о действии, которое jar может сделать после того, как существует. Pine остаётся дверью, которую вы открываете через dotnet run. Следующая страница — static, где некоторые члены принадлежат имени класса без переменной объекта впереди.
Держите void на методе, а не на конструкторе. Держите объект перед вызовом: j.bump();. Держите запись на j.fill. Эти три привычки — контрольная точка этой страницы перед тем, как идти дальше.