Доступ
Напишите класс Lid с приватным полем int seal, конструктором Lid(int n), который задаёт seal = n;, и публичным методом int Read(), возвращающим seal. В Pine оставьте Main и соберите один lid командой Lid L = new Lid(9);, затем вызовите L.Read(). Держите оба типа в одном учебном файле, чтобы dotnet run оставался простым. Запустите через dotnet run. Экран должен показать одну строку: 9. Поле остаётся приватным внутри Lid. Публичный метод — путь, по которому Pine получает число. Имя стартового публичного класса оставьте Pine.
Кто видит член
На странице static вы вызывали Cup.Mark() через имя класса. Здесь новые слова — private и public. Поле private видно только внутри своего класса. Другие классы в том же файле — включая Pine — не могут писать L.seal, когда seal приватный. Метод public по-прежнему может выполняться из Pine и возвращать скрытое значение.
Откройте файл Pine. Имя стартового класса остаётся Pine. Эта страница не переименовывает старт. Если в Main у вас всё ещё только остаток Cup.Mark(); со static-демо, удалите его. Удалите любой оставшийся класс Cup. Удалите любой остаток Jar. Удалите строку с ReadLine. В сохраняемом файле нет ожидания ввода.
Вне фигурных скобок Pine — всё ещё в том же файле — напишите public class Lid. Внутри скобок объявите private int seal;. Запишите конструктор Lid(int n) { seal = n; }. Затем напишите public int Read() { return seal; }. На этой странице в Lid нет Main. Сохраните файл перед запуском.
Полю нужен private, чтобы Pine не трогал seal по имени. Методу нужен public, чтобы Pine мог вызвать Read. Тип возврата — int, потому что Read отдаёт сохранённое число вызывающему. Держите return seal; внутри тела метода.
using System;
public class Lid
{
private int seal;
Lid(int n)
{
seal = n;
}
public int Read()
{
return seal;
}
}
Pine собирает lid и вызывает Read
Pine сохраняет public static void Main(). Внутри Main напишите две строки по порядку: Lid L = new Lid(9);, затем Console.WriteLine(L.Read());. Конструктор кладёт 9 в приватное поле. Вызов L.Read() возвращает это значение. Вывод показывает его. На этой странице вы не пишете Cup.Mark(); — это был урок static.
using System;
public class Pine
{
public static void Main()
{
Lid L = new Lid(9);
Console.WriteLine(L.Read());
}
}
public class Lid
{
private int seal;
Lid(int n)
{
seal = n;
}
public int Read()
{
return seal;
}
}
Прочитайте сохранённый файл сверху. using System; готовит короткие имена. public class Pine — старт. public static void Main() — точка входа. Выражение new Lid(9) создаёт lid и кладёт 9 в seal. Вызов L.Read() входит в публичный метод этого объекта. Тело возвращает seal, значит значение 9 возвращается в Main. Затем Main пишет его, и экран показывает 9.
Запустите через dotnet run. Программа пишет одну строку и останавливается. Она не ждёт вашего ввода. Если dotnet run ждёт, в файле ещё есть ReadLine — удалите эту строку и оставьте в Pine new Lid(9) и Console.WriteLine(L.Read());, а в Lid — private int seal и public int Read(). Экран покажет 9. Если экран показывает 2, возможно, всё ещё крутится остаток демо Cup tally. Если сборка падает на L.seal, вы попытались читать приватное поле из Main — переходите на L.Read().
Если вы пишете Console.WriteLine(L.seal);, пока seal — private, сборка отказывается. Этот отказ и есть урок. Держите публичную дверь: L.Read(). Если оставить seal без private, доступ по умолчанию в этой простой форме может всё ещё компилироваться из Pine так, как эта страница не хочет учить — намеренно поставьте private на поле.
Сравнение со static Cup и с простыми публичными полями
На static-странице к Cup.tally вы доходили через имя класса после работы со static. Эта страница прячет seal от Pine и открывает только Read. Остаток Cup.Mark(); Cup.Mark(); Console.WriteLine(Cup.tally); — другой урок. Для этой страницы держите Lid, Pine и L.Read().
Можно было сделать каждое поле публичным и писать L.seal из Main. Этот урок выбирает private, чтобы объект владел хранением, а Pine спрашивал через метод. Одна строка Console.WriteLine(L); не даёт чистую 9. Пишите Console.WriteLine(L.Read());, чтобы увидеть возвращённое число.
Два lid с отдельными приватными seal
Каждый new Lid(...) получает свой приватный seal. Можно написать Lid a = new Lid(3); и Lid b = new Lid(8);, затем вызвать a.Read() и b.Read(). Ключевое слово private не делит один seal между объектами. Оно лишь запрещает другим классам называть поле.
using System;
public class Pine
{
public static void Main()
{
Lid a = new Lid(3);
Lid b = new Lid(8);
Console.WriteLine(a.Read());
Console.WriteLine(b.Read());
}
}
public class Lid
{
private int seal;
Lid(int n)
{
seal = n;
}
public int Read()
{
return seal;
}
}
Снова запустите dotnet run. Экран должен показать 3 на одной строке и 8 на следующей. Каждый Read вернул приватное поле своего объекта. Если обе строки совпадают, проверьте, что вы сделали два вызова new Lid(...) с разными аргументами. Если экран всё ещё показывает одну 9, вы, возможно, на демо с одним lid — для первой контрольной точки этого достаточно; для второй проверки используйте файл с двумя lid.
Если сборка ругается на Read, убедитесь, что в заголовке метода есть public и int. Если Main всё ещё вызывает Cup.Mark(), удалите static-остаток, чтобы урок access показывал числа lid, а не tally.
Что эта страница оставляет для namespaces
Эта страница использует private и public, чтобы один класс мог скрыть поле и всё же отдать значение через метод. Следующая страница — namespaces — группирует типы под именем, чтобы крупные программы оставались упорядоченными. Здесь оставайтесь на access. Не выдумывайте обёртку namespace на этой странице, если вы её ещё не знаете; цель урока — private на поле и public на Read.
Не вкладывайте Lid внутрь скобок Pine. На этой странице два класса сидят рядом в файле. Если сборка не находит Lid при компиляции Pine, проверьте, что public class Lid в том же файле. Если экран показывает 0, конструктор мог не сохранить значение — оставьте Lid(int n) { seal = n; } и вызывайте Read после new.
Вы можете объявить private int seal;, написать Lid(int n) { seal = n; } и public int Read() { return seal; }, а из Pine.Main выполнить Lid L = new Lid(9);, затем вызвать L.Read(). Запустите через dotnet run. Экран покажет 9. Приватное поле осталось внутри Lid. Публичный метод передал число в Pine. Думайте о private как о закрытом ящике, а о Read — как о разрешённом способе заглянуть внутрь. Pine остаётся дверью, которую вы открываете через dotnet run. Следующая страница — namespaces, где типы сидят под именем группы, чтобы большие файлы оставались ясными.
Держите private на поле. Держите public на Read. Держите вызов как L.Read(), а не L.seal. Эти три привычки — контрольная точка страницы перед переходом дальше. Уберите остатки Cup.Mark() из Main, чтобы экран случайно не показал tally.
🧠 Проверьте Свои Знания
Проверьте Свои Знания
Бросьте себе вызов с помощью этой интерактивной викторины и узнайте, насколько хорошо вы понимаете тему
📝 Инструкции
- Внимательно прочитайте каждый вопрос
- Выберите лучший ответ на каждый вопрос
- Вы можете пересдавать тест столько раз, сколько захотите
- Ваш прогресс будет показан вверху