Amol Pawar

Kotlin provides a concise way to reference a member of a class or an instance of a class without invoking it, called member reference. Member reference is a functional feature in Kotlin that allows you to pass a function reference as a parameter to another function, without actually invoking the function. It’s similar to method reference but works with properties and functions that are members of a class or an instance of a class.

In this article, we’ll explore how to use member reference in Kotlin, including syntax, examples, and use cases.

What is a Member Reference?

A member reference in Kotlin is a way to reference a member of a class or interface, such as a property or a method, without invoking it immediately. It is similar to a lambda expression, but instead of providing a block of code to execute, it provides a reference to a member of a class. Member references are useful when you want to pass a function or a property as an argument to another function or class constructor.

Kotlin provides two types of member references: property references and function references. Property references refer to properties of a class, while function references refer to methods of a class.

Property References

Property references allow you to reference a property of a class without invoking it immediately. You can create a property reference by prefixing the property name with the double colons (::) operator. For example, consider the following class:

class Person(val name: String, val age: Int)

To create a property reference for the name property, you can use the following syntax:

val getName = Person::name

In this example, the getName variable is a property reference to the name property of the Person class. You can use this property reference in many contexts, such as passing it as an argument to a function:

fun printName(getName: (Person) -> String, person: Person) {
    println(getName(person))
}

val person = Person("Amol Pawar", 20)
printName(Person::name, person)

In this example, the printName function takes a property reference to the name property of the Person class and a Person object. It then uses the property reference to print the name of the person.

Function References

Function references allow you to reference a method of a class without invoking it immediately. You can create a function reference by prefixing the method name with the double colons (::) operator. For example, consider the following class:

class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
}

To create a function reference for the add method, you can use the following syntax:

val calculator = Calculator()
val add = calculator::add

In this example, the add variable is a function reference to the add method of the Calculator class. You can use this function reference in many contexts, such as passing it as an argument to a function:

fun performOperation(operation: (Int, Int) -> Int, a: Int, b: Int) {
    val result = operation(a, b)
    println("Result: $result")
}

val calculator = Calculator()
performOperation(calculator::add, 5, 10)

In this example, the performOperation function takes a function reference to the add method of the Calculator class and two integer values. It then uses the function reference to perform the addition operation and print the result.

Member References with Bound Receivers

In some cases, you may want to use a member reference with a bound receiver. A bound receiver is an instance of a class that is associated with the member reference. To create a member reference with a bound receiver, you can use the following syntax:

val calculator = Calculator()
val add = calculator::add

In this example, the add variable is a function reference to the add method of the Calculator class, with a bound receiver of the calculator instance.

You can use a member reference with a bound receiver in many contexts, such as passing it as an argument to a function:

fun performOperation(operation: Calculator.(Int, Int) -> Int, calculator: Calculator, a: Int, b: Int) {
    val result = calculator.operation(a, b)
    println("Result: $result")
}

val calculator = Calculator()
performOperation(Calculator::add, calculator, 5, 10)

In this example, the performOperation function takes a function reference to the add method of the Calculator class, with a bound receiver of the Calculator class. It also takes a Calculator instance and two integer values. It then uses the function reference with the calculator instance to perform the addition operation and print the result.

Use Cases for Member Reference

Member reference can be used in many different contexts, such as passing functions as parameters to higher-order functions or creating a reference to a member function or property for later use. Here are some examples of how to use member reference in Kotlin.

1. Passing a member function as a parameter

One of the most common use cases for member reference is passing a member function as a parameter to a higher-order function. Higher-order functions are functions that take other functions as parameters or return functions as results. By passing a member function as a parameter, you can reuse the same functionality across different contexts.

class MyClass {
    fun myFunction(param: Int) {
        // function implementation
    }
}

fun higherOrderFunction(func: (Int) -> Unit) {
    // do something
}

fun main() {
    val myClassInstance = MyClass()
    higherOrderFunction(myClassInstance::myFunction)
}

In this example, we have a class called MyClass with a member function called myFunction. We then create an instance of MyClass and store it in the myClassInstance variable. Finally, we pass a reference to the myFunction function using member reference to the higherOrderFunction, which takes a function with a single Int parameter and returns nothing.

2. Creating a reference to a member function for later use

Another use case for member reference is creating a reference to a member function that can be invoked later. This can be useful if you want to invoke a member function on an instance of a class without actually calling the function immediately.

class MyClass {
    fun myFunction(param: Int) {
        // function implementation
    }
}

