static

Напишите класс Cup со статическим полем int tally и статическим методом void Mark(), который выполняет tally = tally + 1;. В Pine оставьте Main и вызовите Cup.Mark(); дважды, затем напишите Cup.tally. Держите оба типа в одном учебном файле, чтобы dotnet run оставался простым. Запустите через dotnet run. На экране должна появиться одна строка: 2. Метод выполняется через имя класса, а не через переменную объекта. Одна общая tally на классе — вот чему учит эта страница. Публичный стартовый класс оставьте с именем Pine.

Член, который принадлежит имени класса

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

Pine вызывает Mark по имени класса

У Pine остаётся public static void Main(). Внутри Main напишите три строки по порядку: Cup.Mark();, снова Cup.Mark();, затем Console.WriteLine(Cup.tally);. Каждый вызов добавляет единицу. Запись показывает общий счётчик. На этой странице вы не пишете Jar j = new Jar(3); или j.bump();. Это был урок instance-methods.

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

Сравнение с j.bump и остаточным Jar

На странице instance-methods для j.bump() нужен объект впереди. Это по-прежнему работает, когда вы хотите изменить один jar. Здесь Cup.Mark() требует имя класса впереди. Остаток Jar j = new Jar(3); j.bump(); Console.WriteLine(j.fill); — другой урок. На этой странице держите Cup, Pine и Cup.Mark();.
Позже вы всё ещё можете придумать метод экземпляра. Этот урок держит общий счётчик на классе, чтобы два вызова без new делили одну tally. Написание только Console.WriteLine(Cup); не показывает чистую 2. Напишите Console.WriteLine(Cup.tally);, чтобы увидеть сохранённое число.

Одна tally на все вызовы Mark

На этой странице вам не нужно строить две чашки, чтобы получить две отметки. Первый Cup.Mark(); и второй Cup.Mark(); оба трогают одно и то же статическое поле. В этом смысл static int tally. Если позже добавите объекты, они всё равно делят эту одну tally, пока вы не придумаете другую схему. Для учебного файла двух вызовов по имени класса достаточно.
Если экран всё ещё показывает 1, может быть только один вызов Mark, или запись стоит между вызовами. Держите оба вызова перед Console.WriteLine(Cup.tally);. Если экран показывает 7 или другое число-остаток, в файле всё ещё может быть старое демо Tin или Jar. Держите Cup.Mark(); дважды и запись на Cup.tally.

Ошибки, которые прячут статический вызов

Если убрать static с Mark, метод станет методом экземпляра. Тогда Cup.Mark(); из Main ломает сборку, и страница перестаёт учить вызову по имени класса. Верните static и на поле, и на метод. Если вызывать только j.bump();, потому что файл Jar всё ещё открыт, урок тоже прячется — удалите это демо из Main, когда тренируете Cup.
Ловушка — писать только Cup.tally = Cup.tally + 1; в Main и не писать Mark. После двух присваиваний может напечататься 2, но вы пропустите форму статического метода, которую эта страница хочет, чтобы вы набрали. Предпочитайте две строки Cup.Mark();, чтобы тело метода владело сложением. Если IntelliSense предлагает вызов экземпляра после new Cup(), для этого упражнения игнорируйте его и оставайтесь с Cup.Mark();.

Что остаётся для access

На этой странице вы добираетесь до членов через имя класса: Cup.Mark() и Cup.tally. Позже страница access показывает слова вроде public и private, которые решают, кто видит член. Здесь оставайтесь со static. Не придумывайте ключевые слова доступа на каждой строке, если вы их уже не используете; цель урока — вызов по имени класса и общее поле.
Не вкладывайте Cup внутрь фигурных скобок Pine. На этой странице два класса сидят как соседи в файле. Если сборка не находит Cup при компиляции Pine, проверьте, что public class Cup в том же файле. Если экран показывает 0, Mark может ни разу не выполниться — держите обе строки Cup.Mark(); перед записью. Если сборка жалуется, что Mark нужен объект, проверьте, что в заголовке метода всё ещё есть static.

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