out kotlin что это

Дженерики Kotlin

Создание параметризованных классов —
Универсальный тип — это класс или метод, параметризованный над типами. Мы всегда используем угловые скобки ( ) указать параметр типа в программе.

Общий класс определяется следующим образом:

Чтобы создать экземпляр такого класса, нам нужно предоставить аргументы типа:

Если параметры могут быть выведены из аргументов конструктора, то можно пропустить аргументы типа:

Здесь GeeksforGeeks имеет тип String, поэтому компилятор выясняет, что мы говорим о Myclass

Преимущества дженерика —

Общее использование в нашей программе

В следующем примере мы создаем класс Company с основным конструктором, имеющим один параметр. Теперь мы пытаемся передать другой тип данных в объекте класса Company как String и Integer. Первичный конструктор класса Company принимает строковый тип ( «GeeskforGeeks» ), но выдает ошибку времени компиляции при передаче типа Integer ( 12 ).

Программа Kotlin без общего класса

class Company (text: String) <

>
fun main(args: Array )<

var name: Company = Company( «GeeksforGeeks» )

var rank: Company = Company( 12 ) // ошибка времени компиляции

Чтобы решить вышеупомянутую проблему, мы можем создать класс универсального типа, который определяется пользователем, который принимает различные типы параметров в одном классе. Класс Company of type является классом общего типа, который принимает параметры типа Int и String.

Программа Kotlin с использованием универсального класса

class Company (text : T)<

>
fun main(args: Array )<

var name: Company = Company ( «GeeksforGeeks» )

var rank: Company = Company ( 12 )

Дисперсия —

В отличие от Java, Kotlin делает массивы инвариантными по умолчанию. В общем, универсальные типы инвариантны в Kotlin. Это может управляться вне и в ключевых словах. Инвариантность — это свойство, с помощью которого стандартная универсальная функция / класс, уже определенная для определенного типа данных, не может принимать или возвращать другой тип данных. Любой является супертипом всех других типов данных.
Дисперсия бывает двух типов:

Котлин и в Ключевые слова —

Ключевое слово out —

В Kotlin мы можем использовать ключевое слово out для универсального типа, что означает, что мы можем присвоить эту ссылку любому из ее супертипов. Значение out может быть получено только данным классом, но не может быть использовано:

Выше мы определили класс OutClass который может создавать значение типа T. Затем мы можем присвоить экземпляр OutClass ссылке, которая является его супертипом:

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

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

Здесь мы объявили метод toString (), который потребляет только значение типа T. Затем мы можем присвоить ссылку типа Number ссылке на его подтип — Int:

Примечание. Если мы не использовали тип in в вышеприведенном классе, то данное выражение приведет к ошибке компилятора.

Ковариантность —

Ковариантность подразумевает, что замена подтипов является приемлемой, а супертипы — нет, то есть универсальная функция / класс может принимать подтипы того типа данных, для которого он уже определен, например, универсальный класс, определенный для Number, может принимать Int, но универсальный класс, определенный для Int, не может принимать Номер. Это может быть реализовано в Kotlin с использованием ключевого слова out следующим образом:

fun main(args: Array ) <

val y: MyClass = MyClass () // Работает, так как String является подтипом Any

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

fun main(args: Array ) <

Контраковариантность —

Он используется для замены значения супертипа в подтипах, то есть универсальная функция / класс может принимать супертипы типа данных, для которого она уже определена, например, универсальный класс, определенный для Number, не может принимать Int, но универсальный класс, определенный для Int, может принимать Номер. Он реализован в Kotlin с использованием ключевого слова in следующим образом:

fun main(args: Array ) <

Тип проекции —

Kotlin программа копирования элементов одного массива в другой —

assert (from.size == to.size)

// копирование (из) массива в (в) массив

for (i in from.indices)

// печать элементов массива, в который скопированы

for (i in to.indices) <

>
fun main(args :Array ) <

Выход:

Звездные проекции —

Когда мы не знаем о конкретном типе значения и просто хотим распечатать все элементы массива, мы используем проекцию звезды (*).

Kotlin программа использования звездных проекций —

// проекция звезды в массиве
fun printArray(array: Array ) <

>
fun main(args :Array ) <

Источник

Функции

Использование функций

При вызове функции используется традиционный подход:

Для вызова вложенной функции используется знак точки.

Параметры

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

Аргументы по умолчанию

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

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

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

Именованные аргументы

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

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

При её вызове, вам не нужно явно указывать все имена аргументов.

Вы можете пропустить все аргументы со значением по умолчанию.

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

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

Функции с возвращаемым типом Unit

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

