Kotlin Basics | Commissioning and Applications

Delegation is a common pattern, it has nothing to do with programming language, that is, delegate what you originally did to another object to do it. Both the decorator pattern and the agent pattern reuse behavior through delegation. Kotlin supports delegation at the language level. This article introduces Kotlin's delegation with examples.

Kotlin's decorator pattern

The decorator pattern and inheritance have the same purpose, both for extending the class, but it uses a more complicated way: inheritance + composition. The decorator pattern extends its functions on the basis of reusing the original types and behaviors. For a detailed analysis of the decorator mode and the agent mode, you can click to use the combined design mode | remote agent mode for chasing girls .

The following is an example of the decorator pattern:

This interface is used to describe an abstract accessory. A specific accessory needs to implement three methods to define the accessory name, price, and category.

Feathers, rings, and earrings are three specific accessories, and their realization is as follows:

Now it is necessary to add feather rings and feather earrings. According to the inherited idea, this can be achieved as follows:

The disadvantage of writing this way is that only the type is reused, and there is no reuse behavior. Every time a new type is added, a subcategory must be added, which will cause subcategories to expand. If you switch to the decorator pattern, you can reduce one subcategory:

Now feather rings and earrings can be expressed like this

,. The application combination holds an abstract accessory, so that the behavior that is injected into the accessory can be reused.withAdded new functions on the basis of reuse behavior, andDirectly delegated the implementation to.

Using Kotlin's delegation syntax can be further simplified

class: The keyword appears after the class name, indicating class delegation , that is, the realization of the class is delegated to an object, which must implement the same interface as the class, here it isinterface. useThe advantage is to eliminate the template code, as shown above,The implementation of the interface can be omitted.

Lazy initialization once

Lazy initialization is also a common pattern: the initialization of an object is delayed until it is accessed for the first time. When initialization consumes a lot of resources, lazy initialization is particularly valuable.

Supporting attributes is an idiomatic technique for lazy initialization:

Support attributes

Is private, it is used to store a set of Bitmap, and another of the same typeUsed to provide access to a set of Bitmaps.

So only when the first visit

When the time, Bitmap will be loaded. During the second visit, Bitmap will not be reloaded, and you can return directly.

The above code is a Kotlin predefined function

Internally used technology, with it, template code can be eliminated:

Keywords here

Appears after the attribute name, indicating attribute delegation , that is, entrusting the reading and writing of the attribute to another object. The delegated object must meet certain conditions:

1. When performing property delegation for read-only variables modified by val, the delegated object must implement
   getValue()
   Interface, which defines how to get the variable value.
2. When performing attribute delegation for var modified read-write variables, the delegated object must implement
   getValue()
   with
   setValue()
   Interface, which defines how to read and write variable values.

3.ways to achieve attribute delegation

The return value of the method is aObject: The class is not directly implementedmethod. It uses another, more flexible way: Is declared asThe extension function of the class . This is Kotlin's unique feature that adds new functions to the class outside of the class. It is especially useful when the original class cannot be modified.

In addition to extension functions, there are two other ways to implement the delegated class (assuming the type of proxy is String):

In this way, a new proxy class is created, and keywords are passed in the class

OverloadedwithThese two operators correspond to value and setting operations respectively.

The last way is as follows (assuming the type of proxy is String):

Realize

In the interfacewithmethod.

Then you can use the proxy class like this:

The implementation behind the attribute delegation is as follows:

Newly created

The class will be stored in a supporting attributeIn, the setting of the delegated property and the realization of the value method are delegated to the proxy class.

After delegation, when accessing the delegated properties, it is like calling a method of the proxy class:

Commissioned application

1. Easier access to parameters

Delegates can hide details, especially when the details are some template code:

The code to get the value passed to the Activity or Fragment is very template. You can use delegates to hide the following details:

Then you can use the delegate like this:

2. Get the map value more easily

The properties of some classes are not fixed, but sometimes more, sometimes less, that is, dynamic, such as:

There are children, some don t, so it s differentThe set of attributes possessed by the instance is different. Use this scenarioIt is appropriate to store attributes.

The above code can be simplified with delegation:

The fetching is delegated to a map object. The magic is that you don t even need to specifyYou can get the value of the name attribute from the map correctly. This is because the Kotlin standard library has already defined MapwithExtension function. The attribute name will automatically be applied to the map key.

summary

1. Kotlin delegation is divided into class delegation and attribute delegation . KeywordsTo commission.
2. Class delegation can use a concise syntax to delegate the implementation of a class to another object to reduce template code.
3. Property delegation can delegate access to properties to another object to reduce template code and hide access details.
4. There are three ways to implement property delegation , namely extension method and implementation
   ReadWriteProperty
   Interface, overloaded operator.

Recommended reading