fun main() {
    val myClassInstance = MyClass()
    val functionReference = myClassInstance::myFunction
    // ...
    functionReference.invoke(42) // invoke the function later
}

In this example, we have a class called MyClass with a member function called myFunction. We then create an instance of MyClass and store it in the myClassInstance variable. Finally, we create a reference to the myFunction function using the double colon operator and store it in the functionReference variable. We can then use the invoke function to call the myFunction function on the myClassInstance object later.

3. Creating a reference to a member property for later use

In addition to member functions, you can also create a reference to a member property for later use. This can be useful if you want to access a member property on an instance of a class without actually accessing the property immediately.

class MyClass {
    var myProperty: String = ""
}

fun main() {
    val myClassInstance = MyClass()
    val propertyReference = myClassInstance::myProperty
    // ...
    propertyReference.set("softAai") // set the property later
    val value = propertyReference.get() // get the property later
}

In this example, we have a class called MyClass with a member property called myProperty. We then create an instance of MyClass and store it in the myClassInstance variable. Finally, we create a reference to the myProperty property using the double colon operator and store it in the propertyReference variable. We can then use the set and get functions to access the myProperty property on the myClassInstance object later.

4. Bound member reference

Bound member reference is a syntax for referencing a member function of a specific instance of a class. This is useful when you have a function that expects a specific instance of a class as a parameter.

class MyClass {
    fun myFunction(param: Int) {
        // function implementation
    }
}

fun main() {
    val myClassInstance = MyClass()
    val boundReference = myClassInstance::myFunction
    // ...
    boundReference(42) // call the function on myClassInstance
}

In this example, we have a class called MyClass with a member function called myFunction. We then create an instance of MyClass and store it in the myClassInstance variable. Finally, we create a bound reference to the myFunction function using the double colon operator and store it in the boundReference variable. We can then call the myFunction function on the myClassInstance object later by simply invoking the boundReference function and passing in the necessary parameters.

Member References and Lambdas

In Kotlin, lambda expressions and member references can be used interchangeably in certain situations. This is because a lambda expression that takes an object and calls one of its methods can be replaced with a reference to that method using the double colon operator. This makes the code more concise and readable.

For example, consider the following code:

val myList = listOf("abc", "opq", "xyz")

val lengthList = myList.map { str -> str.length }

In this code, we have a list of strings and we want to create a new list containing the lengths of each string in the original list. We achieve this using the map function and a lambda expression that takes a string and returns its length.

Now, consider the following code, which achieves the same thing but uses a member reference instead of a lambda expression:

val myList = listOf("abc", "opq", "xyz")

val lengthList = myList.map(String::length)

In this code, we use a member reference to reference the length function of the String class instead of the lambda expression. This is possible because the lambda expression only calls a single method on the object it receives, which is exactly what the member reference does.

Let’s take one more example, let’s say you have a class called Person with a method getName() that returns the person\’s name. You can define a lambda expression that calls this method as follows:

val p = Person("amol")
val getNameLambda: (Person) -> String = { person -> person.getName() }

Alternatively, you can define a callable reference (method reference) to the same method as follows:

val getNameRef: (Person) -> String = Person::getName

In this case, getNameRef is a callable reference to the getName() method of the Person class, and it has the same type as getNameLambda. You can use either getNameLambda or getNameRef interchangeably in contexts where a function or method of type (Person) -> String is expected.

This interchangeability between lambdas and member references can be useful in situations where you have a lambda expression that only calls a single method on an object, as it can make the code more concise and readable. However, it’s important to note that this interchangeability only works in these specific situations and there may be cases where a lambda expression or a member reference is more appropriate.

Conclusion

Kotlin member references provide a concise and readable way to reference a class’s properties or methods, without invoking them immediately. They are useful when you want to pass a function or a property as an argument to another function or class constructor. Kotlin provides two types of member references: property references and function references. Property references refer to properties of a class, while function references refer to methods of a class. You can also create member references with bound receivers, which allows you to associate a member reference with a specific instance of a class. With member references, Kotlin makes it easy to write concise and readable code that is easy to maintain and understand.

Kotlin’s object keyword can be used in a variety of situations, all of which revolve around defining a class and creating an instance of that class at the same time. In this blog post, we’ll explore the different ways in which the object keyword can be used in Kotlin.

The object keyword in Kotlin is a versatile feature that can be used in various situations. The primary idea behind using the object keyword is that it defines a class and creates an instance (or an object) of that class simultaneously. There are three main cases where the object keyword is used:

1. Object declaration is a way to define a singleton.
2. Companion objects can contain factory methods and other methods that are related to this class but don’t require a class instance to be called. Their members can be accessed via class name.
3. Object expression is used instead of Java’s anonymous inner class.

Now we’ll discuss these Kotlin features in detail.

Object Keyword declarations: singletons made easy

This is a way to define a singleton in Kotlin. In Java, this is typically implemented using the Singleton pattern, where a class has a private constructor and a static field holding the only existing instance of the class. In Kotlin, however, the object declaration feature provides first-class language support for defining singletons. An object declaration combines a class declaration and a declaration of a single instance of that class.

For instance, an object declaration can be used to represent the payroll of an organization, where multiple payrolls are unlikely:

object Payroll {
    val allEmployees = arrayListOf<Person>()
    fun calculateSalary() {
        for (person in allEmployees) {
            ...
        }
    }
}

Object declarations are introduced with the object keyword. They can contain declarations of properties, methods, initializer blocks, and more. However, constructors (either primary or secondary) are not allowed in object declarations. Unlike instances of regular classes, object declarations are created immediately at the point of definition, not through constructor calls from other places in the code. Therefore, defining a constructor for an object declaration doesn’t make sense.

Inheriting from Classes and Interfaces

Object declarations can inherit from classes and interfaces. This is often useful when you need to implement an interface, but your implementation doesn’t contain any state. For instance, let’s take the java.util.Comparator interface. A Comparator implementation receives two objects and returns an integer indicating which of the objects is greater. Comparators almost never store any data, so you usually need just a single Comparator instance for a particular way of comparing objects. That’s a perfect use case for an object declaration:

object CaseInsensitiveFileComparator : Comparator<File> {
    override fun compare(file1: File, file2: File): Int {
        return file1.path.compareTo(file2.path, ignoreCase = true)
    }
}

println(CaseInsensitiveFileComparator.compare(File("/User"), File("/user")))  // output is 0

Declaring Objects in a Class

You can also declare objects in a class. Such objects also have just a single instance; they don’t have a separate instance per instance of the containing class. For example, it’s logical to place a comparator:

data class Person(val name: String) {
    object NameComparator : Comparator<Person> {
        override fun compare(p1: Person, p2: Person): Int =
            p1.name.compareTo(p2.name)
    }
}


val persons = listOf(Person("Boby"), Person("Abhi"))
println(persons.sortedWith(Person.NameComparator))

// output is [Person(name=Abhi), Person(name=Boby)]

Using Kotlin Objects from Java

An object declaration in Kotlin is compiled as a class with a static field holding its single instance, which is always named INSTANCE. To use a Kotlin object from Java code, you access the static INSTANCE field.

// Java
CaseInsensitiveFileComparator.INSTANCE.compare(file1, file2);

here the INSTANCE field has the type CaseInsensitiveFileComparator.

Companion objects: a place for factory methods and static members

Kotlin does not have a static keyword like Java, so it uses different constructs to replace it.

One of the constructs that Kotlin uses to replace static members is package-level functions, which can replace Java’s static methods in many situations. For example, the following Java code:

public class Utils {
    public static int add(int a, int b) {
        return a + b;
    }
}

can be replaced in Kotlin with a package-level function like this:

package mypackage

fun add(a: Int, b: Int): Int {
    return a + b
}

In most cases, it’s recommended to use package-level functions. However, top-level functions can’t access private members of a class. If you need to write a function that can be called without having a class instance but needs access to the internals of a class, you can write it as a member of an object declaration inside that class. An example of such a function would be a factory method.

class User private constructor(val nickname: String) {
    companion object {
        fun newSubscribingUser(email: String) = User(email.substringBefore('@'))
        fun newFacebookUser(accountId: Int) = User(getFacebookName(accountId))
    }
}

In this example, the companion object is used to define two factory methods that can be called on the User class without creating an instance of it. The private constructor of the User class can be called from within the companion object, making it an ideal candidate to implement the Factory pattern.

Another construct that Kotlin uses to replace static members is object declarations. An object declaration creates a singleton instance of a class and can replace static fields and methods in Java. For example, the following Java code:

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

can be replaced in Kotlin with an object declaration like this:

object Singleton {
    fun getInstance() = this
}

In this example, the object declaration Singleton creates a singleton instance of the class and defines a method getInstance() that returns the instance.

One of the objects defined in a class can be marked with a special keyword: companion. If you do that, you gain the ability to access the methods and properties of that object directly through the name of the containing class, without specifying the name of the object explicitly. The resulting syntax looks exactly like static method invocation in Java.

