Что такое класс в программировании с
Перейти к содержимому

Что такое класс в программировании с

  • автор:

Объектно-ориентированное программирование

Кроме использования встроенных типов, таких как int, double и т.д., мы можем определять свои собственные типы или классы . Класс представляет составной тип, который может использовать другие типы.

Класс предназначен для описания некоторого типа объектов. То есть по сути класс является планом объекта. А объект представляет конкретное воплощение класса, его реализацию. Можно еще провести следующую аналогию. У нас у всех есть некоторое представление о человеке, у которого есть имя, возраст, какие-то другие характеристики. То есть некоторый шаблон — этот шаблон можно назвать классом. Конкретное воплощение этого шаблона может отличаться, например, одни люди имеют одно имя, другие — другое имя. И реально существующий человек будет представлять объект или экземпляр этого класса.

Для определения класса применяется ключевое слово class , после которого идет имя класса:

class имя_класса < // компоненты класса >;

После названия класса в фигурных скобках располагаются компоненты класса. Причем после закрывающей фигурной скобки идет точка с запятой.

Например, определим простейший класс:

class Person < >; int main()

В данном случае класс называется Person. Как правило, названия классов начинаются с большой буквы. Допустим, данные класс представляет человека. Данный класс пуст, не содержит никаких компонентов, тем не менее он уже представляет новый тип. И после определения класса мы можем определять его переменные или константы:

class Person < >; int main()

Но данный класс мало что делает. Класс может определять переменные и константы для хранения состояния объекта и функции для определения поведения объекта. Поэтому добавим в класс Person некоторое состояние и поведение:

#include class Person < public: std::string name; unsigned age; void print() < std::cout >; int main() < Person person; // устанавливаем значения полей класса person.name = "Tom"; person.age = 38; // вызываем функцию класса person.print(); >

Теперь класс Person имеет две переменных name и age, которые предназначены для хранения имени и возраста человека соответственно. Переменные класса еще называют полями класса. Также класс определяет функцию print, которая выводит значения переменных класса на консоль. Также стоит обратить внимание на модификатор доступа public: , который указывает, что идущие после него переменные и функции будут доступны извне, из внешнего кода.

Затем в функции main создается один объект класса Person. Через точку мы можем обратиться к его переменным и функциям.

объект.компонент

Например, мы можем установить значения полей класса

person.name = "Tom"; person.age = 38;

Ну и также мы можем вызывать функции у объекта:

person.print();

Консольный вывод данной программы:

Name: Tom Age: 38

Подобным образом можно получать значения переменных объектов

#include class Person < public: std::string name; unsigned age; void print() < std::cout >; int main() < Person person; // устанавливаем значения полей класса person.name = "Bob"; person.age = 42; // получаем значения полей std::string username = person.name; unsigned userage = person.age; // выводим полученные данные на консоль std::cout

Также можно поля класса, как и обычные переменные, инициализировать некоторыми начальными значениями:

#include class Person < public: std::string name; unsigned age; void print() < std::cout >; int main() < Person person; person.print(); // Name: Undefined Age: 18 >

Указатели на объекты классов

На объекты классов, как и на объекты других типов, можно определять указатели. Затем через указатель можно обращаться к членам класса — переменным и методам. Однако если при обращении через обычную переменную используется символ точка, то для обращения к членам класса через указатель применяется стрелка (->):

#include class Person < public: std::string name; unsigned age; void print() < std::cout >; int main() < Person person; Person *ptr = &person; // обращаемся к полям и функции объекта через указатель ptr->name = «Tom»; ptr->age = 22; ptr->print(); // обращаемся к полям объекта std::cout

Изменения по указателю ptr в данном случае приведут к изменениям объекта person.

Что такое класс в программировании с

Класс — это тип, создаваемый пользователем. Классы являются основным строительным материалом программ, написанных на языке C#. Если в C++ классы используют только в случае необходимости (их можно и вообще не применять!), то в C# всё построено на классах . Даже простейшая программа типа «Здравствуй, мир!» содержит в себе один класс. Обычно же программы на C# состоят из большого количества пользовательских классов.

Каждый класс определяет какую-нибудь сущность. При проектировании программы необходимо представить решаемую задачу в виде совокупности неких объектов, каждый из которых должен обладать необходимыми характеристиками. Совершено очевидно, что необходимо реализовать классы, в которые заложены эти возможности, а затем создавать и использовать в тексте программы объекты этих классов.

