Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Object Oriented Programming · Question Set
Design Patterns – Part 1 (Creational) interview questions for placements and exams.
Questions
12
Included in this set
Subject
Object Oriented Programming
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Object Oriented Programming.
Lazy initialization delays creation of an object until it is actually required. This is a common approach in creational patterns to optimize performance and resource usage, especially when object creation is expensive or the object may not be used.
For complete preparation, combine this set with full subject-wise practice for Object Oriented Programming. You can also explore other subjects and sets from the links below.
A design pattern is a general, reusable solution to a common problem in software design. It is not a finished design that can be directly transformed into code. Rather it provides a template or blueprint for solving problems that occur across many projects.
Creational patterns deal with ways to create objects while hiding the creation logic, making the system independent of how its objects are created, composed, and represented.
The Singleton pattern restricts instantiation of a class to one object and provides a global point of access to that instance. It's used when exactly one object is needed to coordinate actions across the system.
The Factory Method pattern defines an interface for creating an object, but lets subclasses alter which class is instantiated. This allows for loose coupling by delegating object creation to subclasses.
The Abstract Factory pattern offers an interface for creating families of related or dependent objects without specifying their concrete classes. It promotes consistency among products and separates client code from concrete implementations.
The Builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations. It is useful when an object has many optional parameters or complex construction logic.
The Prototype pattern is used when the type of objects to create is determined at runtime and object creation is expensive. It builds a new object by copying a prototype instance rather than instantiating classes via new.
Design patterns encode proven solutions to recurring design problems, which saves development time and improves code quality. /n/n They provide a common vocabulary among developers so one can refer to a pattern name and instantly understand the structure and intent. /n/n They help promote code reuse, loose coupling, maintainability and scalability by guiding developers to structure relationships between objects rather than re-inventing solutions.
While design patterns provide clear benefits, they also introduce abstraction layers which may increase complexity and reduce clarity if used indiscriminately. /n/n Over-engineering with too many patterns can lead to code bloat, harder debugging and performance overhead. /n/n You should avoid applying a pattern when a simpler solution suffices and only adopt a pattern when it clearly matches a recurring problem in the system.
The Singleton pattern restricts a class to one instance, but this may introduce hidden dependencies and make unit testing difficult because the global instance persists and can retain state. /n/n It may hinder parallelism, and misuse can turn it effectively into a global variable which violates encapsulation. /n/n To mitigate this you can use dependency injection (inject the singleton instance rather than letting classes call the static getInstance), avoid using Singleton for excessive state, and ensure thread-safe initialization (e.g., using double-checked locking or enum singletons in Java).
The Factory Method pattern is about defining an interface for creating an object but letting subclasses decide which class to instantiate. It is useful when you want to vary the concrete implementation based on runtime conditions. /n/n The Builder pattern, on the other hand, is about constructing a complex object step-by-step, where you might want optional parameters, fluent interface, or different representations of the same product. /n/n Use a Factory when you have a single method that returns varied subclasses; use a Builder when you need to build complex objects with many options or deviate from simple constructors.