Функции с одним выражением

Явное объявление возвращаемого типа является необязательным, когда он может быть определен компилятором.

Явные типы возвращаемых значений

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

Нефиксированное число аргументов (varargs)

Это позволит указать несколько значений в качестве аргументов функции.

Инфиксная запись

Область видимости функций

В Kotlin функции могут быть объявлены в самом начале файла, что значит, что вам не обязательно создавать класс, чтобы воспользоваться его функцией (как в Java, C# или Scala). В дополнение к этому, функции в Kotlin могут быть объявлены локально, как функции-члены и функции-расширения.

Локальные функции

Kotlin поддерживает локальные функции, т.е. функции, вложенные в другие функции.

Локальная функция может иметь доступ к локальным переменным внешних по отношению к ним функций (типа closure). Таким образом, в примере, приведённом выше, visited может быть локальной переменной.

Функции-члены

Функции-члены вызываются с использованием точки.

Для более подробной информации о классах и их элементах см. Классы и Наследование.

Функции-обобщения

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

Для более подробной информации см. Обобщения.

Функции с хвостовой рекурсией

Kotlin поддерживает стиль функционального программирования, известный как «хвостовая рекурсия». Это позволяет использовать циклические алгоритмы вместо рекурсивных функции, но без риска переполнения стэка. Когда функция помечена модификатором tailrec и её форма отвечает требованиям компилятора, он оптимизирует рекурсию, оставляя вместо неё быстрое и эффективное решение этой задачи, основанное на циклах.

Источник

Почему следует полностью переходить на Kotlin

Хочу рассказать вам о новом языке программирования, который называется Kotlin, и объяснить, почему вам стоит использовать его в своём следующем проекте. Раньше я предпочитал Java, но в последний год пишу на Kotlin везде, где только можно. И в данный момент я не представляю себе ситуации, в которой лучше было бы выбрать Java.

Kotlin разработан в JetBrains, и участие тех же людей в создании наборов IDE, таких как IntelliJ и ReSharper, хорошо заметно по самому языку. Он прагматичен и краток, благодаря чему написание кода превращается в приятный и эффективный процесс.

Хотя Kotlin компилируется в JavaScript и скоро будет компилироваться в машинный код, я сконцентрируюсь на его первичной среде — JVM.

Итак, несколько причин, почему вам следует полностью переходить на Kotlin (порядок случаен):

0# Совместимость с Java

Kotlin на 100 % совместим с Java. Вы можете в буквальном смысле продолжать работать над своим старым Java-проектом, но уже используя Kotlin. Все ваши любимые Java-фреймворки также будут доступны, и, в каком бы фреймворке вы ни писали, Kotlin будет легко принят упрямым любителем Java.

1# Знакомый синтаксис

2# Интерполяция строк

Это как бы более умная и читабельная версия String.format() из Java, встроенная в язык:

3# Выведение типа

Kotlin будет выводить ваши типы, если вы посчитаете, что это улучшит читабельность:

4# Умные приведения типов (Smart Casts)

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

5# Интуитивные равенства (Intuitive Equals)

6# Аргументы по умолчанию

Больше не нужно определять несколько одинаковых методов с разными аргументами:

7# Именованные аргументы

В сочетании с аргументами по умолчанию именованные аргументы избавляют от необходимости использовать Строителей:

8# Выражение When

Оператор ветвления заменён гораздо более читабельным и гибким в применении выражением when:

Оно работает и как выражение (expression), и как описание (statement), с аргументом или без него:

9# Свойства

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

10# Data Class

11# Перегрузка оператора (Operator Overloading)

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

12# Деструктурирующие объявления (Destructuring Declarations)

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

13# Диапазоны (Ranges)

Для улучшения читабельности:

14# Функции-расширения (Extension Functions)

Если бы существовал способ добавления новых функций в старые классы, тогда ваш IDE помог бы найти правильную функцию при завершении кода. Именно это можно делать в Kotlin:

Стандартная библиотека расширяет функциональность оригинальных Java-типов, что особенно полезно для String :

15# Безопасность Null

Kotlin заставляет вас бороться с NPE, когда вы обращаетесь к типу, допускающему null:

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

Если всё это вам не подходит и вам совершенно точно нужны NPE, то скажите об этом явно:

16# Улучшенные лямбды

Это хорошая система лямбд — идеальный баланс между читабельностью и лаконичностью благодаря нескольким толковым решениям. Синтаксис прост:

А вот и толковые решения:

Комбинация этих факторов делает эквивалентными эти три строки:

Это позволяет нам писать лаконичный функциональный код, вы только посмотрите на эту красоту:

Система лямбд, объединённая с функциями-расширениями, делает Kotlin идеальным инструментом для создания DSL. Anko — пример DSL, предназначенного для расширения возможностей Android-разработки:

17# Поддержка IDE

У вас есть целый ряд вариантов, как можно начать работать с Kotlin, но я крайне рекомендую использовать IntelliJ, идущий в комплекте поставки Kotlin — его возможности демонстрируют преимущество ситуации, когда одни и те же люди разрабатывают как язык, так и IDE.
Небольшой пример: это сообщение всплыло, когда я впервые попытался скопипастить Java-код со Stack Overflow:

IntelliJ заметит, что вы вставляете Java-код в файл Kotlin

На этом всё, спасибо за чтение! Если мне пока не удалось убедить вас насчёт Kotlin, то рекомендую почитать дополнительные материалы:

Источник

Kotlin и свои почти языковые конструкции

Скорее всего, из разработчиков, пользующихся Java, и в особенности Android-разработчиков многие уже знают про Kotlin. Если нет, то никогда не поздно узнать. Особенно если Java не устраивает вас чем-то как язык — что наверняка так — или если вы владеете Scala, но и этот язык вам не подходит, что тоже не исключено.

Если кратко, то Kotlin — это статически типизированный язык, ориентирующийся на JVM, Android (компилируется в байт-код Java) и веб (компилируется в JavaScript). JetBrains, разработчик языка, ставили своей целью лаконичный и понятный синтаксис, быструю компиляцию кода и типобезопасность. Язык пока находится в предрелизном состоянии, но всё стремительно движется к релизу.

К слову, после Java «переучиться» на Kotlin не составит никакого труда, в этом поможет и понятный (субъективно) синтаксис, и полная совместимость с кодом на Java в обе стороны, что позволяет Java-программисту использовать весь привычный набор библиотек.

Ещё одной целью разработчиков языка была возможность его гибкого использования, в том числе для создания библиотек, внешне похожих на DSL, и собственных конструкций (хороший пример типобезопасного builder’а для HTML; статья про реализацию yield). У Kotlin есть несколько фич, которые позволят решать эти задачи эффективно и красиво. Давайте с ними познакомимся.

Расширения (Extensions)

В Kotlin есть возможность дополнять функционал произвольного класса, не наследуясь от него, функциями (и свойствами) расширения. Такая же возможность есть, например, в C#. Стоит отметить, что поведение функций расширения отличается от member functions: вызовы функций расширения разрешаются статически, по объявленному типу, а не виртуально.

toRegex(), drop(n), take(n) и joinToString(» «) в примере — это тоже функции расширения.

Альтернативный синтаксис для вызова функций

1. Функцию экземпляра или функцию расширения, имеющую только один аргумент, можно вызывать в инфиксной форме:

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

Встраиваемые (inline) функции

Несмотря на то, что этот код пестрит лямбда-выражениями, ни одного анонимного класса для них создано не будет, и i даже не попадёт в closure. Просто праздник!

Попробуем?

Посмотрим, что мы можем сделать со всем этим арсеналом — предположим, что мы хотим сделать такую довольно бесполезную конструкцию:

Прямо так, к сожалению, не получится, но постараемся сделать что-то похожее.

Первая попытка: функция с двумя функциональными аргументами

Вот так её можно использовать:

Если сюда добавить inline, должно получиться достаточно эффективно. Позже посмотрим, насколько, а пока попробуем добиться более красивого синтаксиса для этой конструкции.

Вторая попытка: красивый синтаксис

Этот вариант не рассчитан на многопоточность! Для использования его в нескольких потоках нужно будет завернуть экземпляры в ThreadLocal, что ещё немного ухудшит производительность.

Третья попытка: каррирование

По сравнению с первой попыткой изменилось расположение скобок в вызове. 🙂
Учитывая inline, мы можем ожидать, что работать этот вариант будет так же, как первый.
Это можно проверить, взглянув на байт-код: у IntelliJ IDEA есть утилита, показывающая байт-код, в который скомпилируется код на Kotlin, на лету, и даже можно посмотреть, как будет отличаться байт-код с @inline и без.

Производительность

Давайте теперь посмотрим, что будет с производительностью нашей конструкции в разных вариантах.

Тестировать будем на таком примере:

Задно добавим к сравнению такой код, который будет эталоном производительности:

По итогам пятидесятикратного запуска с последующим усреднением времени получилась следующая таблица:

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

Итого

Kotlin предоставляет действительно гибкие возможности для «кастомизации» языка, но за них иногда будет нужно платить производительностью. Аннотация @inline может помочь улучшить ситуацию, если в вашем коде есть функции первого порядка. В любом случае, думаю, у вас найдутся хорошие сценарии применения для всего этого.

Источник

Немного о Kotlin

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

Что такое Котлин

Котлин — это небольшой остров в Финском заливе недалеко от Санкт-Петербурга. Видимо, тем самым создатели дают отсылку к тому, что новый язык, как остров Котлин — младший русский брат далекого острова Ява.

Для кого этот язык

Действительно, новый язык компилируется в JVM байт-код (есть еще и компиляция в JavaScript, но так как релиз компилятора именно в JVM, эту тему придется опять отложить). А это значит, что он может заинтересовать всех, кто имеет дело с Java-машиной и в целом с языками со сборщиком мусора (а с выходом релиза компиляции в JavaScript покрытие и возможности будут еще шире).

Простой и совместимый

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

Production-ready

Конечно, в первую очередь, запрос на этот язык был у самой JetBrains, отсюда и некоторое понимание, каким он должен быть. Более того, JetBrains же внутри компании его и тестировала: к моменту выхода этого релиза у компании уже есть как минимум один крупный продукт сделанный чисто на котлине (да, я понимаю, что платформа по прежнему написана на Java). Отсюда можно предположить, что заявления о готовности языка к продакшену не голословны. А из своего же опыта использования котлина с 2012 года могу сказать, что из тех проблем, с которыми я сталкивался в дорелизные времена, до релиза ни одна не дожила. Есть еще небольшие проблемы с плагином для IDEA, но сам компилятор работает как часы.

Совместим с Java 1.6

Это очень важный момент, ведь именно эта версия Java используется во всех современных версиях Android, и, не смотря на запланированный переход на OpenJDK, восьмая версия попадет в руки разработчикам под мобильные устройства не так скоро как хотелось бы. Конечно, есть всякие ретролямбды и другие ухищрения, но котлин — это не только лямбды для андроид, но и современный язык, позволяющий сделать разработку под андроид проще и приятней без особых затрат. А увеличение размера apk совсем не значительно по нынешним временам: 823KB (для версии 1.0.0)

Особенности

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

Null safety

Почему-то исторически так сложилось, что эта особенность котлина вспоминается первой. И хотя она безусловно важна, на мой взгляд не является важнейшей. Здесь язык позволяет, определяя переменные, поля, константы и тд, указать, может ли в них храниться ссылка на null. Поднимает на новый уровень идею аннотаций вроде @Nullable и NotNull, позволяет умно приводить к не-nullable типу после проверки её на null. Надо отметить, что бывают случаи, когда эта особенность расходится с моим закостенелым разработкой на Java представлением о том как должны быть сделаны некоторые вещи, но после некоторого раздумья хорошее решение всегда находится.

Выведение типов

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

Extension methods

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

Лямбды

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

Extension-лямбды

Наряду с extension-методами, это еще одна моя любимая фича. Позволяет определить лямбду, которая будет еще и extension-методом. Звучит не очень, да. Посмотрим на примере:

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

Inline-фукнции

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

Конечно, на такие функции накладывается серия ограничений, подробнее см. документацию.

Делегирование

В котлине есть два типа делегирования. Первый, который позволяет делегировать все методы реализуемого интерфейса к какому-то инстансу этого типа:

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

Второй тип делегирования — это delegated properties. Позволяет определить объект с методами get (и set для var), к которым будет осуществляться делегирование доступа при обращении к свойству объекта.

Generics

Создатели котлина несколько улучшили Java-дженерики. Из-за совместимости с джавой не всё получилось как хотелось бы, но им удалось исправить много неприятных моментов, которые не учли их предшественники при работе над Java 5.

Деструктуризация

Чтобы такой код заработал, возвращаемое значение из someFunc() должно быть типа, у которого есть (можно extension) методы component1(), component2():

Data-классы

Сахар компилятора для создания бинов:

Создает бин с полями + автогенерирует equals+hashCode+toString()+componentN из раздела выше, что позволяет писать такой код:

Полезная вещь, но о нюансах см. пункт «О грустном».

Стандартная библиотека

Конечно, нельзя не упомянуть и стандартную библиотеку. Так как котлин нацелен в первую очередь на работу вместе с Java, то и целиком своей стандартной библиотеки у него нет. Большая часть стандартной библиотеки Kotlin нацелена на улучшение и исправление библиотеки старшего брата — Java. Однако, это тема для другой большой статьи.

О грустном

Вы могли подумать, что это идеальный продукт, но нет, есть и неприятные моменты:

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

Data-классы

Некоторая неряшливость

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

Источник