Here’s an example showing the syntax:

class MyClass {
    companion object {
        fun myMethod() {
            println("Hello from myMethod")
        }
    }
}

// Call myMethod() on the class
MyClass.myMethod()

If you need to define functions that can be called on the class itself, like companion-object methods or Java static methods, you can define extension functions on the companion object. For example, imagine that you have a companion object defined like this:

class MyClass {
    companion object {
        fun myMethod() {
            println("Hello from myMethod")
        }
    }
}

You can define an extension function on the companion object like this:

fun MyClass.Companion.myOtherMethod() {
    println("Hello from myOtherMethod")
}

You can then call myOtherMethod() on the class like this:

MyClass.myOtherMethod()

So companion objects can contain factory methods and other methods related to the class, but they don’t require a class instance to be called. The members of companion objects can be accessed via the class name. Companion objects are declared inside a class using the companion object keyword.

Object expressions: anonymous inner classes rephrased

In Kotlin, the object keyword can be used to declare anonymous objects that replace Java\’s use of anonymous inner classes. In this example, let\’s see how to convert a typical Java anonymous inner class—an event listener—to Kotlin using anonymous objects:

window.addMouseListener(
    object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            // ...
        }
        override fun mouseEntered(e: MouseEvent) {
            // ...
        }
    }
)

The syntax for anonymous objects is similar to object declarations, but the name of the object is omitted. The object expression declares a class and creates an instance of that class, without assigning a name to either the class or the instance. Typically, neither is necessary because the object will be used as a parameter in a function call. However, if necessary, the object can be stored in a variable:

val listener = object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { ... }
    override fun mouseEntered(e: MouseEvent) { ... }
}

Unlike Java anonymous inner classes that can only extend one class or implement one interface, a Kotlin anonymous object can implement multiple interfaces or no interfaces.

It’s important to note that anonymous objects are not singletons like object declarations. Every time an object expression is executed, a new instance of the object is created.

Anonymous objects are particularly useful when you need to override multiple methods in your anonymous object. However, if you only need to implement a single-method interface (such as Runnable), Kotlin has support for SAM conversion. SAM conversion allows you to convert a function literal to an implementation of an interface with a single abstract method. Therefore, you can implement a single-method interface with a function literal instead of an anonymous object.

The object keyword in Kotlin has several advantages and disadvantages.

Advantages:

1. Singleton implementation: It allows you to define a Singleton pattern easily and concisely. You can declare a class and its instance at the same time, without the need for a separate class definition or initialization.
2. Anonymous objects: It enables you to create anonymous objects, which can be used as an alternative to anonymous inner classes in Java. Anonymous objects can implement multiple interfaces and can override methods on the spot, without creating a separate class.
3. Clean code: It can make your code cleaner and more concise, as it eliminates the need for boilerplate code that is common in Java.

Disadvantages:

1. Overuse: Using the object keyword extensively in your code can lead to overuse and abuse, making it harder to read and maintain.
2. Limited functionality: It has limited functionality when compared to a full-fledged class definition. It cannot be inherited or extended, and it cannot have constructors, which limits its usefulness in certain scenarios.
3. Lack of thread safety: It is not thread-safe by default, which can cause issues in multi-threaded applications. You need to add synchronization code to ensure thread safety.

Overall, the object keyword is a powerful feature in Kotlin that can make your code more concise and eliminate boilerplate code. However, it should be used judiciously to avoid overuse and to ensure thread safety when necessary.

Jetpack Components is a collection of libraries that provide developers with ready-made solutions to common problems encountered when building Android apps. These libraries are designed to work together seamlessly, allowing developers to quickly and easily build high-quality apps. In this article, we will take a closer look at the different Jetpack Components and how they can be used to build better Android apps.

Jetpack Architecture Components

The Architecture Components is a set of libraries that help developers build robust, testable, and maintainable apps. It includes the following components:

ViewModel

The ViewModel component helps manage the UI-related data in a lifecycle-conscious way. It allows data to survive configuration changes such as screen rotations, making it easier to handle data in your app.

LiveData

LiveData is a data holder class that allows you to observe changes in data and update the UI accordingly. It is lifecycle-aware, which means it automatically updates the UI when the app goes into the foreground and stops updates when the app goes into the background.

Room

Room is a SQLite database library that provides an easy-to-use abstraction layer over SQLite. It provides compile-time checks for SQL queries and allows you to easily map Java objects to database tables.

Paging