Понятие класса является основой концепции объектно-ориентированного программирования (ООП) .

ООП базируется на т рёх основных принципах : инкапсуляция, наследование и полиморфизм.

Инкапсуляция — это объединение под одним общим именем в виде класса данных (их часто называют полями) и методов по обработки этих данных. Вне класса по-умолчанию все поля и методы просто недоступны. Делается это с целью исключения ошибочного изменения полей «чужими» методами.

Именно благодаря такому искусственному сокрытию данных (и часто — методов) появляется возможность разработки больших программных комплексов (на миллионы строк кода), которые могут быть вполне работоспособны.

Принцип наследования — второй по значимости среди основных идей ООП. Благодаря наследованию мы можем на основе одного класса (класса-предка) спроектировать другой класс (класс-наследник), который унаследует от своего предка всё, что нам потребуется. Естественно, в классе-наследнике появятся какие-то новые свойства (поля, методы), которые расширят возможности класса-наследника. Но при этом нам не требуется заново разрабатывать тот программный код, который был в классе-предке. Понятно, что принцип наследования может существенно сократить сроки разработки новых программ и повысить их надёжность.

Термин полиморфизм переводится как многообразие форм. К элементам полиморфизма можно отнести перегрузку методов, перегрузку операции, использование виртуальных методов.

Принцип полиморфизма позволяет в ряде случаев заметно упростить проектирование программ, повысить её наглядность. Всё это также способствует повышению надёжности программного обеспечения и сокращению сроков его разработки.

Рассмотрев вкратце основные идеи ООП, далее перейдём к более подробному их изучению. И начнём с главного — как создавать и использовать классы.

Структура класса и порядок его использования

Формально любой класс можно описать таким образом:

атрибуты class имя_класса : предки

атрибуты — одно из ключевых слов, определяющих доступность класса (например, public , protected , private ), либо какие-то другие базовые свойства класса ( static — статичный класс, abstract — абстрактный класс, sealed — бесплодный класс);

имя_класса — задаётся по общим правилам (как для любого идентификатора, например, как для имени переменной);

предки — необязательный параметр. Класс, который мы создаём, может быть наследником какого-то другого класса (но только одного!) и наследником любого количества интерфейсов (об интерфейсах речь пойдёт далее);

члены_класса — это данные, инкапсулированные в классе, и методы по их обработке.

Для того, чтобы использовать разработанный класс, необходимо где-то в программе создать объект этого класса и вызвать его метод:

имя_класса переменная = new имя_класса () ;

Здесь с помощью операции new создаётся объект нашего класса. В скобках как после имени класса, так и после названия метода возможны какие-либо параметры (если это определено в классе).

