Что такое сеттер и геттер
Урок №115. Инкапсуляция, Геттеры и Сеттеры
Обновл. 13 Сен 2021 |
На предыдущем уроке мы узнали, что переменные-члены класса по умолчанию являются закрытыми. Новички, которые изучают объектно-ориентированное программирование, очень часто не понимают, почему всё обстоит именно так.
Зачем делать переменные-члены класса закрытыми?
В качестве ответа, воспользуемся аналогией. В современной жизни мы имеем доступ ко многим электронным устройствам. К телевизору есть пульт дистанционного управления, с помощью которого можно включать/выключать телевизор. Управление автомобилем позволяет в разы быстрее передвигаться между двумя точками. С помощью фотоаппарата можно делать снимки.
Все эти 3 вещи используют общий шаблон: они предоставляют вам простой интерфейс (кнопка, руль и т.д.) для выполнения определенного действия. Однако, то, как эти устройства фактически работают, скрыто от вас (как от пользователей). Для нажатия кнопки на пульте дистанционного управления вам не нужно знать, что выполняется «под капотом» пульта для взаимодействия с телевизором. Когда вы нажимаете на педаль газа в своем автомобиле, вам не нужно знать о том, как двигатель внутреннего сгорания приводит в движение колеса. Когда вы делаете снимок, вам не нужно знать, как датчики собирают свет в пиксельное изображение.
Такое разделение интерфейса и реализации чрезвычайно полезно, поскольку оно позволяет использовать объекты, без необходимости понимания их реализации. Это значительно снижает сложность использования этих устройств и значительно увеличивает их количество (устройства с которыми можно взаимодействовать).
По аналогичным причинам разделение реализации и интерфейса полезно и в программировании.
Инкапсуляция
В объектно-ориентированном программировании инкапсуляция (или «сокрытие информации») — это процесс скрытого хранения деталей реализации объекта. Пользователи обращаются к объекту через открытый интерфейс.
В языке C++ инкапсуляция реализована через спецификаторы доступа. Как правило, все переменные-члены класса являются закрытыми (скрывая детали реализации), а большинство методов являются открытыми (с открытым интерфейсом для пользователя). Хотя требование к пользователям использовать публичный интерфейс может показаться более обременительным, нежели просто открыть доступ к переменным-членам, но на самом деле это предоставляет большое количество полезных преимуществ, которые улучшают возможность повторного использования кода и его поддержку.
Преимущество №1: Инкапсулированные классы проще в использовании и уменьшают сложность ваших программ.
С полностью инкапсулированным классом вам нужно знать только то, какие методы являются доступными для использования, какие аргументы они принимают и какие значения возвращают. Не нужно знать, как класс реализован изнутри. Например, класс, содержащий список имен, может быть реализован с использованием динамического массива, строк C-style, std::array, std::vector, std::map, std::list или любой другой структуры данных. Для использования этого класса, вам не нужно знать детали его реализации. Это значительно снижает сложность ваших программ, а также уменьшает количество возможных ошибок. Это является ключевым преимуществом инкапсуляции.
Все классы Стандартной библиотеки C++ инкапсулированы. Представьте, насколько сложнее был бы процесс изучения языка C++, если бы вам нужно было знать реализацию std::string, std::vector или std::cout (и других объектов) для того, чтобы их использовать!
Преимущество №2: Инкапсулированные классы помогают защитить ваши данные и предотвращают их неправильное использование.
Глобальные переменные опасны, так как нет строгого контроля над тем, кто имеет к ним доступ и как их используют. Классы с открытыми членами имеют ту же проблему, только в меньших масштабах. Например, допустим, что нам нужно написать строковый класс. Мы могли бы начать со следующего:
Геттеры и сеттеры
Материал на этой странице устарел, поэтому скрыт из оглавления сайта.
Для управляемого доступа к состоянию объекта используют специальные функции, так называемые «геттеры» и «сеттеры».
Геттер и сеттер для воды
На текущий момент количество воды в кофеварке является публичным свойством waterAmount :
Это немного опасно. Ведь в это свойство можно записать произвольное количество воды, хоть весь мировой океан.
Это ещё ничего, гораздо хуже, что можно наоборот – вылить больше, чем есть:
Так происходит потому, что свойство полностью доступно снаружи.
Чтобы не было таких казусов, нам нужно ограничить контроль над свойством со стороны внешнего кода.
Для лучшего контроля над свойством его делают приватным, а запись значения осуществляется через специальный метод, который называют «сеттер» (setter method).
Теперь waterAmount – внутреннее свойство, его можно записать (через сеттер), но, увы, нельзя прочитать.
Для того, чтобы дать возможность внешнему коду узнать его значение, создадим специальную функцию – «геттер» (getter method).
Единый геттер-сеттер
Для большего удобства иногда делают единый метод, который называется так же, как свойство и отвечает и за запись, и за чтение.
При вызове без параметров такой метод возвращает свойство, а при передаче параметра – назначает его.
Единый геттер-сеттер используется реже, чем две отдельные функции, но в некоторых JavaScript-библиотеках, например jQuery и D3, подобный подход принят на уровне концепта.
Итого
Также можно организовать геттеры/сеттеры для свойства, не меняя структуры кода, через дескрипторы свойств.
Задачи
Написать объект с геттерами и сеттерами
Напишите конструктор User для создания объектов:
Должен работать так:
Обратим внимание, что для «геттера» getFullName нет соответствующего свойства объекта, он конструирует ответ «на лету». Это нормально. Одна из целей существования геттеров/сеттеров – как раз и есть изоляция внутренних свойств объекта, чтобы можно было их как угодно менять, генерировать «на лету», а внешний интерфейс оставался тем же.
Добавить геттер для power
Обратим внимание, что ситуация, когда у свойства power есть геттер, но нет сеттера – вполне обычна.
Здесь это означает, что мощность power можно указать лишь при создании кофеварки и в дальнейшем её можно прочитать, но нельзя изменить.
Добавить публичный метод кофеварке
При этом, конечно же, должны происходить все необходимые проверки – на положительность и превышение ёмкости.
Что такое геттеры и сеттеры: терминология и сравнение методов
Геттеры и сеттеры встречаются во многих популярных языках программирования:
Где бы н и использовались геттеры и сеттеры, у них одна цель — защитить содержимое ваших скриптов, когда ими пользуется кто-нибудь другой.
Геттеры и сеттеры
Геттеры и сеттеры — это методы доступа, которые помогают вам управлять доступом к различным переменным в коде. В скриптах они пишутся так:
Чтобы лучше понять, как работают геттеры и сеттеры, нужно показать это на примере.
Геттеры и сеттеры для кваса
Итак, представим, что у нас есть собственная квас-машина наподобие кофе-машины, только с пивом:
//Наша квас-машина столько литров кваса не в местит!
//никого не тревожит, что наша квас-машина в мещает всего 50 литров кваса, все просто подходят и пьют
«Почему такой бардак с квасом происходит?» — спросите вы. А все потому, что объем нашей квас-машины доступен снаружи и абсолютно всем. Абсолютно любой может к ней обратиться и добавить или взять кваса столько, сколько за хочет. Для того чтобы такого не происходило, необходимо задать ограничение на использование нашей квас-машины со стороны остальных «любителей кваса».
Обычно контролировать в таких ситуациях можно при помощи приватного свойства, а записывать нужное значение при помощи сеттера. В нашем варианте это будет «setKvassAmount». Например:
var kvassAmount = 0;
var KVASS_COOL_VOLUME = 50;
return Amount * KVASS_HEAT_VOLUME * 40 / power;
// останавливаем квас-машину «с умом»
throw new Error(«Не может быть отрицательного значения»);
throw new Error(«Невозможно наливать большее количество кваса, чем » + volume);
alert( ‘Охлажденный квас!’ );
var kvassMachine = new KvassMachine(100, 50);
kvassMachine.setkvassAmount(500); // вот вам и ошибка!
function KvassMachine(power, volume) <
throw new Error(«Не может быть отрицательного значения»);
throw new Error(«Невозможно наливать большее количество кваса, чем » + volume);
var kvassMachine = new KvassMachine(100, 50);
alert( kvassMachine.getKvassAmount() ); // 500
Заключение
Мы будем очень благодарны
если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.
Геттеры и сеттеры в Javascript
Javascript — очень изящный язык с кучей интересных возможностей. Большинство из этих возможностей скрыты одним неприятным фактором — Internet Explorer’ом и другим дерьмом, с которым нам приходится работать. Тем не менее, с приходом мобильных телефонов с актуальными браузерами и серверного JavaScript с нормальными движками эти возможности уже можно и нужно использовать прям сейчас. Но по привычке, даже при программировании для node.js мы стараемся писать так, чтобы оно работало в IE6+.
В этой статье я расскажу про интересный и не секретный способ указывать изящные геттеры и сеттеры и немножко покопаемся в исходниках Mootools. Частично это информация взята из статьи John Resig, частично лично мой опыт и эксперименты.
Стандартные геттеры
Что такое Геттеры и Сеттеры, надеюсь знают все. Обычно и кроссбраузерно это выглядит так:
Можно пойти дальше и написать более изящный вариант:
Нативные геттеры/сеттеры
Но есть более удобный способ, который работает во всех серверных движках и современных браузерах, а именно Firefox, Chrome, Safari3+, Opera9.5+ — задание сеттера и геттера для свойства так, чтобы продолжать обращатся к свойству, как свойству. У такого подхода есть несколько преимуществ:
1. Более изящная запись. Представим ORM:
2. Если апи, которое базируется на свойствах уже есть и его нельзя менять (а очень нужно).
Есть два способа задать такой геттер/сеттер:
Через объект:
Через методы __defineGetter__ и __defineSetter__:
Определяем поддержку браузером
Из этого можно получить лёгкий способ определения, поддерживает ли браузер геттеры или не поддерживает:
Как быть с наследованием?
Таким образом нашему target передадутся не значения родительского source, а функции-геттеры/сеттеры.
Что следует помнить
MooTools
Мутулз не поддерживает по-умолчанию такую возможность. И, хотя я уже предложил патч, мы можем с лёгкостью (слегка изменив исходники) заставить его понимать геттеры и сеттеры.
Итак, какая наша цель?
Более того, в классах унаследованных через Implements и Extends тоже должны работать геттеры и сеттеры родительского класса. Все наши действия будут происходить в файле [name: Class] внутри анонимной функции.
Во-первых, внутри функции, в самом верху, определим функцию, которая перезаписывает только геттеры и сеттеры. И хотя мы отказалась от устаревших браузеров — стоит застраховаться.
Конечно, если наш скрипт с такими геттерами попадёт в устаревший браузер, то он просто упадёт, но это страховка от того, чтобы кто-то случайно не взял этот файл и не прицепил его к себе на сайт, а потом недоумевал, что такое с ишаком.
Мы видим, что если __lookupGetter__ не поддерживается, то функция просто ничего не сделает.
Теперь заставляем работать getterы и setterы во время создания класса и наследования (Extends). Для этого:
Отдельным движением надо реализовать наследование геттеров и сеттеров от примесей (Implements). Для этого надо найти встроенные Мутаторы и добавить всего одну строку:
Все, теперь сеттеры и геттеры реализуются и мы с лёгкостью можем их наследовать и использовать. Наслаждайтесь)
Есть два типа свойств объекта.
Первый тип это свойства-данные (data properties). Мы уже знаем, как работать с ними. Все свойства, которые мы использовали до текущего момента, были свойствами-данными.
Второй тип свойств мы ещё не рассматривали. Это свойства-аксессоры (accessor properties). По своей сути это функции, которые используются для присвоения и получения значения, но во внешнем коде они выглядят как обычные свойства объекта.
Геттеры и сеттеры
Свойства-аксессоры представлены методами: «геттер» – для чтения и «сеттер» – для записи. При литеральном объявлении объекта они обозначаются get и set :
Геттер срабатывает, когда obj.propName читается, сеттер – когда значение присваивается.
Например, у нас есть объект user со свойствами name и surname :
Снаружи свойство-аксессор выглядит как обычное свойство. В этом и заключается смысл свойств-аксессоров. Мы не вызываем user.fullName как функцию, а читаем как обычное свойство: геттер выполнит всю работу за кулисами.
Давайте исправим это, добавив сеттер для user.fullName :
Дескрипторы свойств доступа
Дескрипторы свойств-аксессоров отличаются от «обычных» свойств-данных.
То есть, дескриптор аксессора может иметь:
Например, для создания аксессора fullName при помощи defineProperty мы можем передать дескриптор с использованием get и set :
Ещё раз заметим, что свойство объекта может быть либо свойством-аксессором (с методами get/set ), либо свойством-данным (со значением value ).
Умные геттеры/сеттеры
Геттеры/сеттеры можно использовать как обёртки над «реальными» значениями свойств, чтобы получить больше контроля над операциями с ними.
Использование для совместимости
У аксессоров есть интересная область применения – они позволяют в любой момент взять «обычное» свойство и изменить его поведение, поменяв на геттер и сеттер.
Давайте его сохраним.
Добавление геттера для age решит проблему:
Теперь старый код тоже работает, и у нас есть отличное дополнительное свойство!