Kotlin: object vs class

In Kotlin, both object and class are used to define types. However, they serve different purposes and have distinct characteristics. Understanding the differences between object and class is important for writing clean and efficient code in Android development. In this article, we will delve into the features and use cases of object and class, providing examples along the way.

Classes

Let's start with classes, as they are fundamental building blocks in object-oriented programming. A class defines a blueprint for creating objects. It encapsulates properties and behaviors that an object of that class can possess. Here's an example of a simple class in Kotlin:

Copycopy code to clipboard
1class Person(val name: String) {
2    fun sayHello() {
3        println("Hello, my name is $name")
4    }
5}

In the above example, we define a Person class with a single property name and a method sayHello(). We can create multiple instances (objects) of this class, each with its own name value. For instance:

Copycopy code to clipboard
1val person1 = Person("Alice")
2val person2 = Person("Bob")
3
4person1.sayHello() // Output: Hello, my name is Alice
5person2.sayHello() // Output: Hello, my name is Bob

Classes provide the flexibility to instantiate multiple objects with individual state and behavior. They are suitable for scenarios where you want to create multiple instances of a type.

Objects

On the other hand, Kotlin's object is a singleton instance that is created implicitly. It represents a single unique object with its own properties and behavior. An object is useful when you need only one instance of a class throughout your application. Here's an example illustrating the usage of object:

Copycopy code to clipboard
1object Logger {
2    fun log(message: String) {
3        println("Logging: $message")
4    }
5}
6
7Logger.log("An important message") // Output: Logging: An important message

In the above code, we define an object named Logger with a single method log(). The Logger object can be accessed directly without creating an instance. This makes it easy to use shared resources or provide global utility functions.

Differences and Use Cases

To summarize, here are the key differences between object and class in Kotlin:

• A class allows multiple instances (objects) to be created, while an object represents a single unique instance.
• class objects can have stateful properties, whereas object instances cannot have constructor parameters.
• class objects are lazily initialized, meaning they are created only when needed, whereas object instances are created eagerly.
• class objects can implement interfaces and inherit from classes, but object instances cannot extend other classes (since they already have a superclass, Any).

When deciding whether to use a class or an object, consider the following guidelines:

• Use a class when you need multiple instances of a type with individual state and behavior.
• Use an object when you require a single instance that can be accessed globally or used for shared resources, such as logger instances, utility methods, or database connections.

Understanding the distinctions between object and class is crucial for writing well-structured and maintainable code in Kotlin.