Вызов метода возможен только с использованием операции доступа (операция «точка». Указываем название переменной, имеющей тип данного класса, затем ставим точку и только потом пишем имя метода с возможными фактическими параметрами.

Пример простого класса

Для большей ясности сразу же рассмотрим пример с небольшим классом.

Пример . Создать класс, моделирующий работу с треугольником (задаются три стороны a , b и c и вычисляется площадь треугольника s ).

Возможная реализация программы:

double a, b, c; // стороны треугольника

// метод для ввода данных

Что такое классы в объектно-ориентированном программировании

Глубокое погружение в самую сложную и неинтуитивную область программирования.

В этом цикле статей мы говорим об объектно-ориентированном программировании — передовом и очень распространённом подходе к разработке. Это стоит знать всем, кто серьёзно относится к программированию и хочет зарабатывать в этой области.

Если не читали предыдущую статью, вот краткое содержание:

Кратко: что мы уже знаем из прошлой статьи

  • ООП — это подход к программированию. Такой набор практик и принципов, которыми пользуются хорошие разработчики. Противопоставление этому подходу — традиционное процедурное программирование.
  • В процедурном программировании мы пишем функции, которые выполняют какие-то задачи. И при необходимости вызываем одни функции из других. В программе функции живут отдельно, данные — отдельно.
  • Главная проблема процедурного программирования — сложно писать и поддерживать большие проекты. Любой мало-мальски сложный продукт будет требовать сотен функций, которые будут связаны между собой. Получится «спагетти-код».
  • В ООП функции и данные группируются в объекты. Объекты более-менее независимые и общаются друг с другом по строго определённым правилам.
  • Данные в ООП хранятся внутри объектов и называются свойствами объектов. Например, у объекта user может быть свойство name со значением ‘Иван’.
  • Функции в ООП тоже хранятся внутри объектов и называются методами объектов. Например, у объекта user может быть метод sendEmail(), который отправляет этому юзеру письмо.
  • Можно представить, что в ООП взяли «спагетти-код» с тефтелями и разложили из огромного чана порционно по контейнерам. Теперь в каждом контейнере есть спагетти и тефтели, и каждый программист может работать над своим контейнером-объектом, а не ковыряться в общем чане со спагетти.

Одно из преимуществ ООП — не нужно много раз писать один и тот же код. Можно однажды придумать какую-то красивую штуку и потом заново её использовать буквально одной строкой. Для этого и нужны классы.

Что за классы

Вот одно из формальных определений класса: «Класс — это элемент ПО, описывающий абстрактный тип данных и его частичную или полную реализацию»

Если более по-русски, то класс — это шаблон кода, по которому создаётся какой-то объект. Это как рецепт приготовления блюда или инструкция по сборке мебели: сам по себе класс ничего не делает, но с его помощью можно создать новый объект и уже его использовать в работе.

Если пока непонятно, погружайтесь в пример:

Сила примера

Призовём на помощь силу примеров и поговорим про сотовые телефоны.

Допустим, вы делаете мобильники и хотите выпустить на рынок новую модель. Чтобы люди могли сразу пользоваться вашим устройством и быстро к нему привыкли, у телефона должен быть экран, кнопки включения и громкости, камеры спереди и сзади, разъём для зарядки и слот для сим-карты.

Но одного железа недостаточно — нужно соединить его между собой так, чтобы всё работало без сбоёв. Кроме этого, нужно предусмотреть, что происходит при нажатии на кнопки, что выводится на экран и как пользователь будет управлять этим телефоном.

Следующий этап — описать каждую деталь, из которой состоит телефон, каждую микросхему и плату, и объяснить, как детали работают друг с другом. Последний шаг — написать руководство пользователя, где будет полностью рассказано, что можно делать с телефоном, как запустить звонилку или отправить смс.

Мы только что сделали новый класс для телефона — полный набор нужных знаний, описаний, свойств и инструкций, который описывает нашу модель. Все эти инструкции и описания — это ещё не телефон, но из них этот телефон можно сделать.

В программировании у класса есть наборы данных — в нашем случае это комплектующие для телефона. Ещё есть функции для работы с классами, которые называются методами — это то, как пользователь будет работать с нашим телефоном, что он будет на нём делать и каким образом.

Классы на практике

Все примеры дальше мы будем делать на Python, потому что это стильно, модно и молодёжно. А сам Python — очень объектно-ориентированный язык, почти всё в нём — это объекты. Вот и опробуем.

Допустим, мы пишем интернет-магазин с системой скидок. Нам нужно работать с пользователями — постоянными покупателями. Пользователь у нас будет объектом: у него будет имя, возраст и адрес доставки по умолчанию. Мы заведём класс, который поможет нам инициировать нового покупателя.

class User: """Класс для всех покупателей""" user_count = 0 def __init__(name, age, adress): self.name = name self.age = age self.adress = adress user.user_count += 1 

Здесь сказано: «Вот класс для покупателя. У него есть три свойства: имя, возраст и адрес». Теперь мы можем заводить новых покупателей одной строкой:

# Создаём первого покупателя

# Создаём второго покупателя

Что дальше

В следующем материале мы смоделируем реальную ситуацию: добавим программу лояльности, бонусные баллы и расскажем, как Python с этим справится. Чтобы было интереснее, будем писать код на двух языках сразу — Python и JavaScript.

Программирование — это даже не будущее. Это настоящее
Получите профессии настоящего и будущего в Яндекс Практикуме. Это хорошо.

Программирование — это даже не будущее. Это настоящее Программирование — это даже не будущее. Это настоящее Программирование — это даже не будущее. Это настоящее Программирование — это даже не будущее. Это настоящее

Получите ИТ-профессию

В «Яндекс Практикуме» можно стать разработчиком, тестировщиком, аналитиком и менеджером цифровых продуктов. Первая часть обучения всегда бесплатная, чтобы попробовать и найти то, что вам по душе. Дальше — программы трудоустройства.

Класс (программирование)

Класс в программировании — набор методов и функций. Другие абстрактные типы данных — метаклассы, интерфейсы, структуры, перечисления — характеризуются какими-то своими, другими особенностями. Наряду с понятием «объекта» класс является ключевым понятием в ООП (хотя существуют и бесклассовые объектно-ориентированные языки, например, JavaScript; подробнее смотрите Прототипное программирование). Суть отличия классов от других абстрактных типов данных состоит в том, что при задании типа данных класс определяет одновременно и интерфейс, и реализацию для всех своих экземпляров, а вызов метода-конструктора обязателен. Точный смысл этой фразы будет раскрыт ниже.

На практике объектно-ориентированное программирование сводится к созданию некоторого набора классов, включая интерфейс и реализацию, и последующему их использованию. Графическое представление набора классов и связей между ними называется диаграммой классов. Объектно-ориентированный подход за время своего развития накопил множество рекомендаций (паттернов) по созданию классов и иерархий классов.

Идея классов пришла из работ по базам знаний, имеющих отношение к исследованиям по искусственному интеллекту. Используемые человеком классификации в зоологии, ботанике, химии, деталях машин, несут в себе основную идею, что любую вещь всегда можно представить частным случаем некоторого более общего понятия. Конкретное яблоко — это в целом некоторое яблоко, вообще яблоко, а любое вообще яблоко — фрукт. Именно поэтому примеры классов в учебных пособиях по объектно-ориентированному программированию так часто упоминают яблоки и груши.

Везде далее слова «класс», «объект», «интерфейс» и «структура» будут употребляться в своих специальных значениях, заданных в рамках ООП.

Классы и объекты, понятие экземпляра класса, понятие членов класса

В объектно-ориентированной программе с применением классов каждый объект является «экземпляром» некоторого конкретного класса, и других объектов не предусмотрено. То есть «экземпляр класса» в данном случае означает не «пример некоторого класса» или «отдельно взятый класс», а «объект, типом которого является какой-то класс». При этом в разных языках программирования допускается либо не допускается существование еще каких-то типов данных, экземпляры которых не являются объектами (то есть язык определяет, являются ли объектами такие вещи, как числа, массивы и указатели, или не являются, и, соответственно, есть ли такие классы как «число», «массив» или «указатель», экземплярами которых были бы каждое конкретное число, массив или указатель).

Например, абстрактный тип данных «строка текста» может быть оформлен в виде класса, и тогда все строки текста в программе будут являться объектами — экземплярами класса «строка текста».

При использовании классов все элементы кода программы, такие как переменные, константы, методы, процедуры и функции, могут принадлежать (а во многих языках обязаны принадлежать) тому или иному классу. Сам класс в итоге определяется как список своих членов, а именно полей (свойств) и методов/функций/процедур. В зависимости от языка программирования к этому списку могут добавиться константы, атрибуты и внешние определения.

Как и структуры, классы могут задавать поля — то есть переменные, принадлежащие либо непосредственно самому классу (статические), либо экземплярам класса (обычные). Статические поля существуют в одном экземпляре на всю программу (или, в более сложном варианте, — в одном экземпляре на процесс или на поток/нить). Обычные поля создаются по одной копии для каждого конкретного объекта — экземпляра класса. Например, общее количество строк текста, созданных в программе за время её работы, будет являться статическим полем класса «строка текста». А конкретный массив символов строки будет являться обычным полем экземпляра класса «строка текста», так же как переменная «фамилия», имеющая тип «строка текста», будет являться обычным полем каждого конкретного экземпляра класса «человек».

В ООП при использовании классов весь исполняемый код программы (алгоритмы) будет оформляться в виде так называемых «методов», «функций» или «процедур», что соответствует обычному структурному программированию, однако теперь они могут (а во многих языках обязаны) принадлежать тому или иному классу. Например, по возможности, класс «строка текста» будет содержать все основные методы/функции/процедуры, предназначенные для работы со строкой текста, такие как поиск в строке, вырезание части строки и т. д.

Как и поля, код в виде методов/функций/процедур, принадлежащих классу, может быть отнесен либо к самому классу, либо к экземплярам класса. Метод, принадлежащий классу и соотнесенный с классом (статический метод) может быть вызван сам по себе и имеет доступ к статическим переменным класса. Метод, соотнесенный с экземпляром класса (обычный метод), может быть вызван только у самого объекта, и имеет доступ как к статическим полям класса, так и к обычным полям конкретного объекта (при вызове этот объект передастся скрытым параметром метода). Например, общее количество созданных строк можно узнать из любого места программы, но длину конкретной строки можно узнать только указав, тем или иным образом, длину какой строки будем мерить.

Сам класс не является объектом, однако, в зависимости от языка программирования и платформы, программисту могут быть доступны те или иные объекты, позволяющие получить информацию о классе — название, список членов, объем памяти, занимаемой классом или отдельным экземпляром. Например, может существовать специальный класс «тип данных», экземпляры которого описывают тот или иной конкретный класс, существующий в программе.

Интерфейс и реализация, наследование реализации

В программировании существует понятие программного интерфейса, означающего перечень возможных вычислений, которые может выполнить та или иная часть программы, включая описание того, какие аргументы и в каком порядке требуется передавать на вход алгоритмам из этого перечня, а также что и в каком виде они будут возвращать. Абстрактный тип данных интерфейс придуман для формализованного описания такого перечня. Сами алгоритмы, то есть действительный программный код, который будет выполнять все эти вычисления, интерфейсом не задаётся, программируется отдельно и называется реализацией интерфейса.

Программные интерфейсы, а также классы, могут расширяться путем наследования, которое является одним из важных средств повторного использования готового кода в ООП. Наследованный класс или интерфейс будет содержать в себе всё, что указано для всех его родительских классов (в зависимости от языка программирования и платформы, их может быть от нуля до бесконечности). Например, можно создать свой вариант текстовой строки путем наследования класса «моя строка текста» от уже существующего класса «строка текста», при этом предполагается, что программисту не придется заново переписывать алгоритмы поиска и прочее, так как они автоматически будут унаследованы от готового класса, и любой экземпляр класса «моя строка текста» может быть передан не только в готовые методы родительского класса «строка текста» для проведения нужных вычислений, но и вообще в любой алгоритм, способный работать с объектами типа «строка текста», так как экземпляры обоих классов совместимы по программным интерфейсам.

Класс позволяет задать не только программный интерфейс к самому себе и к своим экземплярам, но и в явном виде написать код, ответственный за вычисления. Если при создании своего нового типа данных наследовать интерфейс, то мы получим возможность передавать экземпляр своего типа данных в любой алгоритм, который умеет работать с этим интерфейсом. Однако нам придется самим написать реализацию интерфейса, то есть те алгоритмы, которыми будет пользоваться интересующий нас алгоритм для проведения вычислений с использованием нашего экземпляра. В то же время, наследуя класс, мы автоматически наследуем готовый код под интерфейс (это не всегда так, родительский класс может требовать реализации каких-то алгоритмов в дочернем классе в обязательном порядке). В этой возможности наследовать готовый код и проявляется то, что в объектно-ориентированной программе тип данных класс определяет одновременно и интерфейс, и реализацию для всех своих экземпляров.

Состояние объекта, понятие областей доступа, конструкторы

Одной из проблем структурного программирования, с которой борется ООП, является проблема поддержания правильного значения переменных программы. Часто разные переменные программы хранят логически связанные значения, и за поддержание этой логической связности несет ответственность программист, то есть автоматически связность не поддерживается. Примером могут служить флажки «уволен» и «ожидает премии по итогам года», когда по правилам отдела кадров человек может быть одновременно не уволенным и не ожидающим премии, не уволенным и ожидающим премии, уволенным и не ожидающим премии, но не может быть одновременно и уволенным, и ожидающим премии. То есть любая часть программы, которая проставляет флажок «уволен», всегда должна снимать флажок «ожидает премии по итогам года».

Хороший способ решить эту проблему — объявить флажок «уволен» недоступным к изменению для всех участков программы, кроме одного специально оговоренного. В этом специально оговоренном участке всё будет написано один раз и правильно, а все остальные должны будут обращаться к этому участку всегда, когда они хотят установить или снять флажок «уволен».

В объектно-ориентированной программе флажок «уволен» будет объявлен приватным членом некоторого класса, а для чтения и изменения его будут написаны соответствующие публичные методы. Правила, определяющие возможность или невозможность напрямую изменять какие-либо переменные, называются правилами задания областей доступа. Слова «приватный» и «публичный» в данном случае являются так называемыми «модификаторами доступа». Они называются модификаторами потому, что в некоторых языках они используются для изменения ранее установленных прав при наследовании класса. Совместно классы и модификаторы доступа задают область доступа, то есть у каждого участка кода, в зависимости от того, какому классу он принадлежит, будет своя область доступа относительно тех или иных элементов (членов) своего класса и других классов, включая переменные, методы, функции, константы и т. д. Существует основное правило: ничто в одном классе не может видеть приватных элементов другого класса. Относительно других, более сложных правил, в различных языках существуют другие модификаторы доступа и правила их взаимодействия с классами.

Почти каждому члену класса можно установить модификатор доступа (за исключением статических конструкторов и некоторых других вещей). В большинстве объектно-ориентированных языков программирования поддерживаются следующие модификаторы доступа:

  • private (закрытый, внутренний член класса) — обращения к члену допускаются только из методов того класса, в котором этот член определён. Любые наследники класса уже не смогут получить доступ к этому члену. Наследование по типу private делает все public и protected члены родительского класса private-членами класса-наследника (С++);
  • protected (защищённый, внутренний член иерархии классов) — обращения к члену допускаются из методов того класса, в котором этот член определён, а также из любых методов его классов-наследников. Наследование по типу protected делает все public-члены родительского класса protected-членами класса-наследника (С++);
  • public (открытый член класса) — обращения к члену допускаются из любого кода. Наследование по типу public не меняет модификаторов родительского класса (С++);

Проблема поддержания правильного состояния переменных актуальна и для самого первого момента выставления начальных значений. Для этого в классах предусмотрены специальные методы/функции, называемые конструкторами. Ни один объект (экземпляр класса) не может быть создан иначе, как путем вызова на исполнение кода конструктора, который вернет вызывающей стороне созданный и правильно заполненный экземпляр класса. Во многих языках программирования тип данных «структура», как и класс, может содержать переменные и методы, но экземпляры структур, оставаясь просто размеченным участком оперативной памяти, могут создаваться в обход конструкторов, что запрещено для экземпляров классов (за исключением специальных исключительных методов обхода всех подобных правил ООП, предусмотренных в некоторых языках и платформах). В этом проявляется отличие классов от других типов данных — вызов конструктора обязателен.

Практический подход

В современных объектно-ориентированных языках программирования (в том числе в php, Java, C++, Oberon, Python, Ruby, Smalltalk, Object Pascal) создание класса сводится к написанию некоторой структуры, содержащей набор полей и методов (среди последних особую роль играют конструкторы, деструкторы, финализаторы). Практически класс может пониматься как некий шаблон, по которому создаются объекты — экземпляры данного класса. Все экземпляры одного класса созданы по одному шаблону, поэтому имеют один и тот же набор полей и методов.

Отношения между классами

  • Наследование (Генерализация) — объекты дочернего класса наследуют все свойства родительского класса.
  • Ассоциация — объекты классов вступают во взаимодействие между собой.
  • Агрегация — объекты одного класса входят в объекты другого.
  • Композиция — объекты одного класса входят в объекты другого и зависят друг от друга по времени жизни.
  • Класс-Метакласс — отношение, при котором экземплярами одного класса являются другие классы.

Виды классов

  • Базовый (родительский) класс
  • Производный класс (наследник, потомок)
  • Абстрактный класс
  • Интерфейс

Область видимости

Область видимости членов класса (то есть область кода, из которой к ним можно обращаться по неквалифицированному имени — без указания имени класса или объекта) не зависит от их области доступа, и всегда совпадает с кодом методов класса.

Область видимости самого класса по-разному определяется в разных языках программирования. В одних языках (таких как Delphi) все классы имеют глобальную видимость (с учётом видимости модуля), в других (таких как Java) область видимости класса связана с содержащей его единицей компиляции (в Java — с пакетом), в третьих (таких как C++ и C#) область видимости класса определяется пространствами имён (namespaces), которые задаются программистом явно и могут совпадать или не совпадать с единицами компиляции.

Классы в языке Object Pascal (среда Delphi)

На языке Delphi класс описывается следующим образом:

TMyClass = class(TObject) private  protected public published end; 
  • TMyClass — имя класса;
  • class — ключевое слово, начинающее определение класса;
  • TObject — класс-предок, если есть наследование;
  • private, protected, public, published — ключевые слова, обозначающие секции областей доступа.

Создается экземпляр (объект) класса так:

MyClass := TMyClass.Create; 

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *