Курс по Ruby+Rails. Часть 2. Объектно-ориентированное программирование

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

Основные свойства Ruby как чистого ОО-языка таковы:

• Любая сущность — объект, исключений не существует.

• Примитивных типов не существует.

• Любая функция — это метод какого-либо объекта. Инфиксные операторы (например, + - / *) — не исключение.

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

• Поведение объектов может программно изменяться в их жизненном цикле.

Объекты

Поговорим об объектах. Мы только что проговорили, что всё в Ruby является объектом. Например, число 42, которое вы видите — объект. Давайте это проверим. Вызовем какой-нибудь метод у этого числа. Допустим, метод class. И получим класс этого объекта:

pry(main)> 42 => 42  pry(main)> 42.class => Integer  pry(main)> Integer.class => Class

Попробуем посмотреть все доступные методы у объекта 42. Среди них увидим математические операторы, которые можем использовать:

pry(main)> 42.methods => [  # ...  :%,  :&,  :*,  :+,  :-,  :/,  # ... ]  pry(main)> 42.method(:+) => #<Method: Integer#+(_)>

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

pry(main)> 2 * 2 => 4 pry(main)> 2.*(2) => 4

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

Классы

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

Давайте создадим класс. Определим имя, опишем конструктор. Конструктор — это метод, который вызывается при создании нового экземпляра класса и выполняет первоначальную настройку состояния объекта. Опишем переменную экземпляра класса и зададим значение этой переменной. Опишем метод этого экземпляра класса. Создадим новый экземпляр класса и вызовем его метод:

class DeepThought   def initialize     @answer = 42   end    def answer_for(question)     sleep 10      puts "The Answer about life, universe and everything, including '#{question}' is #{@answer}"   end end  supercomputer = DeepThought.new supercomputer.answer_for('To be or not to be?')  #> The Answer about life, universe and everything, including 'To be or not to be?' is 42

Прежде, чем продолжить, поговорим о собственном поведении класса. У класса есть методы, константы и переменные самого класса. Их мы можем использовать без создания нового экземпляра класса. Посмотрим на код: на второй строчке вы видите константу класса, на третьей — переменная класса. В конце класса находится конструкция class << self. Методы, которые описаны внутри этого блока, являются методами самого класса:

class DeepThought   ANSWER = 42   @@answer_template = 'Umm...'    attr_reader :answer, :seconds_to_sleep    def initialize(seconds_to_sleep)     @answer = ANSWER     @seconds_to_sleep = seconds_to_sleep   end    def answer_for(question)     sleep(seconds_to_sleep)      puts expand_answer(question)   end    def expand_answer(question)     "#{@@answer_template.gsub(/$q/, question)} #{answer}"   end    class << self     def answer_template=(string)       @@answer_template = string     end   end end

Обратите внимание на метод answer_template. В конце его имени стоит знак =. Он напрямую изменяет переменную класса. Такие методы называются сеттерами. Посмотрите на вызов метода attr_reader, — так создаются геттеры, — методы, возвращающие значения одноименных переменных экземпляра.

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

DeepThought::ANSWER #> 42

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

supercomputer = DeepThought.new(10) #> #<DeepThought:0x00007fece5c12418 @seconds_to_sleep=10>  supercomputer.answer_for('To be or not to be?') #> Umm... 42  DeepThought.answer_template =   "The Answer about life, universe and everything, including $q is" supercomputer.answer_for('To be or not to be?') #> The Answer about life, universe and everything, including $q is 42

Модули

Модули — Это особые объекты в Ruby. Они используются для группировки методов, констант, других классов и модулей. Модули также создают неймспейсы — пространства имён. Модули похожи на классы тем, что у них есть методы, константы, вложенные классы и модули. Но есть и отличие: их нельзя инстанциировать. Невозможно создать экземпляр модуля.

module SupercomputersPlanet   PLANET = "Magrathea"    class DeepThought   # ...   end    def make_deep_thought     puts "Making Deep Thought of #{PLANET}"     DeepThought.new   end end

Посмотрим на примеры: мы можем получить список всех констант. Также можем попробовать создать экземпляр модуля, но в этом месте получим исключение. Можем попробовать прочитать константу, однако её нет в глобальной области видимости, константа описана только внутри модуля. Здесь же мы получим исключение. В конце мы явно указываем, к какому модулю хотим обратиться, и получаем нужное значение:

SupercomputersPlanet.class #> Module  SupercomputersPlanet.constants #> [:PLANET, :DeepThought]  SupercomputersPlanet.new #> NoMethodError: undefined method `new' for SupercomputersPlanet:Module  PLANET #> NameError: uninitialized constant PLANET  SupercomputersPlanet::PLANET #> "Magrathea"

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

DeepThought.new #> NameError: uninitialized constant DeepThought  SupercomputersPlanet::DeepThought.new #> #<SupercomputersPlanet::DeepThought:0x00007fe16bae4490>  SupercomputersPlanet.make_deep_thought #> NoMethodError: undefined method `make_deep_thought' for SupercomputersPlanet:Module

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

module SupercomputersPlanet   PLANET = "Magrathea"    class DeepThought   # ...   end    def self.make_deep_thought     puts "Making Deep Thought of #{PLANET}"     DeepThought.new   end end  SupercomputersPlanet.make_deep_thought #> Making Deep Thought of Magrathea #> #<SupercomputersPlanet::DeepThought:0x00007fdc389159d0>

3 основных принципа объектно-ориентированного программирования: инкапсуляция, наследование, полиморфизм. 

Начнём с инкапсуляции. Инкапсуляция — это свойство объекта прятать своё состояние от внешнего мира. Напрямую с переменными класса или переменными экземпляра мы взаимодействовать не сможем. Для взаимодействия нужны методы. Они позволяют читать и изменять состояние класса. В Ruby существует инструмент, с помощью которого можно управлять доступом к методам. Делается это с помощью ключевых слов private и protected. private делает так, что методы могут вызываться только изнутри экземпляра класса. Попробуем на примере увидеть, как это работает. Создадим экземпляры и попробуем вызвать у них приватные метод. Получим исключения:

class DeepThought   ANSWER = 42    attr_reader :seconds_to_sleep   private :seconds_to_sleep    def initialize(seconds_to_sleep)     @seconds_to_sleep = seconds_to_sleep   end    def answer_for(question)     sleep(seconds_to_sleep)     puts full_answer_text(question)   end    private    def full_answer_text(question)     <<~TXT.gsub(/\n/, ' ')       The Answer about life, universe and everything,       including '#{question}' is #{answer}"     TXT   end    def answer     ANSWER   end end  DeepThought.new(5).answer #> NoMethodError: private method `answer' called ...  DeepThought.new(5).seconds_to_sleep #> NoMethodError: private method `seconds_to_sleep' called ...  DeepThought.new(5).answer_for("Foo?") #> The Answer about life, universe and everything, including 'Foo?' is 42"

Свойство методов protected используется довольно редко, и мы его сейчас рассматривать не будем.

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

Смотрим пример: создадим два класса, где второй будет потомком первого. Создадим экземпляры этого класса и попробуем вызвать оба метода: как метод родительского класса, так и метод самого класса:

class Animal   def breathe     puts "inhale and exhale"   end end  class Cat < Animal   def speak     puts "Meow"   end end  nyan = Cat.new nyan.breathe nyan.speak

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

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

class LifeForm   def breathe     # all lifeforms breathe   end end  class Animal < LifeForm   include AnimalCellsBiochemistry   include AnimalGenetics   include AnimalMetabolism   include AnimalMotion   include AnimalSounds end  class Cat < Animal   # это поведение — DSL из модуля AnimalSounds   animal_sound "Meow" end

Вернёмся к примеру с иерархией классов. У нас есть класс Animal, есть класс Cat, который является его наследником. Есть ещё класс японской кошки — наследник класса Cat:

class Animal   def speak     puts 'The animal sound'   end end  class Cat < Animal   def speak     puts 'The cat speaks:'     super   # super вызывает одноимённый метод родителя   end end  module JapaneseCatSpeak   def speak     puts 'Nyaaaaa!'   end end  class JapaneseCat < Cat end  JapaneseCat.new.speak #> The cat speaks: #  The animal sound

Создадим экземпляр японской кошки и вызовем у неё один единственный метод. Но сейчас кошка мяукает по-английски, а должна по-японски. Давайте это сделаем. Создадим отдельный модуль и «подмешаем» его в нужный класс с помощью ключевого слова include. Теперь наша кошка мяукает правильно:

class JapaneseCat < Cat   include JapaneseCatSpeak    def speak     puts 'The cat speaks:'     super   # теперь родитель для этого метода — модуль JapaneseCatSpeak   end end  JapaneseCat.new.speak #> The cat speaks: #  Nyaaaaa!

Посмотрим на механизм примесей модулей внимательней. Есть некоторый модуль, у в котором определён метод, возвращающий массив. Подмешаем этот модуль в наш класс и попробуем вызвать этот метод на уровне класса. Получаем ошибку:

module CatsCommons   def features     %i[ears legs tail]   end end  class Cat   include CatsCommons end  Cat.features #> NoMethodError: undefined method `features' for Cat:Class  Cat.new.features #> [:ears, :legs, :tail]

Давайте попробуем создать экземпляр класса и вызовем метод на нём. Всё работает корректно. Однако изначально я хотел, чтобы метод вызывался на уровне класса. Исправим это поведение. Для этого используем ключевое слово eхtend:

class Cat   extend CatsCommons end  Cat.features #> [:ears, :legs, :tail]

С его помощью мы подмешиваем содержимое модуля не в экземпляр класса, а в сам класс. 

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

И, наконец, третий принцип объектно-ориентированного программирования  — полиморфизм. Это способность одного и того же кода работать с разными типами данных.

В Ruby тождественны понятие «тип» и «поведение». За счёт динамической природы языка мы можем изменять экземпляр класса непосредственно. На примере у нас есть модуль и класс. Создадим экземпляр класса, опишем в модуле новый метод для него и подмешаем модуль непосредственно в экземпляр. Проверим — всё работает корректно:

module ExplicitCatThings   def get_in_the_way     "I'm on the laptop!"   end end  class Cat   def speak     'Meow!'   end end  cat = Cat.new def cat.jump   'Weeeee!!! Rumble-rumble!' end cat.extend ExplicitCatThings  cat.speak #> "Meow!" cat.jump #> "Weeeee!!! Rumble-rumble!" cat.get_in_the_way #> "I'm on the laptop!"

Такой подход называется «monkey patching» — во время работы программы, после создания экземпляра мы меняем его поведение. Язык позволяет нам такую гибкость, но это считается не особенно хорошей практикой, поэтому старайтесь её избегать. Из-за «monkey patching» бывает сложно анализировать работу программы и отслеживать, где и как изменяются свойства классов и объектов.

Это был обзор основного стиля программирования в Ruby — объектно-ориентированного. Готовим для вас следующую лекцию, всего хорошего!