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

На верхнем изображении мы видим систему передач, которая работает вместе и составляет единое целое, в данном случае целая машина. Если какая-либо из частей перестанет работать, скорее всего, машина также перестанет работать или будет вести себя неожиданно.

Вкратце объектно-ориентированное программирование выражается в объектно-ориентированном поведении, обеспечивающем всю работу.

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

Итак, если класс - это форма, мы можем сказать, что объект является производным от класса (от формы). В программировании мы говорим, что объект, производный от класса, называется Экземпляр.

Мы собираемся создать нашу машину на языке Ruby, применяя концепцию объектно-ориентированного программирования.

Первое, что мы сделаем, это подумаем: Что нам нужно для создания нашей машины? Мы могли бы начать с создания класса под названием Machine, а затем продолжить. В нашем текстовом редакторе создадим новый файл с именем Machine.rb и установим наш класс Machine (пресс-форма):

Теперь у нас есть шаблон или форма для создания машины.

Внимание! При именовании класса мы начинаем его с заглавной буквы, и если наш класс состоит из более чем одного слова, мы будем использовать CamelCase, то есть , каждое слово будет присоединено к предыдущему, а его первая буква будет заглавной. Уточнив это, можно продолжить.

Бесполезно иметь наш класс Machine (пресс-форма), если мы не используем его для создания объекта (экземпляра). В Ruby синтаксис для создания нового объекта: Machine.new

Мы также можем создать переменную с именем newMachine и сохранить этот новый объект в памяти, чтобы иметь возможность впоследствии взаимодействовать или устанавливать связь с этим объектом: newMachine = Machine.new

Наша переменная newMachine содержит наш новый объект (экземпляр), производный от класса Machine.

У всех объектов есть специальный метод под названием class, который возвращает класс, от которого этот объект является производным. Мы можем применить это к нашему упражнению. Чтобы узнать, от какого класса происходит наш объект newMachine, мы можем вывести в консоли newMachine.class и увидеть, что результатом является Machine, что означает, что класс Machine был шаблоном, с помощью которого мы создали наш новый объект newMachine.

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

Методы

Существует несколько определений того, что такое метод, в зависимости от автора или источника, в котором мы видим его определение, некоторые определения могут происходить друг от друга в некоторых вещах, но суть одна и та же. Метод можно определить как:

  • Подпрограмма
  • Подпрограмма
  • Процесс
  • Функция
  • Рутина
  • Метод
  • Под-алгоритм

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

Мы можем думать, например, что все глаголы в нашем языке являются действиями и, следовательно, подпрограммами, например:

  • Есть
  • Смех
  • Спать
  • Работа
  • Плакать
  • Учиться
  • Чувствовать
  • Так далее…

Глаголы - это действия, потому что каждый из них представляет отдельную задачу, поэтому действия человека можно рассматривать как вспомогательные алгоритмы.

Я надеюсь, что эта иллюстрация поможет вам понять эти концепции.

Методы определены внутри нашего класса (пресс-формы), поскольку они принадлежат ему, придают ему идентичность и отличает его от других классов. В Ruby методы определяются инициалами def, за которыми следует имя метода, например:

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

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

Машина не может запуститься без двигателя. Двигатель будет отвечать за подачу энергии на различные шестерни машины. В нашем текстовом редакторе создадим новый файл с именем Engine.rb, чтобы определить класс Engine:

А поскольку мы говорим о шестеренках, давайте теперь создадим класс Gear. В нашем текстовом редакторе мы создаем файл Gear.rb для определения класса Gear:

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

Созданный нами класс Gear (пресс-форма) будет отвечать за создание шестерен указанного размера, поскольку не все шестерни имеют одинаковый размер. Для этого нам нужно будет использовать то, что мы называем в программировании: Конструктор.

Конструктор и атрибуты

Атрибут: это характеристика объекта, такая как цвет, размер, форма и т. д. Атрибуты хранятся в памяти с помощью переменных, которые называются переменными экземпляра .

Конструктор: метод, подпрограмма, которая обычно используется для инициализации атрибутов объекта.

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