The Paging library helps you load large data sets efficiently and gradually. It loads data in chunks, making it easier to handle large data sets without consuming too much memory.

WorkManager

WorkManager is a library that makes it easy to schedule deferrable, asynchronous tasks that are expected to run even if the app is closed or the device is restarted.

Navigation

The Navigation component helps you implement navigation between screens in your app. It provides a consistent and predictable way to navigate between destinations in your app.

UI Components

The UI Components are a set of libraries that help you build beautiful and functional user interfaces. It includes the following components:

Compose UI Toolkit

Compose is a modern UI toolkit that enables developers to build beautiful and responsive user interfaces using a declarative programming model. It simplifies the UI development process by allowing developers to express their UI components in code, using a Kotlin-based DSL.

RecyclerView

RecyclerView is a flexible and efficient way to display large data sets. It allows you to customize the way items are displayed and provides built-in support for animations.

CardView

CardView is a customizable view that displays information in a card-like format. It provides a consistent and attractive way to display information in your app.

ConstraintLayout

ConstraintLayout is a flexible and powerful layout manager that allows you to create complex layouts with a flat view hierarchy. It provides a variety of constraints that allow you to create responsive and adaptive layouts.

ViewPager2

ViewPager2 is an updated version of the ViewPager library that provides better performance and improved API consistency. It allows you to swipe between screens in your app, making it a popular choice for building onboarding experiences.

Material Components

Material Components is a collection of UI components that implement Google’s Material Design guidelines. It provides a consistent look and feel across different Android devices and versions.

Behavior Components

The Behavior Components are a set of libraries that help you implement common app behaviors. It includes the following components:

Download Manager

The Download Manager component makes it easy to download files in your app. It provides a powerful API that allows you to manage downloads, monitor progress, and handle errors.

Media

The Media component provides a set of APIs for working with media files in your app. It allows you to play, record, and manage media files with ease.

Notifications

The Notifications component provides a set of APIs for creating and managing notifications in your app. It allows you to create rich, interactive notifications that engage users.

Sharing

The Sharing component provides a set of APIs for sharing content from your app. It allows you to share text, images, and other types of content with other apps and services.

Foundation Components

The Foundation library provides a set of core utility classes and functions that are used across the other Jetpack libraries. It includes the following components:

AppCompat

AppCompat is a library that provides backwards compatibility for newer Android features on older Android versions. It allows developers to use the latest features of Android while still supporting older versions of the platform.

Android KTX

Android KTX is a set of Kotlin extensions that make writing Android code easier and more concise. It provides extension functions for many of the Android framework classes, making them easier to use and reducing the amount of boilerplate code needed.

Multidex

Multidex is a library that provides support for apps that have a large number of methods, which can cause the 64K method limit to be exceeded. It allows developers to build apps that use more than 64K methods by splitting the app’s classes into multiple dex files.

Test

The Test library provides a set of testing utilities for Android apps, including JUnit extensions, Espresso UI testing, and Mockito mocking framework.

Core

The Core library provides a set of classes and functions that are used across many of the other Jetpack libraries, including utilities for handling lifecycle events, threading, and resource management.

Conclusion

The Jetpack Components are a powerful set of libraries and tools that enable developers to build high-quality Android apps quickly and efficiently. By using these components, developers can focus on building the core features of their apps while relying on well-tested and well-documented solutions for common problems. The Compose UI toolkit takes this a step further, simplifying the UI development process by allowing developers to express their UI components in code. Together, these components make Jetpack a valuable resource for any Android developer.

Kotlin is a powerful and modern programming language that has been gaining popularity in recent years due to its concise and expressive syntax, strong type system, and seamless interoperability with Java. One of the most important features of Kotlin that sets it apart from other languages is its support for constructors, which play a crucial role in creating objects and setting up their initial state.

Constructors in Kotlin are not just a simple way to create objects; they offer a wide range of options and flexibility to customize the object initialization process. In this article, we’ll take an in-depth look at Kotlin constructors and explore the different ways they can be used to create and configure objects, along with some best practices and examples. Whether you’re new to Kotlin or a seasoned developer, this article will provide you with a solid understanding of Kotlin constructors and how to use them to create powerful, flexible classes.

Constructors?

In object-oriented programming, a constructor is a special method that is used to initialize an object’s state when it is first created. A constructor is invoked automatically when an object is created, and it sets the initial values for the object’s properties and executes any initialization code.

Kotlin provides several types of constructors that can be used to create objects. Each constructor has a specific syntax and purpose, and we will discuss each of them in detail below.

