Объекты
Напишите класс с именем Chip и методом beep, который пишет ok. На этой странице метод не static. В Pine оставьте Main и постройте один chip через Chip c = new Chip();, затем вызовите c.beep();. Держите оба типа в одном учебном файле, чтобы dotnet run оставался простым. Запустите через dotnet run. На экране должна появиться одна строка: ok. Слово new строит один объект из класса. Переменная c держит этот объект. Вы вызываете beep на c, а не на голом имени класса. Именно этот построенный объект — и вызов, который им пользуется — тема страницы. Публичный стартовый класс оставьте с именем Pine.
Один объект из класса
Класс по-прежнему именованный тип. Объект — одно значение, построенное из этого типа. Строка new Chip() просит C# построить это значение. Вы сохраняете его в переменной типа Chip, затем через эту переменную доходите до методов, которые принадлежат каждому объекту.
Откройте файл Pine. Имя стартового класса остаётся Pine. Эта страница стартер не переименовывает. Удалите остаток Badge.show();, если именно такой static-вызов всё ещё занимает весь Main. Удалите любой остаток рекурсии down. Удалите любую строку ReadLine. В файле, который вы оставляете, нет ожидания ввода.
Вне фигурных скобок Pine — но всё ещё в том же файле — напишите public class Chip. Внутри Chip напишите void beep() — на этом заголовке слова static нет. Тело — одна строка записи: Console.WriteLine("ok");. Оставьте void. Метод не возвращает число. В Chip на этой странице нет Main. Сохраните файл перед запуском.
Первая программа в рамке показывает только Chip, чтобы тип читался чисто. Позже в рамках — оставляемые формы, где Pine строит один chip, затем два.
using System;
public class Chip
{
void beep()
{
Console.WriteLine("ok");
}
}
Pine строит chip, затем вызывает beep
У Pine остаётся public static void Main(). Внутри Main напишите две строки: сначала Chip c = new Chip();, затем c.beep();. Первая строка объявляет переменную c типа Chip и заполняет её новым объектом. Вторая вызывает beep на этом объекте. Точка стоит после имени переменной, а не после имени класса в одиночку. На этой странице вы не пишете Badge.show();. Тот static-вызов был на уроке про классы.
using System;
public class Pine
{
public static void Main()
{
Chip c = new Chip();
c.beep();
}
}
public class Chip
{
void beep()
{
Console.WriteLine("ok");
}
}
Прочитайте оставляемый файл сверху. using System; готовит короткие имена. public class Pine — стартер. public static void Main() — место, где среда выполнения начинает работу. Выражение new Chip() строит один объект. Этот объект сохраняется в c. Вызов c.beep() входит в beep для этого объекта. Метод пишет ok и возвращается. Затем Pine заканчивается. Слово на экране пришло из метода объекта — после того, как new создал объект.
Запустите через dotnet run. Программа пишет одну строку и останавливается. Она не ждёт, пока вы что-то наберёте. Если dotnet run ждёт, в файле всё ещё есть ReadLine. Удалите эту строку и оставьте в Pine Chip c = new Chip(); плюс c.beep();, а beep — в Chip. Экран показывает ok. Если экран показывает ready, всё ещё выполняется остаточный вызов Badge.show();. Если экран показывает буквы Chip, в строке записи стоят кавычки: Console.WriteLine("Chip");. Не переустанавливайте .NET SDK из‑за экрана с неверной строкой.
Пройдите запуск ещё раз по порядку. C# начинает с Pine.Main. Первый оператор строит один объект через new Chip() и кладёт его в c. Второй вызывает c.beep(). Внутри beep WriteLine пишет ok. Затем beep заканчивается, в Main ничего не осталось, и программа завершается. На этой странице вы не клали Console.WriteLine("ok"); внутрь Pine. Вы положили его под Chip и запросили через переменную объекта.
Думайте о классе как о чертеже в файле, а об объекте — как об одной собранной детали в памяти для этого запуска. Каждый new Chip() собирает ещё одну деталь. Переменная называет деталь, чтобы следующие строки могли до неё дотянуться. Без этого имени у собранной детали на этой странице нет ручки для beep.
Почему вызов идёт через c, а не через Chip в одиночку
На странице про классы static-метод можно было вызвать как Badge.show() по имени типа. Здесь у beep нет слова static. C# сначала ждёт объект. Написание Chip.beep(); без объекта не совпадает с начальной формой этой страницы. Постройте через new, сохраните результат в переменной, затем вызывайте через эту переменную.
Если написать только new Chip(); и никуда не сохранить, объект всё равно построен, но имени для вызова beep не осталось. На этой странице держите переменную: Chip c = new Chip(); затем c.beep();. Переменная — способ дотянуться до объекта после того, как new закончил работу.
Остаточный static-демо может запутать Main. Файл, который всё ещё вызывает Badge.show();, — это форма предыдущего урока. Для этой страницы держите Chip и Pine и строку new. Здесь Badge не нужен.
Два объекта, два beep
Из одного и того же класса можно построить больше одного объекта. Каждый new Chip() делает отдельный объект. Каждый объект может выполнить свой beep. Текст класса общий; объекты — не одно и то же значение.
using System;
public class Pine
{
public static void Main()
{
Chip a = new Chip();
Chip b = new Chip();
a.beep();
b.beep();
}
}
public class Chip
{
void beep()
{
Console.WriteLine("ok");
}
}
Запустите снова через dotnet run. На экране должны появиться две строки: ok, затем ok. Первая строка пришла от a. Вторая — от b. Оба вызова использовали один и тот же текст метода beep в Chip, но каждый вызов шёл на другой объект, построенный через new.
Если экран показывает только один ok, проверьте, есть ли оба вызова и построены ли обе переменные через new. Написание Chip b = a; не строит второй объект; оно заставляет b ссылаться на тот же объект, что и a. Эта идея ждёт более поздних страниц. На этой странице, когда нужны два объекта, пишите два выражения new Chip().
Можете переименовать переменную с c на unit, если хотите: Chip unit = new Chip(); затем unit.beep();. Экран остаётся ok, пока тело метода всё ещё пишет это слово. Имя переменной — ваше; имя типа Chip и выражение new Chip() должны по-прежнему совпадать.
Что эта страница оставляет для полей
Эта страница ещё не хранит число или слово внутри chip. Поля — имена, которые держат данные на каждом объекте — следующая страница. Здесь объект существует после new, а метод экземпляра beep только пишет. Этого достаточно, чтобы увидеть разделение: класс как тип и один объект как построенное значение.
Не вкладывайте Chip внутрь фигурных скобок Pine. На этой странице два класса в файле — соседи. Методы Chip сидят внутри Chip. Main сидит внутри Pine. Можете сменить написанное слово внутри beep на ping и запустить снова. Экран должен следовать строке, которую вы положили в Chip. У Pine остаётся та же форма new и вызова.
Если сборка не находит Chip при компиляции Pine, проверьте, что public class Chip лежит в том же файле и что строка класса действительно говорит Chip. Если запуск ничего не пишет, подтвердите, что Main всё ещё вызывает c.beep(); после строки new и что в beep по-прежнему есть WriteLine.
Вы можете написать Chip с void beep(), построить один объект через Chip c = new Chip(); и вызвать c.beep(); из Pine.Main. Запустите через dotnet run. Экран показывает ok. Второй new Chip() строит другой объект, который может beep сам по себе. Думайте о Chip как о чертеже, а о каждом new Chip() — как об одной собранной детали, которой можно дать имя. Pine остаётся дверью, которую вы открываете через dotnet run. Следующая страница — поля: там каждый объект начинает держать свои собственные сохранённые данные.
🧠 Проверьте Свои Знания
Проверьте Свои Знания
Бросьте себе вызов с помощью этой интерактивной викторины и узнайте, насколько хорошо вы понимаете тему
📝 Инструкции
- Внимательно прочитайте каждый вопрос
- Выберите лучший ответ на каждый вопрос
- Вы можете пересдавать тест столько раз, сколько захотите
- Ваш прогресс будет показан вверху