В Ruby конструкторы определяются словом инициализировать. Чтобы применить эту концепцию, вернемся к примеру с нашей машиной, и в классе Gear мы собираемся добавить новый метод конструктора:

Когда мы создаем новый экземпляр класса, автоматически вызывается метод инициализации этого класса. В нашем примере метод initialize содержит переменную с именем @size, которая сохраняет размер каждой шестеренки при создании экземпляра Gear class, и переменная с именем: power, которая представляет мощность, которую должен перемещать объект шестерни. Первоначально она будет false, потому что начальное состояние машины будет выключено.

Пришло время использовать конструктор для класса Machine, поскольку мы не хотим, чтобы все шестерни нашей машины были одного размера. Мы будем использовать следующее изображение, чтобы определить размеры шестерен, которые будут у машины:

Переходим к классу Machine, используем require_relative для вызова класса Gear и создаем метод initialize. так что при создании машины она включает в себя каждую из шестерен, каждая из которых имеет соответствующий размер для работы. Помните, что каждая шестерня будет иметь значение мощности false, поскольку мы установили это в методе initialize класса Gear:

Важно: при создании каждой шестеренки внутри класса Machine вызывается метод initialize класса Gear.

Теперь мы собираемся создать метод конструктора для нашего класса Engine, который будет отображать сообщение «Новый движок» в консоли только при создании нового движка:

Теперь перейдем к классу Machine, мы используем require_relative для вызова класса Engine и создаем движок внутри его конструктора, чтобы в конце у нас были шестеренки и двигатель готов в нашей машине:

Пришло время протестировать нашу базовую машину, которая содержит двигатель и 4 передачи. В консоли пишем ruby ​​Machine.rb и видим такое сообщение:

Таким образом, мы проверяем, как была создана новая машина, благодаря методам конструктора каждого из классов.

Теперь пора создать процесс включения машины. Этот процесс будет выполняться путем проверки, то есть только пользователи, которые предоставят пароль администратора, смогут включить машину. Пришло время поговорить о частных методах.

Частные методы

Мы узнали, что методы - это подалгоритмы общего алгоритма и что они выполняют определенную функцию. Важно помнить, что до сих пор то, как мы определяли методы в предыдущих примерах, было общедоступным, почему? потому что все те объекты, которые являются производными от определенного класса, могут получить доступ к методам этого класса вне его. То есть вернемся к нашему примеру в классе Machine:

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

Однако в программировании не все методы должны быть всегда общедоступными, в наших приложениях есть процедуры, которые удобнее сохранить как частные.

Мы собираемся применить концепцию частного метода, чтобы движок, который у нас есть на нашей машине, запускался только при вводе секретного пароля администратора, и как только движок запускается, машина включается. Частным методом будет тот, который проверяет пароль, предоставленный пользователем:

Мы создали метод под названием turnOn, который запрашивает у пользователя секретный пароль и сохраняет его в переменной. После получения пароля будет вызван частный метод validate, который получит переменную в качестве параметра для проверки правильности пароля.

Если пароль правильный, вызывается метод двигателя turnOn, этого метода еще нет, давайте создадим его:

Когда мы вызываем метод turnOn, каждое из шестеренок принимается как параметр, и его значение power изменяется на true, то есть двигатель дает им силу двигаться.

При работе с приватными методами мы всегда должны учитывать следующее:

  • Частные методы видны только внутри того класса, в котором они находятся.
  • В частных методах используется ключевое слово private.
  • Нам не нужно указывать слово частный для каждого из методов, которые мы хотим сделать частными, просто введите слово частный один раз, и все методы, которые находятся под это слово будет частным.

В настоящий момент класс Engine не имеет доступа к атрибуту power класса Gear. Пришло время поговорить о чтении и письме.

Чтение и письмо

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

В программировании слово get используется для обозначения чтения атрибута, а слово set используется для обозначения записи или изменения атрибута.