Default Constructor

In Kotlin, a default constructor is generated automatically if no constructor is defined explicitly. This default constructor is used to create an instance of the class and initializes the class properties with their default values.

Here is an example of a class with a default constructor:

class Person {
    var name: String = ""
    var age: Int = 0
}

In this example, we have defined a class Person with two properties name and age. As we have not defined any constructor, a default constructor is generated automatically.

We can create an instance of this class by simply calling the constructor like this:

val person = Person()

The person object created using the default constructor will have the name property initialized with an empty string and the age property initialized with zero.

Primary Constructor

Kotlin provides two types of constructors for initializing objects: primary and secondary constructors.

The primary constructor is usually the main and concise way to initialize a class, and it is declared inside the class header in parentheses. It serves two purposes: specifying constructor parameters and defining properties that are initialized by those parameters.

Here’s an example of a class with a primary constructor:

class User(val nickname: String)

In this example, the block of code surrounded by parentheses is the primary constructor, and it has a single parameter named “nickname”. The “val” keyword before the parameter name declares the parameter as a read-only property.

You can also write the same code in a more explicit way using the “constructor” keyword and an initializer block:

class User constructor(_nickname: String) {
    val nickname: String
    
    init {
        nickname = _nickname
    }
}

In this example, the primary constructor takes a parameter named “_nickname” (with the underscore to distinguish it from the property name), and the “init” keyword introduces an initializer block that assigns the parameter value to the “nickname” property.

The primary constructor syntax is constrained, so if you need additional initialization logic, you can use initializer blocks to supplement it. You can declare multiple initializer blocks in one class if needed.

To elaborate, let’s take the example of a Person class, which has a primary constructor that takes two parameters – name and age. We want to add additional initialization logic to the class, such as checking if the age is valid or not.

Here’s how we can do it using an initializer block:

class Person(val name: String, val age: Int) {
    init {
        if (age < 0) {
            throw IllegalArgumentException("Age cannot be negative")
        }
    }
}

In this example, we use an initializer block to add additional initialization logic to the class. The initializer block is introduced with the init keyword, and the code inside it is executed when an instance of the class is created.

The initializer block checks if the age parameter is negative, and if so, throws an IllegalArgumentException with an appropriate error message.

Note that you can declare multiple initializer blocks in a class if needed. For example, suppose we want to initialize some properties based on the constructor parameters. We can add another initializer block to the class like this:

class Person(val name: String, val age: Int) {
    val isAdult: Boolean
    
    init {
        if (age < 0) {
            throw IllegalArgumentException("Age cannot be negative")
        }
        
        isAdult = age >= 18
    }
    
    init {
        println("Person object created with name: $name and age: $age")
    }
}

In this example, we have two initializer blocks. The first one initializes the isAdult property based on the age parameter. The second one simply prints a message to the console.

So you can use initializer blocks to add additional initialization logic to a class, such as checking parameter values, initializing properties based on constructor parameters, or performing other setup tasks. You can declare multiple initializer blocks in a class if needed.

What about “constructor” keyword?

In Kotlin, if the primary constructor has no annotations or visibility modifiers, the constructor keyword can be omitted, and the constructor parameters are placed directly after the class name in parentheses. Here’s an example:

class User(val nickname: String)

In this case, the constructor keyword is not used explicitly because there are no annotations or visibility modifiers.

However, if you need to add visibility modifiers, annotations, or other modifiers to the constructor, you need to declare it using the constructor keyword. For example:

class User private constructor(val nickname: String)

In this example, we use the private keyword to make the constructor private, and thus we need to use the constructor keyword to declare it explicitly.

The primary constructor can also include annotations, and other modifiers as needed:

class Person @Inject constructor(private val name: String, var age: Int) {
    // Class body
}

In this example, the primary constructor includes an @Inject annotation and a private visibility modifier for the name property.

So you can omit the constructor keyword in the primary constructor declaration if there are no modifiers or annotations. Otherwise, you need to use it to declare the constructor explicitly.

Default Parameter Values

Kotlin also allows us to provide default values for constructor parameters. This means that we can create an object without providing all the required arguments, as long as the missing arguments have default values.

class Person(val name: String, val age: Int = 0) {
  // additional methods and properties can be defined here
}

In this example, the Person class has a primary constructor with two parameters: name and age. However, the age parameter has a default value of 0, which means that we can create a Person object with just the name parameter:

val john = Person("John")

In this case, the john variable is assigned a new instance of the Person class with the name property set to “John” and the age property set to 0.

