DEV Community

Ahmed Moussa
Ahmed Moussa

Posted on

Kotlin Primary Constructors vs. Java Constructors: A Construction Conundrum (Solved with Kotlin's Elegance!)

#kotlin #java

Kotlin vs Java

Imagine you're building a house. In Java, you might have to lay each brick individually, meticulously placing each one in its proper position. But in Kotlin, you have a magic wand that can conjure up the entire foundation with a single incantation! 🪄 That's the power of Kotlin's primary constructors. They streamline class creation, making your code cleaner and more concise. 🧱

Java: The Brick-by-Brick Approach

In Java, constructors are special methods used to initialize objects. You can have multiple constructors with different parameters, but they can sometimes lead to repetitive code and boilerplate. It's like having to write separate blueprints for every possible variation of your house! 🏡

// Java
public class House {
    private int windows;
    private int doors;

    public House() {
        this.windows = 5;
        this.doors = 2;
    }

    public House(int windows, int doors) {
        this.windows = windows;
        this.doors = doors;
    }
}
Enter fullscreen mode Exit fullscreen mode

Kotlin: The Foundation-Laying Wizard

Kotlin introduces the concept of primary constructors, which are declared directly in the class header. This eliminates the need for separate constructor methods and reduces boilerplate significantly. It's like having a master architect who can design the entire foundation with a single stroke of their pen! ✍️

// Kotlin
class House(val windows: Int = 5, val doors: Int = 2)
Enter fullscreen mode Exit fullscreen mode

That's it! With this single line, you've defined a class with two properties and a default constructor that initializes them. You can even specify default values for the parameters, making your code even more flexible. It's like having a house that comes pre-furnished with all the essentials! 🛋️

Why Primary Constructors Are So Powerful

Kotlin's primary constructors offer several advantages:

  • Conciseness: They eliminate the need for separate constructor methods, reducing code verbosity.
  • Readability: Declaring properties and their initialization directly in the class header improves code clarity.
  • Flexibility: You can use default parameters to create flexible constructors that adapt to different use cases.
  • Immutability: By using val for your properties in the primary constructor, you can create immutable classes with ease.

Java's Counterpart: Constructor Overloading (The Manual Approach)

In Java, you can achieve similar flexibility by using constructor overloading, where you define multiple constructors with different parameters. However, this can lead to code duplication and make your class less concise. It's like having to build multiple foundations for the same house, just with slight variations! 🏗️

// Java
public class House {
    private int windows;
    private int doors;

    public House() {
        this.windows = 5;
        this.doors = 2;
    }

    public House(int windows, int doors) {
        this.windows = windows;
        this.doors = doors;
    }
}
Enter fullscreen mode Exit fullscreen mode

In Conclusion (The Housewarming Party)

Kotlin's primary constructors provide a more elegant and efficient way to initialize classes. They reduce boilerplate, improve readability, and offer greater flexibility. So, if you're ready to trade in your Java blueprints for a Kotlin magic wand, embrace the power of primary constructors! ✨

P.S. If you're a Java developer still building your classes brick by brick, don't worry. You can still achieve similar functionality with constructor overloading. It might take a bit more effort, but you'll get there eventually! 😉

Top comments (2)

Collapse
 
khmarbaise profile image
Karl Heinz Marbaise •

I would suggest to use records in Java:

public record House (int windows, int doors) {}
Enter fullscreen mode Exit fullscreen mode

Yes default parameters do not exist in Java... If you like to have a default creation...

public record House (int windows, int doors) {
  public static House defaultHouse() {
    return new House(5, 2);
  }
}
Enter fullscreen mode Exit fullscreen mode

But the question is really: Do you need multiple defaultHouses with different numbers of Windows/Doors?

Collapse
 
hamada147 profile image
Ahmed Moussa •

I do apologize for the late reply. I just saw your comment.

In the example above, we don't 😅

records definitely offer a more concise way to define classes in Java, similar to Kotlin's primary constructors. You're absolutely right that using a record like public record House(int windows, int doors) {} achieves a similar level of brevity.

However, Kotlin's primary constructors still offer some extra flexibility, particularly with default parameters. This allows for easy creation of objects with predefined values. For instance, consider these Kotlin examples:

// Kotlin
fun sendNotification(
    message: String, 
    priority: Int = 3, 
    sound: String = "default"
) { 
    // ... code to send a notification with the given properties ... 
}

fun createButton(
    text: String, 
    width: Int = 100, 
    height: Int = 50, 
    backgroundColor: String = "blue"
) { 
    // ... code to create a button with the given properties ...
}
Enter fullscreen mode Exit fullscreen mode

In these cases, you can easily create notifications or buttons with default settings while still having the option to customize them when needed. While you can achieve this in Java with static factory methods, it requires a bit more code.

Ultimately, both approaches have their merits. Java records are a great step towards more concise code in Java, and Kotlin's primary constructors provide a slightly more streamlined approach to class definition and initialization.

Read next

mcadariu profile image

Hierarchical data with PostgreSQL and Spring Data JPA

Mircea Cadariu -

sota_333ad4b72095606ab40c profile image

Observer Pattern

Sota -

jholsch profile image

Mapping inheritance hierarchies with MapStruct

Jens -

mostafa_ profile image

Building a Rotated Sorted Array Search in Java: Understanding Pivot and Binary Search

Mostafa Shariare -