В Ruby методы set и get создаются в соответствии со следующим стандартом:

  • Метод, созданный для чтения атрибута (get), должен иметь то же имя, что и атрибут, и обычно возвращает значение атрибута.
  • Метод, созданный для записи или изменения атрибута (set), должен вызываться так же, как атрибут, и с оператором = в конце атрибута.

Давайте вернемся к созданию нашей машины, чтобы лучше понять эту концепцию. В нашем классе Gear мы собираемся создать метод чтения под названием power, поскольку мы хотим получить доступ к значению атрибута, хранящемуся в переменной @power , чтобы при запуске двигателя мы могли изменить значение мощности на true. Причина, по которой наш метод называется так же, как атрибут, заключается в том, что он соответствует стандарту 1:

Метод, созданный для чтения атрибута, должен иметь то же имя, что и атрибут, и обычно возвращает значение атрибута.

Следовательно, метод power вернет значение нашей переменной экземпляра @power:

Теперь давайте создадим метод записи:

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

Теперь, когда движок хочет изменить значение мощности, он сможет это сделать, потому что у него уже есть доступ к атрибуту:

Созданный нами метод письма соответствует стандарту 2:

Метод, созданный для записи или изменения атрибута, должен называться так же, как атрибут, и со знаком = в конце атрибута.

Ярлыки в Ruby

Мы многому научились, мы уже знаем, как создавать классы и объекты, производные от них. Мы также знаем, что такое метод и каковы атрибуты объекта. Мы также говорили о методе конструктора (инициализация) и чтении и изменении атрибутов (get и set).

Наша машина уже имеет 4 передачи и двигатель, который запускает машину. Теперь: что, если бы вместо 1 или 2 атрибутов в классе у нас было 10 атрибутов? Нам пришлось бы создать методы чтения (get) и записи (set) для каждого из них, и в конце у нас будет много строк кода, повторяющих один и тот же шаблон чтения и записи снова и снова. Благодаря языку Ruby мы можем упростить этот процесс в одну строку, используя ярлыки.

Существует 3 типа ярлыков, они описаны ниже:

  • attr_accessor: разрешает как чтение, так и изменение атрибута (set и get).
  • attr_writer: разрешает только изменение атрибута (установить).
  • attr_reader: разрешает только чтение атрибута (get).

Мы собираемся применить эту систему быстрого доступа вместо определения чтения (получить) и записи (установить ) для атрибута power, мы будем использовать attr_accessor, чтобы предоставить внешние разрешения на чтение и запись:

Таким образом, наша переменная @power может быть прочитана и изменена извне из класса, в котором она находится. Теперь наш код выглядит более ясным и понятным.

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

Метод control проверяет наличие мощности у всех шестерен. В этом случае отобразится сообщение «Машина включена!», в противном случае отобразится сообщение «ОШИБКА!»

Единственное, что нам осталось протестировать нашу машину, - это вызвать метод turnOn из newMachine (строка 40):

Зайдите в консоль и введите ruby ​​Machine.rb,, и мы увидим, что нас просят ввести пароль. Если мы введем неверный пароль, мы увидим сообщение «ОШИБКА!», но если мы введем правильный пароль (123456), мы увидим сообщение «Машина включена!»

Наконец, важно отметить, что иногда, когда мы хотим, чтобы атрибут имел то же имя, что и метод, в Ruby мы используем слово self.

С помощью self мы указываем, что это метод объекта, а не атрибут, таким образом мы различаем атрибут метода, если они имеют одинаковое имя.

Мы собираемся применить эту концепцию. Возвращаемся к нашей машине. Давайте покажем кредиты производителя машины (нас), для этого в методе инициализации класса Machine мы добавляем переменную кредиты, сохранит результат, который возвращает метод объекта с тем же именем кредиты:

Затем мы определяем метод, который будет отображать кредиты:

Мы можем выполнить наше упражнение с помощью ruby ​​Machine.rb, и мы увидим, что первое, что будет показано, - это кредиты, за которыми следуют компоненты машины и, наконец, инструкция по вводу ключа:

Поздравляем, вы создали машину, применяющую изученные концепции.

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

Большое спасибо и до скорой встречи!