Super Class Initialization

If your class has a superclass, the primary constructor also needs to initialize the superclass. You can do so by providing the superclass constructor parameters after the superclass reference in the base class list.

open class User(val nickname: String) { ... }
class TwitterUser(nickname: String) : User(nickname) { ... }

If you don’t declare any constructors for a class, a default constructor that does nothing will be generated for you.

open class Button
// The default constructor without arguments is generated.

If you inherit the Button class and don’t provide any constructors, you have to explicitly invoke the constructor of the superclass.

class RadioButton: Button()

Here note the difference with interfaces: interfaces don’t have constructors, so if you implement an interface, you never put parentheses after its name in the supertype list.

Private Constructor

If you want to ensure that your class can’t be instantiated by other code, you have to make the constructor private. You can make the primary constructor private by adding the private keyword before the constructor keyword.

class Secretive private constructor() {}

Here the Secretive class has only a private constructor, the code outside of the class can’t instantiate it.

Secondary Constructor

In addition to the primary constructor, Kotlin allows you to declare secondary constructors. Secondary constructors are optional, and they are defined inside the class body, after the primary constructor and initialization blocks.

A secondary constructor is defined using the constructor keyword followed by parentheses that can contain optional parameters.

open class View {
    constructor(ctx: Context) {
        // some code
    }
    constructor(ctx: Context, attr: AttributeSet) {
        // some code
    }
}

Don’t declare multiple secondary constructors to overload and provide default values for arguments. Instead, specify default values directly

Unlike the primary constructor, the secondary constructor must call the primary constructor, directly or indirectly, using this keyword

class Person(val name: String, val age: Int) {
    constructor(name: String) : this(name, 0) // calls the primary constructor with age set to 0
}

Super Class Initialization

Here is an example that shows how to define a secondary constructor to initialize the superclass in a different way:

open class User(val nickname: String) {
    // primary constructor
}

class TwitterUser : User {
    constructor(email: String) : super(extractNicknameFromEmail(email)) {
        // secondary constructor
    }

    private fun extractNicknameFromEmail(email: String): String {
        // some code to extract the nickname from the email
        return "someNickname"
    }
}

In this example, the TwitterUser class has a secondary constructor that takes an email address as a parameter. The secondary constructor calls the primary constructor of the User class by passing a nickname value that is extracted from the email address.

Note that the secondary constructor is defined using the constructor keyword, followed by the email parameter. The constructor then calls the primary constructor of the superclass (User) using the super keyword with the extracted nickname value as the argument. Finally, the secondary constructor can perform additional initialization logic if needed.

super() or this()

In Kotlin, super() and this() are used to call constructors of the parent/super class and the current class respectively.

In a primary constructor, you can use this to reference another constructor in the same class and super to reference the constructor of the superclass.

open class View {
    constructor(ctx: Context) {
        // ...
    }
    constructor(ctx: Context, attrs: AttributeSet) {
        // ...
    }
}

class MyButton : View {
    constructor(ctx: Context)
        : this(ctx, MY_STYLE) {
        // ...
    }
    constructor(ctx: Context, attrs: AttributeSet)
        : super(ctx, attrs) {
        // ...
    }
    // ...
}

The super() is used to call the constructor of the immediate parent/super class of a derived class. It is typically used to initialize the properties or fields defined in the parent/super class. If the parent/super class has multiple constructors, you can choose which one to call by providing the appropriate arguments. For example:

open class Person(val name: String) {
    constructor(name: String, age: Int) : this(name) {
        // Initialize age property
    }
}

class Employee : Person {
    constructor(name: String, age: Int, id: Int) : super(name, age) {
        // Initialize id property
    }
}

In the above example, the Employee class has a secondary constructor that calls the primary constructor of its parent/super class Person with name and age arguments using super(name, age).

On the other hand, the this() function is used to call another constructor of the same class. It can be used to provide multiple constructors with different parameters. If you call another constructor with this(), it must be the first statement in the constructor. For example:

class Person(val name: String, val age: Int) {
    constructor(name: String) : this(name, 0) // calls the primary constructor with age set to 0
}

In this example, the Person class has a primary constructor that takes both name and age as parameters. It also has a secondary constructor that takes only the name parameter and calls the primary constructor with age set to 0 using the this() keyword. this()is useful when you have multiple constructors in a class and you want to avoid duplicating initialization logic.

Primary Constructor vs Secondary Constructor

