Factory pattern with companion objects in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Factory pattern in Kotlin?

The Factory pattern is a way to create objects without exposing the creation logic to the client. It uses a method to return instances, making object creation flexible and centralized.

beginner

What is a companion object in Kotlin?

A companion object is a special object inside a class that allows you to define methods and properties tied to the class itself, similar to static members in other languages.

intermediate

How does the Factory pattern use companion objects in Kotlin?

In Kotlin, the Factory pattern often uses companion objects to hold factory methods. This lets you create instances by calling methods on the class itself, keeping creation logic inside the class.

intermediate

Example: What does this Kotlin code do?
<pre>class Car private constructor(val type: String) {
  companion object {
    fun createSedan() = Car("Sedan")
    fun createSUV() = Car("SUV")
  }
}</pre>

This code defines a Car class with a private constructor, so it can't be created directly. The companion object has factory methods createSedan() and createSUV() that create Car instances of specific types.

intermediate

Why use a private constructor with a companion object factory in Kotlin?

Using a private constructor prevents direct creation of objects. The companion object factory methods control how objects are made, ensuring consistent and safe creation.

What keyword makes a constructor private in Kotlin to support the Factory pattern?

A private

B protected

C internal

D public

The 'private' keyword restricts constructor access, so objects can only be created through factory methods.

Where are factory methods typically placed in Kotlin when using the Factory pattern?

A In interface declarations

B In separate utility classes

C Inside companion objects

D In the main function

Companion objects hold factory methods to create instances without exposing constructors.

What is the main benefit of using the Factory pattern with companion objects?

A Makes all properties mutable

B Automatically generates getters and setters

C Allows multiple inheritance

D Centralizes object creation logic

Factory pattern centralizes and controls how objects are created.

How do you call a factory method named createSedan in a companion object of class Car?

A new Car.createSedan()

B Car.createSedan()

C createSedan.Car()

D Car().createSedan()

Factory methods in companion objects are called on the class name directly.

What happens if the constructor is not private in a Factory pattern?

A Objects can be created directly, bypassing factory methods

B Factory methods won't work

C The class becomes abstract

D The compiler throws an error

Without a private constructor, clients can create objects directly, which may break the pattern.

Explain how the Factory pattern works with companion objects in Kotlin.

Think about how you hide the constructor and provide special methods to create objects.

Describe the benefits of using a private constructor with companion object factory methods.

Why would you want to stop people from making objects any way they want?