Creating instances without new keyword in Kotlin - Mechanics & Internals

Overview - Creating instances without new keyword

What is it?

In Kotlin, you create objects (instances) of classes without using the 'new' keyword. Unlike some languages like Java or C++, Kotlin simplifies object creation by calling the class name directly as a function. This makes the code cleaner and easier to read, especially for beginners.

Why it matters

Removing the 'new' keyword reduces clutter and makes Kotlin code more concise and expressive. Without this feature, Kotlin would look more like Java, making it harder to learn and write quickly. It helps developers focus on what they want to create rather than how to create it.

Where it fits

Before learning this, you should understand what classes and objects are in programming. After this, you can explore advanced object creation patterns like factory methods, data classes, and dependency injection in Kotlin.

Mental Model

Core Idea

In Kotlin, creating an instance is like calling a function named after the class, so you don’t need the 'new' keyword.

Think of it like...

Imagine ordering a coffee by just saying the coffee name aloud instead of saying 'Please make me a new coffee.' Kotlin lets you just say the class name to get a new object.

┌───────────────┐
│   ClassName   │
└──────┬────────┘
       │
       ▼
  ClassName()  ← call like a function to create an instance
       │
       ▼
  New Object Created

Build-Up - 7 Steps

1

Foundation

Understanding Classes and Objects

Concept: Learn what classes and objects are in programming.

A class is like a blueprint for creating objects. An object is an actual thing made from that blueprint. For example, a 'Car' class describes what a car is, and an object is a specific car you can use.

Result

You understand that classes define structure and objects are instances of those classes.

Knowing the difference between a class and an object is essential before creating instances.

2

Foundation

Object Creation in Java vs Kotlin

Concept: Compare how objects are created in Java and Kotlin.

In Java, you write 'new Car()' to create a car object. In Kotlin, you just write 'Car()' without 'new'. This is because Kotlin treats class names like functions that create objects.

Result

You see that Kotlin simplifies object creation by removing the 'new' keyword.

Understanding this difference helps you write cleaner Kotlin code and avoid confusion when switching languages.

3

Intermediate

Calling Class Constructors Directly

🤔Before reading on: Do you think Kotlin classes behave like functions when creating instances? Commit to your answer.

Concept: Kotlin allows calling the constructor of a class directly using the class name as a function.

When you write 'Car()', Kotlin calls the constructor of the 'Car' class and returns a new object. This works for all classes, including those with parameters like 'Car(color: String)'.

Result

You can create objects by simply calling the class name with parentheses and arguments if needed.

Recognizing that class names act like functions for object creation clarifies Kotlin’s concise syntax.

4

Intermediate

Using Data Classes for Simple Instances

Concept: Data classes in Kotlin automatically provide constructors and useful methods.

A data class like 'data class Person(val name: String, val age: Int)' lets you create instances with 'Person("Alice", 30)'. This is concise and automatically gives you functions like 'toString()' and 'equals()'.

Result

You can quickly create and use objects with minimal code.

Knowing data classes helps you write less boilerplate and focus on your data.

5

Intermediate

Object Expressions and Declarations

Concept: Kotlin lets you create anonymous objects without naming a class.

You can write 'val obj = object { val x = 5 }' to create an instance without a class name. This is useful for quick, one-off objects.

Result

You can create instances without defining a full class.

Understanding this expands your ability to create objects flexibly.

6

Advanced

Factory Functions as Alternative Creators

🤔Before reading on: Do you think factory functions replace constructors or just add options? Commit to your answer.

Concept: Factory functions are regular functions that create and return instances, offering more control than constructors.

Instead of calling 'Car()', you might write 'fun createCar() = Car()'. This lets you add logic before creating the object, like caching or choosing subclasses.

Result

You gain flexibility in how and when objects are created.

Knowing factory functions helps you design better, more maintainable code.

7

Expert

Behind the Scenes: No 'new' Keyword in Bytecode

🤔Before reading on: Do you think Kotlin’s lack of 'new' means it doesn’t use it internally? Commit to your answer.

Concept: Although Kotlin code omits 'new', the compiled bytecode still uses it because the JVM requires it.

Kotlin compiler translates 'Car()' into Java bytecode that calls 'new Car()' under the hood. The 'new' keyword is just hidden from the programmer for simplicity.

Result

You understand that Kotlin’s syntax is a cleaner layer over JVM mechanics.

Knowing this prevents confusion about performance or behavior differences between Kotlin and Java.

Under the Hood

Kotlin compiles to JVM bytecode where object creation requires the 'new' instruction. The Kotlin compiler hides this by letting you call the class name like a function, which it translates into a 'new' call in bytecode. This means Kotlin syntax is simpler but still uses the same underlying process as Java.

