Kotlin provides the ability to extend a class or an interface with new functionality without having to inherit from the class or use design patterns such as Decorator. This is done via special declarations called extensions.
For example, you can write new functions for a class or an interface from a third-party library that you can't modify. Such functions can be called in the usual way, as if they were methods of the original class. This mechanism is called an extension function. There are also extension properties that let you define new properties for existing classes.
To declare an extension function, prefix its name with a receiver type, which refers to the type being extended. The following adds a
swap function to
this keyword inside an extension function corresponds to the receiver object (the one that is passed before the dot). Now, you can call such a function on any
This function makes sense for any
MutableList<T>, and you can make it generic:
You need to declare the generic type parameter before the function name to make it available in the receiver type expression. For more information about generics, see generic functions.
Extensions are resolved statically
Extensions do not actually modify the classes they extend. By defining an extension, you are not inserting new members into a class, only making new functions callable with the dot-notation on variables of this type.
Extension functions are dispatched statically, which means they are not virtual by receiver type. An extension function being called is determined by the type of the expression on which the function is invoked, not by the type of the result from evaluating that expression at runtime. For example:
This example prints Shape, because the extension function called depends only on the declared type of the parameter
s, which is the
If a class has a member function, and an extension function is defined which has the same receiver type, the same name, and is applicable to given arguments, the member always wins. For example:
This code prints Class method.
However, it's perfectly OK for extension functions to overload member functions that have the same name but a different signature:
Note that extensions can be defined with a nullable receiver type. These extensions can be called on an object variable even if its value is null, and they can check for
this == null inside the body.
This way, you can call
toString() in Kotlin without checking for
null, as the check happens inside the extension function:
Kotlin supports extension properties much like it supports functions:
Companion object extensions
If a class has a companion object defined, you can also define extension functions and properties for the companion object. Just like regular members of the companion object, they can be called using only the class name as the qualifier:
Scope of extensions
In most cases, you define extensions on the top level, directly under packages:
To use an extension outside its declaring package, import it at the call site:
See Imports for more information.
Declaring extensions as members
You can declare extensions for one class inside another class. Inside such an extension, there are multiple implicit receivers - objects whose members can be accessed without a qualifier. An instance of a class in which the extension is declared is called a dispatch receiver, and an instance of the receiver type of the extension method is called an extension receiver.
In the event of a name conflict between the members of a dispatch receiver and an extension receiver, the extension receiver takes precedence. To refer to the member of the dispatch receiver, you can use the qualified
Extensions declared as members can be declared as
open and overridden in subclasses. This means that the dispatch of such functions is virtual with regard to the dispatch receiver type, but static with regard to the extension receiver type.
Note on visibility
Extensions utilize the same visibility modifiers as regular functions declared in the same scope would. For example:
An extension declared at the top level of a file has access to the other
privatetop-level declarations in the same file.
If an extension is declared outside its receiver type, it cannot access the receiver's