Object expressions and declarations
Sometimes you need to create an object that is a slight modification of some class, without explicitly declaring a new subclass for it. Kotlin can handle this with object expressions and object declarations.
Object expressions
Object expressions create objects of anonymous classes, that is, classes that aren’t explicitly declared with the class declaration. Such classes are useful for one-time use. You can define them from scratch, inherit from existing classes, or implement interfaces. Instances of anonymous classes are also called anonymous objects because they are defined by an expression, not a name.
Creating anonymous objects from scratch
Object expressions start with the object keyword.
If you just need an object that doesn’t have any nontrivial supertypes, write its members in curly braces after object :
Inheriting anonymous objects from supertypes
To create an object of an anonymous class that inherits from some type (or types), specify this type after object and a colon ( : ). Then implement or override the members of this class as if you were inheriting from it:
If a supertype has a constructor, pass appropriate constructor parameters to it. Multiple supertypes can be specified as a comma-delimited list after the colon:
Using anonymous objects as return and value types
When an anonymous object is used as a type of a local or private but not inline declaration (function or property), all its members are accessible via this function or property:
If this function or property is public or private inline, its actual type is:
Any if the anonymous object doesn’t have a declared supertype
The declared supertype of the anonymous object, if there is exactly one such type
The explicitly declared type if there is more than one declared supertype
In all these cases, members added in the anonymous object are not accessible. Overridden members are accessible if they are declared in the actual type of the function or property:
Accessing variables from anonymous objects
The code in object expressions can access variables from the enclosing scope:
Object declarations
The Singleton pattern can be useful in several cases, and Kotlin makes it easy to declare singletons:
This is called an object declaration, and it always has a name following the object keyword. Just like a variable declaration, an object declaration is not an expression, and it cannot be used on the right-hand side of an assignment statement.
The initialization of an object declaration is thread-safe and done on first access.
To refer to the object, use its name directly:
Such objects can have supertypes:
Object declarations can’t be local (that is, they can’t be nested directly inside a function), but they can be nested into other object declarations or non-inner classes.
Companion objects
An object declaration inside a class can be marked with the companion keyword:
Members of the companion object can be called simply by using the class name as the qualifier:
The name of the companion object can be omitted, in which case the name Companion will be used:
Class members can access the private members of the corresponding companion object.
The name of a class used by itself (not as a qualifier to another name) acts as a reference to the companion object of the class (whether named or not):
Note that even though the members of companion objects look like static members in other languages, at runtime those are still instance members of real objects, and can, for example, implement interfaces:
However, on the JVM you can have members of companion objects generated as real static methods and fields if you use the @JvmStatic annotation. See the Java interoperability section for more detail.
Semantic difference between object expressions and declarations
There is one important semantic difference between object expressions and object declarations:
Object expressions are executed (and initialized) immediately, where they are used.
Object declarations are initialized lazily, when accessed for the first time.
A companion object is initialized when the corresponding class is loaded (resolved) that matches the semantics of a Java static initializer.
Объектно-ориентированное программирование
Классы и объекты
Kotlin поддерживает объектно-ориентированную парадигму программирования, а это значит, что программу на данном языке можно представить в виде взаимодействующих между собой объектов.
Класс фактически представляет новый тип данных, поэтому мы можем определять переменные этого типа:
В функции main определены три переменных типа Person. Стоит также отметить, что в отличие от других объектно-ориентированных языков (как C# или Java), функция main в Kotlin не помещается в отдельных класс, а всегда определяется вне какого-либо класса.
Для создания объекта класса необходимо вызвать конструктор данного класса. Конструктор фактически представляет функцию, которая называется по имени класса и которая выполняет инициализацию объекта. По умолчанию для класса компилятор генерирует пустой конструктор, который мы можем использовать:
Часть кода после знака равно Person() как раз и представляет вызов конструктора, который создает объект класса Person. До вызова конструктора переменная класса не указывает ни на какой объект.
Например, создадим три объекта класса Person:
Свойства
Свойство должно быть инициализировано, то есть обязательно должно иметь начальное значение. Например, определим пару свойств:
В данном случае в классе Person, который представляет человека, определены свойства name (имя человека) и age (возраст человека). И эти свойства инициализированы начальными значениями.
Для обращения к свойствам используется имя переменной, которая предствляет объект, и после точки указывается имя свойства. Например, получение значения свойства:
Установка значения свойства:
Функции класса
Класс также может содержать функции. Функции определяют поведение объектов данного класса. Такие функции еще называют member functions или функции-члены класса. Например, определим класс с функциями:
В функциях, которые определены внутри класса, доступны свойства этого класса. Так, в данном случае в функциях можно обратиться к свойствам name и age, которые определены в классе Person.
Для обращения к функциям класса необходимо использовать имя объекта, после которого идет название функции и в скобках значения для параметров этой функции:
Объект в Kotlin и паттерн «Одиночка»
Объект в Kotlin и паттерн «Одиночка»
Сегодня вы изучите, как использовать ключевое слово object в Kotlin для определения одиночных, сопутствующих и анонимных объектов и обеспечения взаимодействия с Java.
Итак, начнем
Откройте свой проект в Android Studio 4.1 или выше. Выберите «Open an Existing Project», а затем выберите имя начального проекта.
Открыв стартовый проект, вы обнаружите там уже некую структуру:
Далее соберите и запустите проект. Вы увидите экран с разнообразными Android- тематическими продуктами для продажи:
Тем не менее вы пока ничего не можете купить. Продолжайте чтение, чтобы добавить возможность покупок, параллельно изучая способы использования object в Kotlin.
Использование синглотонов (одиночек) в Kotlin
Используя слово object в приложении, вы определяете синглтон (одиночку). Одиночка – это шаблон проектирования, в котором данный класс имеет только один экземпляр внутри всего приложения.
Одиночка чаще всего применяется:
Держите в уме, что одиночки не решение по хранению данных. Данные в них живут только пока живо ваше приложение в памяти.
Читайте далее, как определить синглтон!
Использование Object для определения синглтона корзины покупок
На данный момент нет способа добавить предметы в вашу тележку и отобразить в приложении. Для осуществления затеи необходимо место для помещения информации и способ поделиться ей на других экранах приложения.
Android Studio создаст файл с пустым object для вас. Это будет выглядеть так:
Вы можете многое узнать об этой разнице, посмотрев на эквивалентный код Java. К счастью для вас, в Android Studio есть способ сделать это.
Перейдите в Tools ▸ Kotlin ▸ Show Kotlin Bytecode и нажмите кнопку Decompile в верхней части окна Kotlin Bytecode. Вы увидите что-то вроде следующего:
На что обратить внимание:
Помните об этом, когда пытаетесь использовать Kotlin вместе с Java!
Создание публичного интерфейса синглтона
Теперь, создав синглтон, необходимо создать его публичный интерфейс, чтобы другие классы могли общаться с ним. Для этого добавьте следующий код внутрь ShoppingCart :
Добавив этот код, вы:
Далее вы узнаете, как получить доступ к публичному интерфейсу только что определенного синглтона.
Получение публичного интерфейса синглтона
Теперь добавьте некоторую логику для получения одиночки. Для этого:
Для визуализации обратной связи, позволяющей убедиться, что вы успешно добавили продукт, вы также показываете Toast.
Теперь соберите и запустите. Нажмите на продукт, и вы увидите Toast, подтверждающий, что вы добавили его в корзину:
Работа с сопутствующими объектами
Это будет важно, когда вы узнаете, как получить доступ к сопутствующим объектам в следующем разделе. А пока сосредоточитесь на определении сопутствующего объекта.
Определение сопутствующего объекта
Для определения сопутствующего объекта откройте ShoppingCartActivity и найдите // TOD O перед последней закрывающей скобкой. Замените на следующее:
Если Android Studio побуждает так сделать, импортируйте android.content.Context и android.content.Intent для Context и Intent соответственно.
Поздравляю, вы определили сопутствующий объект!
Заметка
Основное различие между объявлениями объектов и сопутствующими объектами заключается в том, как они инициализируются. Объявления объектов инициализируются при первом использовании. Сопутствующие объекты инициализируются при загрузке содержащего их класса, что соответствует поведению статических инициализаторов Java.
Получение сопутствующего объекта для старта задачи
Теперь соберите проект и запустите его. Нажмите на Go to Cart и вы увидите, что приложение теперь показывает новый пустой экран:
Но куда же подевались все товары из вашей корзины? Не волнуйтесь, вы займетесь этим в следующем разделе.
Отображение товаров из корзины
Теперь вы создадите экран корзины для покупок, используя:
Для начала вы примените Java класс для подсчета итоговой цены корзины. В процессе вы изучите, как совместимость между Kotlin и Java одиночками устроена.
Получение Kotlin одиночки из Java для подсчета цены
Начните с создания нового Java класса для выполнения этих вычислений, используя следующие шаги:
Пока этот метод отрабатывает, вы можете его немного подчистить, используя @JvmStatic :
Добавив аннотацию, объявление products должно выглядеть так:
Отображение товаров в корзине
Вам нужно будет подключить все, чтобы отображались товары и общая цена в корзине. Для этого:
Вот что делает приведенный выше код:
Теперь соберите и запустите проект. Убедитесь, что он работает, добавив несколько продуктов в корзину и нажав Go to Cart. Вы увидите экран, на котором отображается корзина с товарами плюс общая цена:
Вы только что узнали, как заставить Java получить доступ к данным из синглтона Kotlin. Далее вы узнаете, как удалить товары из корзины с помощью кнопки Clear Cart.
Определение слушателей объектов
Когда пользователь очищает корзину покупок, ShoppingCartActivity должен обновиться, чтобы отобразить пустую корзину вместо корзины с продуктами. Но синглтоны не уведомляют своих слушателей об изменениях автоматически, поэтому вам необходимо реализовать это поведение, чтобы пользователь мог очистить свою корзину.
Уведомление слушателей об изменениях корзины
Чтобы уведомить слушателей об изменениях корзины, откройте ShoppingCart и добавьте следующий код перед последней закрывающей скобкой:
Здесь вы определяете интерфейс, который ShoppingCart будет использовать для уведомления слушателей об изменении своих данных.
Затем добавьте следующий код между var products и addProduct() в ShoppingCart :
В приведенном коде вы определили слабую ссылку на слушателя. Это заставляет ShoppingCart уведомлять этого слушателя всякий раз, когда данные меняются.
Слабая ссылка не дает одиночке сильно удерживаться за действие, что может вызвать утечку памяти. Подробнее об этом позже!
Теперь, когда у вас есть слушатель, вы должны его уведомить! Еще в ShoppingCart добавьте следующую функцию:
Это добавляет частный метод к одиночке. Он уведомляет вашего слушателя об изменении списка продуктов. Поскольку только синглтон может обновлять список, именно он должен иметь возможность запускать это уведомление. Подобные частные методы не будут видны извне одиночки, поэтому они идеально подходят для внутренней логики.
Теперь, когда бы пользователь не добавил товар в корзину, ShoppingCart уведомит его слушателей.
Прослушивание изменений корзины: анонимные объекты
Для этого вернитесь в ShoppingCartActivity и добавьте следующее свойство между var products и onCreate() :
Вы определили этот анонимный объект как свойство своего ShoppingCartActivity. Это означает, что переопределенный onCartChanged() может получить доступ к любым функциям и свойствам в действии.
Теперь вам нужно указать одиночке использовать только что созданное свойство в качестве его слушателя. Найдите // Your code внутри onCreate() и замените его на:
Далее найдите setupClearCartButton() и замените // TODO на:
Этот код вызывает clear() в синглтон, когда пользователь нажимает кнопку Clear Cart.
Когда пользователь очищает корзину для покупок, одиночка уведомляет своего слушателя. Поскольку слушатель был настроен на анонимный объект в ShoppingCartActivity, именно об этом и отправляется уведомление.
Теперь соберите и запустите приложение. Добавьте товары в корзину, нажмите Go to Cart и Clear Cart. Это очистит корзину и обновит view:
И вот: финальный вид вашей корзины покупок!
Далее вы изучите некоторые лучшие приемы по работе с Kotlin объектами.
Лучшие приемы для синглтонов и сопутствующих объектов
Прежде чем закончить статью, уделите немного времени рассмотрению некоторых передовых моментов.
Котлин с нуля: классы и объекты
Russian (Pусский) translation by Liliya (you can also view the original English article)
В предыдущей статье вы узнали о расширенном использовании функций, таких как функции расширения, смыкания, функции высшего порядка и встроенные функции в Kotlin.
В этой статье вы познакомитесь с объектно-ориентированным программированием в Kotlin, изучив классы: конструкторы и свойства, приведение типов и более продвинутые функции классов, которые Kotlin упрощает.
1. Классы
Конструкторы класса и свойства
Давайте посмотрим, как добавить конструктор и свойства в наш класс. Но сначала давайте посмотрим на типичный класс в Java:
Глядя на наш класс модели Book выше, мы имеем следующее:
Теперь давайте посмотрим, как вместо этого можно написать предыдущий код на Kotlin:
Довольно аккуратный класс! Теперь мы сократили количество строк кода с 20 до просто 9. Функция constructor() называется вторичным конструктором в Kotlin. Этот конструктор эквивалентен конструктору Java, который мы вызывали при создании экземпляра класса.
Давайте посмотрим на другую версию того же класса в Kotlin:
В этом коде мы удалили вторичный конструктор. Вместо этого мы объявили конструктор в заголовке класса, который называется первичным конструктором. Первичный конструктор не имеет места для размещения блока кода, поэтому мы используем модификатор init для инициализации входящих параметров из первичного конструктора. Обратите внимание, что блок init кода инициализации выполняется сразу при создании экземпляра класса.
Как вы можете видеть, наш код все еще содержит много шаблонов. Давайте уменьшим это далее:
Мы также можем добавить значения по умолчанию к любому из свойств класса прямо внутри конструктора.
Очень аккуратный класс, должен сказать!
Теперь мы можем создать экземпляр класса следующим образом:
Доступ и настройка свойств
Давайте посмотрим на другой пример:
Совместимость Java
Пользовательские Getters и Setters
В этом разделе я покажу вам, как создать собственные средства доступа (геттеры и сеттеры) для свойства в Kotlin, если вы хотите. Создание пользовательского установщика может быть полезно, если вы хотите проверить или подтвердить значение до того, как оно будет установлено в свойство класса. И пользовательский метод получения свойств может быть полезен, когда вы хотите изменить или изменить значение, которое должно быть возвращено.
Создание настраиваемого сеттера
Поскольку мы хотим создать свой собственный метод получения или установки для свойства, мы должны определить это свойство в теле класса вместо заголовка конструктора.
Вот почему мы переместили изменяемое свойство title (чтение-запись) в тело класса и присвоили ему значение по умолчанию (иначе оно не будет компилироваться).
Создание пользовательского Getter
Создать собственный геттер для недвижимости в Котлине очень просто.
Если вы хотите узнать о функциях-членах для класса Kotlin (вид функции, которая определена внутри класса, объекта или интерфейса), посетите пост «Больше возможностей с функциями» в этой серии.
Подробнее о конструкторах
Обратите внимание, что мы не можем объявлять свойства внутри вторичного конструктора, как мы это делали для первичного конструктора. Если мы хотим сделать это, мы должны объявить это внутри тела класса, а затем инициализировать его во вторичном конструкторе.
Также обратите внимание, что внутри класса может быть несколько вторичных конструкторов.
2. Любые и ничтожные типы
Это может пригодиться при тестировании поведения обработки ошибок в модульных тестах.
3. Модификаторы видимости
Модификаторы видимости помогают нам ограничить доступность нашего API для широкой публики. Мы можем предоставить различные модификаторы видимости для наших классов, интерфейсов, объектов, методов или свойств. Kotlin предоставляет нам четыре модификатора видимости:
Public
Это значение по умолчанию, и любой класс, функция, свойство, интерфейс или объект, которые имеют этот модификатор, могут быть доступны из любого места.
Private
Любая функция или свойство, которые объявлены private внутри класса, объекта или интерфейса, могут быть видны только другим членам этого же класса, объекта или интерфейса.
Protected
Internal
В проекте, в котором есть модуль (модуль Gradle или Maven), класс, объект, интерфейс или функция, указанные с помощью internal модификатора, объявленного внутри этого модуля, доступны только из этого модуля.
4. Smart Casting
5. Explicit Casting
Мы можем использовать оператор as (или небезопасный оператор литья) для явного указания ссылки типа на другой тип в Kotlin.
6. Объекты
Объекты в Kotlin больше похожи на объекты JavaScript, чем объекты Java. Обратите внимание, что объект в Kotlin не является экземпляром определенного класса!
Объекты очень похожи на классы. Вот некоторые из характеристик объектов в Котлине:
Давайте теперь разберемся, как создать объект.
Вы можете получить доступ к объекту или синглтону в любом месте вашего проекта, если вы импортируете его пакет.
Если вы Java-кодер, так мы обычно создаем синглтоны:
Как вы можете видеть, использование конструкции объекта Kotlin делает его кратким и легким для создания одиночных чисел.
Объекты в Котлине могут также использоваться для создания констант. Обычно в Java мы создаем константы в классе, делая это публичное статическое конечное поле следующим образом:
Этот код на Java можно более кратко преобразовать в Kotlin следующим образом:
Чтобы использовать эту константу в другом пакете в Котлине, просто импортируйте пакет.
Совместимость с Java
Чтобы функция или свойство объекта в Kotlin были статическим членом генерируемого класса Java, мы используем @JvmStatic аннотация. Вот как это использовать:
Теперь Java-вызовы могут вызывать его как обычный статический член-вызов. Обратите внимание, что использование статического поля INSTANCE для вызова участников будет по-прежнему работать.
7. Сопутствующие объекты
Теперь мы поняли, какие объекты находятся в Котлине, давайте погрузимся в объекты другого типа, называемые сопутствующими объектами.
Создание объекта-компаньона
Вызов функции объекта Companion
companion экземпляр объекта ленив. Другими словами, он будет создан только в случае необходимости в первый раз Создание экземпляра объекта companion происходит, когда создается экземпляр класса companion или доступ к элементам companion объекта.
Давайте посмотрим, как вызвать функцию сопутствующего объекта в Kotlin.
Как вы можете видеть, это похоже на вызов статического метода в Java как обычно. Другими словами, мы просто вызываем класс, а затем вызываем его. Обратите внимание: кроме функций мы можем также иметь свойства внутри нашего объекта-компаньона.
Результат выполнения кода выше будет:
Помните, что может существовать только один экземпляр объекта companion класса.
Мы также можем предоставить объекту-компаньону имя.
Этот стиль является многословным, поэтому придерживаться предыдущего способа является очень предпочтительным. Но это может пригодиться при вызове функции или свойства объекта-компаньона с Java.
Как я уже говорил ранее, подобные объекты, объекты-компаньоны могут также включать в себя свойства или функции, реализовывать интерфейсы и даже расширять класс.
Совместимость с Java
Расширения сопутствующих объектов
Аналогично тому, как функции расширения могут расширять функциональность класса, мы также можем расширять функциональность сопутствующего объекта. (Если вы хотите освежить в расширенных функциях в Kotlin, посетите руководство по дополнительным функциям в этой серии).
Заключение
В этом уроке вы узнали об основных классах и объектах в Kotlin. Мы рассказали о классах:
Кроме того, вы узнали о том, как объекты и сопутствующие объекты в Kotlin могут легко заменить ваши статические методы, константы и синглтоны, которые вы кодируете в Java. Но это еще не все! Можно узнать еще больше о Котлине. В следующем посте я покажу вам еще больше интересных возможностей, которые есть у Kotlin для объектно-ориентированного программирования. До скорой встречи!
Чтобы узнать больше о языке Kotlin, я рекомендую посетить документацию Kotlin. Или ознакомьтесь с некоторыми другими нашими статьями по разработке приложений для Android здесь, на Envato Tuts+!
