Code Smell 13 - Empty Constructors

Non-parameterized constructors are a code smell of an invalid object that will dangerously mutate. Incomplete objects cause lots of issues.

TL;DR: Pass the essence to all your objects so they will not need to mutate.

Problems 😔

Mutability
Incomplete objects
Concurrency inconsistencies between creation and essence setting.
Setters

Solutions 😃

Pass the object's essence on creation
Create objects with their immutable essence.

Refactorings ⚙️

https://hackernoon.com/refactoring-remove-setters-codesmell?embedable=true

https://hackernoon.com/refactoring-016-building-with-the-essence?embedable=true

Examples 📚

Some persistence frameworks in statically-typed languages require an empty constructor.

Sample Code 📖

Wrong 🚫

class AirTicket {
   constructor() {     
  }
}

Right 👉

class AirTicket {
   constructor(origin,
                destination, 
                arline,
                departureTime,
                passenger) {     

  // ...
  }
}

Detection 🔍

Any linter can warn about this (possible) situation.

Exceptions 🛑

Stateless objects. Always a better solution than static class methods.

Tags 🏷️

Anemic Models

Level 🔋

[X] Beginner

Why the Bijection Is Important

In the MAPPER, objects correspond to real-world entities.

Real people aren't born nameless and formless, then gradually acquire attributes.

You don't meet someone who temporarily has no age or email address.

When you model a person, you should capture their essential attributes at birth, just like reality.

Breaking this bijection by creating hollow objects forces you to represent impossible states.

Empty constructors create phantom and invalid objects that don't exist in your domain model, violating the mapping between your code and reality.

AI Generation 🤖

AI code generators frequently produce this smell because they often follow common ORM patterns.

When you prompt AI to "create a Person class," it typically generates empty constructors with getters and setters.

AI tools trained on legacy codebases inherit these patterns and propagate them unless you explicitly request immutable objects with required constructor parameters.

AI Detection 🧲

AI tools can detect and fix this smell when you provide clear instructions.

You need to specify that objects should be immutable with required constructor parameters.

Without explicit guidance, AI tools may not recognize empty constructors as problematic since they appear frequently in training data.

Try Them! 🛠

Remember: AI Assistants make lots of mistakes

Suggested Prompt: Create an immutable class with required information. Include constructor validation and no setters. Make all fields final and use constructor parameters only