Why designed this way?

Kotlin was designed to be more concise and readable than Java. Removing the 'new' keyword reduces boilerplate and makes code look cleaner. The JVM requires 'new' for object creation, so Kotlin hides it rather than removing it, balancing simplicity with compatibility.

┌───────────────┐       Kotlin source code
│   Car()       │  ──────▶ Calls constructor
└──────┬────────┘
       │
       ▼
┌───────────────┐       Kotlin compiler
│  bytecode     │  ──────▶ Inserts JVM 'new' instruction
└──────┬────────┘
       │
       ▼
┌───────────────┐       JVM runtime
│  new Car()    │  ──────▶ Creates object in memory
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does Kotlin never use the 'new' keyword anywhere? Commit to yes or no.

Common Belief: Kotlin completely removes the 'new' keyword from object creation, so it is never used.

Reality: Kotlin hides 'new' in its syntax, but the compiled bytecode still uses 'new' because the JVM requires it.

Why it matters: Thinking 'new' is gone can confuse learners about performance and compatibility with Java.

Quick: Can you create instances without parentheses in Kotlin? Commit to yes or no.

Common Belief: You can create an instance by just writing the class name without parentheses.

Reality: You must include parentheses to call the constructor, even if it has no parameters, like 'Car()'.

Why it matters: Omitting parentheses causes syntax errors and confusion about how constructors work.

Quick: Are factory functions the same as constructors? Commit to yes or no.

Common Belief: Factory functions are just another name for constructors and behave identically.

Reality: Factory functions are separate functions that create objects and can include extra logic beyond constructors.

Why it matters: Confusing these limits understanding of flexible object creation patterns.

Quick: Does Kotlin’s object expression create a named class? Commit to yes or no.

Common Belief: Object expressions create named classes that you can reuse elsewhere.

Reality: Object expressions create anonymous classes used only at the point of declaration.

Why it matters: Misunderstanding this leads to incorrect assumptions about object reuse and code structure.

Expert Zone

1

Kotlin’s omission of 'new' improves readability but does not affect runtime performance because the JVM still uses 'new'.

2

Factory functions can return subclasses or cached instances, offering more flexibility than constructors.

3

Object expressions create anonymous classes that can implement interfaces or extend classes on the fly, useful for quick custom behavior.

When NOT to use

Avoid relying solely on direct constructor calls when you need complex creation logic, caching, or polymorphic instances. Use factory functions or dependency injection frameworks instead.

Production Patterns

In production Kotlin code, factory functions and dependency injection are common for managing object creation. Data classes are widely used for simple data holders, and object expressions are used for quick listeners or callbacks.

Connections

Factory Design Pattern

Building-on

Understanding Kotlin’s simple instance creation helps grasp how factory patterns add flexibility by controlling object creation beyond constructors.

Java Bytecode and JVM Internals

Underlying mechanism

Knowing Kotlin compiles to JVM bytecode that uses 'new' clarifies how high-level syntax maps to low-level operations.

Natural Language Commands

Similar pattern

Just like giving a direct command without extra words is clearer and faster in speech, Kotlin’s syntax removes unnecessary keywords to make code more natural and concise.

Common Pitfalls

#1 Trying to create an instance without parentheses.

Wrong approach:

val car = Car

Correct approach:

val car = Car()

Root cause:

Misunderstanding that calling a constructor requires parentheses even if there are no parameters.

#2 Assuming Kotlin’s lack of 'new' means it creates objects differently at runtime.

Wrong approach:

Thinking Kotlin objects are created without JVM 'new' instruction, leading to incorrect performance assumptions.

Correct approach:

Recognizing Kotlin compiles to JVM bytecode that uses 'new' internally, so runtime behavior matches Java.

Root cause:

Confusing syntax sugar with runtime implementation.

#3 Using object expressions when a named class is needed.

Wrong approach:

val obj = object { fun greet() = "Hi" }
// Trying to reuse obj’s class elsewhere

Correct approach:

class Greeter { fun greet() = "Hi" }
val obj = Greeter()

Root cause:

Not realizing object expressions create anonymous, one-time-use classes.

Key Takeaways

Kotlin lets you create instances by calling the class name like a function, without the 'new' keyword.

This syntax is simpler and cleaner but compiles down to JVM bytecode that still uses 'new' internally.

You must always include parentheses when calling constructors, even if there are no parameters.

Factory functions and object expressions provide flexible alternatives for creating instances beyond direct constructor calls.

Understanding these concepts helps write clearer, more idiomatic Kotlin code and bridges knowledge between Kotlin and Java.