1. Syntax: The primary constructor is defined as part of the class header, inside parentheses, while secondary constructors are defined inside the class body and are prefixed with the constructor keyword.
2. Purpose: The primary constructor is mainly used to initialize the class properties with values passed as parameters, while secondary constructors provide an additional way to create objects of a class with different initialization logic.
3. Constraints: The primary constructor has some constraints such as not allowing code blocks, while secondary constructors can have default parameter values and can contain code blocks.
4. Invocation: The primary constructor is always invoked implicitly when an object of the class is created, while secondary constructors can be invoked explicitly by calling them with the constructor keyword.
5. Number: A class can have only one primary constructor, while it can have multiple secondary constructors.
6. Initialization of superclass: The primary constructor can initialize the superclass by calling the superclass constructor in the class header, while the secondary constructor can initialize the superclass by calling the superclass constructor inside the constructor body with the super keyword.

Kotlin interfaces are a fundamental part of the language and are used extensively in many Kotlin projects. In this blog, we’ll cover all the important aspects of Kotlin interfaces, including their syntax, uses, and examples.

Kotlin Interfaces

In Kotlin, an interface is a type that defines a set of method signatures that a class can implement. An interface can contain abstract methods, default method implementations, and properties. Interfaces are used to define a contract that a class must follow in order to be considered an implementation of the interface.

Syntax

An interface in Kotlin is declared using the interface keyword, followed by the name of the interface and its body enclosed in curly braces. Here’s an example of a simple interface declaration:

interface MyInterface {
    fun doSomething()
}

In this example, the MyInterface interface contains a single method signature, doSomething(). This method is abstract, meaning that it does not have a method body and must be implemented by any class that implements the MyInterface interface.

Interfaces can also include default method implementations, which are method implementations that are provided in the interface itself. Here’s an example

interface MyInterface {
    fun doSomething()
    fun doSomethingElse() {
        println("Doing something else")
    }
}

In this example, the MyInterface interface contains two method signatures, doSomething() and doSomethingElse(). The doSomethingElse() method has a default implementation that simply prints a message to the console.

Kotlin interface properties

In Kotlin, interface properties can be declared using the same syntax as regular properties:

interface MyInterface {
    fun doSomething()
    fun doSomethingElse() {
        println("Doing something else")
    }
}

Here, property1 is a read-only property, and property2 is a mutable property.

In Java, interface properties are not directly supported. However, you can define getter and setter methods that behave like properties:

interface MyInterface {
    int getProperty1();
    void setProperty1(int value);
    String getProperty2();
    void setProperty2(String value);
}

Here, getProperty1() and getProperty2() are getter methods, and setProperty1(int value) and setProperty2(String value) are setter methods.

With Kotlin interface properties, you can provide default implementations for them as well:

interface MyInterface {
    val property1: Int
        get() = 42

    var property2: String
        get() = "default"
        set(value) {
            println("Setting property2 to $value")
        }
}

Here, property1 has a default value of 42, and property2 has a default value of “default”. The set() method of property2 is overridden to print a message whenever the property is set.

Extending vs Implementing

In Kotlin, both classes and interfaces play a crucial role in object-oriented programming. A class is a blueprint or a template for creating objects, whereas an interface is a collection of abstract methods and properties. An interface can be seen as a contract that a class has to fulfill by implementing all of its abstract methods and properties.

One of the key differences between a class and an interface is that a class can extend only one other class at a time, while an interface can extend any number of other interfaces. This means that an interface can inherit properties and methods from multiple other interfaces.

In Java, we have the extends and the implements keywords for extending a class and implementing interfaces. However, on Kotlin’s side, we don’t have these keywords. Kotlin uses the colon character “:” to indicate both inheritance (extend) and interfaces implementation.

For example, suppose we have two interfaces A and B, and we want to create a new interface C that extends both A and B. In Kotlin, we can achieve this using the following syntax:

interface A {
    fun foo()
}

interface B {
    fun bar()
}

interface C : A, B {
    fun baz()
}

Here, the interface C extends both A and B, and also declares its own method baz.

On the other hand, a class can extend one other class and implement any number of interfaces at the same time. This means that a class can inherit properties and methods from another class, as well as fulfill the contracts of multiple interfaces.

For example, suppose we have a class D that extends another class E and implements two interfaces F and G. In Kotlin, we can achieve this using the following syntax:

open class E {
    fun qux()
}

interface F {
    fun baz()
}

interface G {
    fun quux()
}

class D : E(), F, G {
    override fun baz() { /* implementation */ }
    override fun quux() { /* implementation */ }
}