Pros and Cons of 3 Ways to Instantiate Objects: Telescope Pattern, JavaBeans, and Builder Pattern

Instantiating objects is an essential activity in object-oriented programming. There are various ways to achieve this, each with its characteristics, advantages, and disadvantages. In this post, we will explore three popular approaches: Telescope Pattern, JavaBeans, and Builder Pattern. Let’s analyze the pros and cons of each method so you can choose the best one for your needs.

---

1. Telescope Pattern

The Telescope Pattern uses overloaded constructors to create objects with different sets of attributes.

Example:

public class Product {
    private String name;
    private double price;
    private String category;

    public Product(String name) {
        this.name = name;
    }

    public Product(String name, double price) {
        this(name);
        this.price = price;
    }

    public Product(String name, double price, String category) {
        this(name, price);
        this.category = category;
    }
}

// Usage:
Product product1 = new Product("Laptop");
Product product2 = new Product("Laptop", 1500.0);
Product product3 = new Product("Laptop", 1500.0, "Electronics");

Pros:

• Simplicity: Quick to implement and intuitive for objects with few attributes.
• Immutability: Attributes can be final, ensuring immutable objects.

Cons:

• Poor scalability: For many attributes, the number of constructor combinations grows exponentially, making the code confusing and hard to maintain.
• Reduced readability: It can be difficult to understand the meaning of parameters just from the constructor call.

---

2. JavaBeans

JavaBeans use no-argument constructors combined with setter methods to configure attribute values.

Example:

public class Product {
    private String name;
    private double price;
    private String category;

    public Product() {}

    public void setName(String name) {
        this.name = name;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public void setCategory(String category) {
        this.category = category;
    }
}

// Usage:
Product product = new Product();
product.setName("Laptop");
product.setPrice(1500.0);
product.setCategory("Electronics");

Pros:

• Flexibility: Easy to construct objects with varied values without requiring multiple constructors.
• Readability: Each setter method clearly indicates which attribute is being set.

Cons:

• No immutability: Objects created using JavaBeans are generally mutable, which can lead to issues in concurrent applications.
• Fragmented validation: It’s hard to ensure that the object is in a valid state, as attributes can be set in any order.

---

3. Builder Pattern

The Builder Pattern is a flexible approach that uses a helper class (builder) to construct complex objects in a controlled and readable way.

Example:

public class Product {
    private final String name;
    private final double price;
    private final String category;

    private Product(Builder builder) {
        this.name = builder.name;
        this.price = builder.price;
        this.category = builder.category;
    }

    public static class Builder {
        private String name;
        private double price;
        private String category;

        public Builder(String name) {
            this.name = name;
        }

        public Builder price(double price) {
            this.price = price;
            return this;
        }

        public Builder category(String category) {
            this.category = category;
            return this;
        }

        public Product build() {
            return new Product(this);
        }
    }
}

// Usage:
Product product = new Product.Builder("Laptop")
                        .price(1500.0)
                        .category("Electronics")
                        .build();

Pros:

• Immutability: The final object is completely immutable.
• Readability: The creation code is clear and self-explanatory, even for complex objects.
• Integrated validation: Validations can be performed during object construction.

Cons:

• Initial overhead: Requires more code to implement, which can be excessive for simple objects.
• Additional class: Introducing a Builder class may seem overkill in small projects.

---

Conclusion

The best approach depends on your project’s context:

• Use Telescope Pattern if you’re dealing with simple objects that rarely change.
• Prefer JavaBeans when simplicity and flexibility are needed, but immutability is not a requirement.
• Opt for Builder Pattern for complex objects where readability, immutability, and validation are crucial.

Each pattern has its place, and understanding their strengths and limitations is key to writing clean and maintainable code. What’s your favorite pattern? Share your thoughts in the comments!

---

📍 Reference

• Design Patterns
• Effective Java

👋 Talk to me

• LinkedIn
• Github
• Portfolio