OOP Expert
Explain the conceptual difference between a class and an object. If a class is a blueprint, what exactly is the instance in memory?
Select the correct answer
A cached compiled copy of the class definition shared across every running instance
A reserved name in the symbol table pointing back at the original class template
A concrete allocation of memory holding actual field values described by the class
A duplicate of the class source code that is reparsed each time it is called
What is the 'this' (or 'self') reference conceptually, and how does an object know its own context?
Select the correct answer
A static handle shared by all instances that references the class definition
A copy of the object's fields passed by value into each method invocation
An implicit reference to the current instance so methods act on its own data
A global pointer to the most recently created object of any class type
What is the difference between a Class and an Object in terms of memory allocation?
Select the correct answer
Both a class and an object reserve equal memory whenever either of them is used.
An object is a blueprint needing no memory; a class reserves memory upon creation.
A class reserves memory when defined; each object merely references that shared block.
A class is a blueprint allocating no memory; an object reserves memory once instantiated.
How does the lifecycle of an object work, and explain the concept of garbage collection or manual destruction at a high level?
Select the correct answer
It is duplicated on each access and every old copy must be freed by the caller
It exists forever from program start and is only cleared at final process exit
It is created, used, then reclaimed automatically or freed manually when unreferenced
It is destroyed instantly the moment any single method finishes running on it
Can you have an object without a class?
Select the correct answer
Yes, but only when the object contains no methods and holds pure data
Yes, prototype-based languages create objects directly from other objects
No, every object universally requires a compiled class declaration first
No, unless the runtime silently generates a hidden anonymous class for it
What happens conceptually during Object Instantiation?
Select the correct answer
All existing instances are copied together into one new merged object
A shared static template is renamed and exposed directly to the caller
Memory is allocated, fields are initialized, and a reference is returned
The class source is recompiled and its bytecode is reloaded into memory
What is the 'Root Object' concept (e.g., Object class) found in many OO languages?
Select the correct answer
The first instance created at startup that every later object must reference
The entry class whose main method runs before any other object exists
A base type all classes implicitly inherit, providing common shared methods
A special container holding one global copy of every class in the program
Explain the difference between state, behavior, and identity of an object.
Select the correct answer
State is its data, behavior is its methods, identity is its unique existence
State is its methods, behavior is its data, identity is its memory alignment
State is its class name, behavior is its parent, identity is its field count
State is its address, behavior is its type, identity is its stored values
Explain the order of initialization when an object is instantiated.
Select the correct answer
Superclass constructor runs first, then field initializers, then the constructor body
Field initializers run first, then the constructor body, then the superclass constructor
The superclass and subclass constructors run together, then all field values are set
The constructor body runs first, then field initializers, then the superclass setup
How does Object-Oriented Programming differ from procedural or structured programming, and what specific problems does it solve?
Select the correct answer
OOP and procedural are identical except that OOP forbids the use of any global variables.
OOP bundles data with behavior into objects, taming complexity that procedural code scatters.
OOP separates data from functions completely, unlike procedural code which merges them tightly.
OOP replaces functions with loops entirely, solving the memory problems procedural code creates.
Explain the four pillars of OOP to a non-technical stakeholder.
Select the correct answer
Write threads that run concurrently, lock resources, share memory, and synchronize on events.
Hide details, build on existing things, treat similar things alike, and group related data.
Store data in tables, query with joins, index the columns, and normalize to avoid duplication.
Break work into functions, pass arguments, return values, and avoid using any global state.
What are the primary goals of OOP, and how does it improve modularity, reusability, and maintainability in a large-scale codebase?
Select the correct answer
It forces all code into a single class so the whole system stays tightly connected together.
It removes interfaces entirely, exposing internal state so modules can share data freely.
It duplicates logic across classes to guarantee that each module stays fully independent.
It encapsulates state behind interfaces, letting components be reused and changed independently.
Explain the concept of 'Message Passing' in OOP.
Select the correct answer
Objects directly modify each other's fields, bypassing methods to exchange internal data.
Messages are shared memory buffers that objects read from to synchronize their state.
Message passing means copying an entire object whenever another object needs its data.
Objects request behavior by sending messages, letting the receiver decide how to respond.
What are the common criticisms of the object-oriented paradigm?
Select the correct answer
Boilerplate, deep inheritance, and hidden mutable state can make behavior hard to trace.
It makes code impossible to reuse, since encapsulation prevents any sharing between classes.
It removes all abstraction, exposing implementation details that tightly couple every module.
It cannot model real-world entities, forcing developers to rely on global procedural state.
What are the trade-offs of using OOP, and in what scenarios might a different paradigm like functional or procedural be more effective?
Select the correct answer
Functional fits stateless transforms and concurrency; procedural fits simple linear scripts.
Functional fits mutable shared state, while procedural best models deep inheritance hierarchies.
OOP is always superior, so functional and procedural only suit very small teaching examples.
Procedural fits concurrency and immutability, whereas functional suits stateful object graphs.
What is the 'Message Passing' view of OOP versus the 'Method Call' view?
Select the correct answer
Message passing resolves everything at compile time, while method calls defer to runtime.
Method call implies late binding where the class picks the right message before compiling.
Message passing implies late binding where the object chooses its response at runtime.
Both views are identical since sending a message always compiles to a fixed function jump.
Why do we use getters and setters instead of making fields public, and what is the architectural benefit of this boilerplate?
Select the correct answer
They make every field accessible faster than direct access by caching computed values internally within the object.
They guarantee thread safety automatically so multiple threads can modify shared fields without any explicit locking.
They decouple the public interface from internal fields, allowing validation and later changes without breaking callers.
They reduce memory usage because private fields are only allocated lazily the first time they are actually accessed.
How does Encapsulation improve the security and maintainability of a system?
Select the correct answer
It duplicates data across many objects so that a single corrupted field cannot ever affect the rest of the system.
It restricts direct state access, enforcing invariants centrally and localizing the impact of internal changes.
It encrypts object fields at runtime so that external code can never read sensitive values directly from memory.
It removes the need for testing entirely since private fields cannot be modified incorrectly by any external code.
Explain the concept of Abstraction using a real-world example other than an ATM or a Car.
Select the correct answer
A TV remote creates many identical copies of itself so each room can independently control the same television.
A TV remote stores all its channel data privately so no other device can read the saved settings from it.
A TV remote lets you change channels by pressing a button without knowing the internal electronics behind it.
A TV remote inherits its buttons from a universal remote and overrides some of them for a specific brand.
What is the difference between data hiding and encapsulation: are they the same thing?
Select the correct answer
No; encapsulation bundles data with methods, while data hiding restricts external access to that internal data.
Yes; both terms mean exactly the same practice of grouping variables and functions together inside a class.
No; data hiding bundles behavior with state, while encapsulation only conceals the class name from its callers.
Yes; encapsulation is simply the modern name that has replaced the older deprecated term called data hiding.
What is the difference between Abstraction and Encapsulation? They both hide things, so why do we need both?
Select the correct answer
Abstraction bundles data with methods; encapsulation hides complexity behind a clean and simple interface.
Abstraction and encapsulation are identical concepts described using two different naming conventions in code.
Abstraction restricts access with keywords; encapsulation groups related classes together into logical packages.
Abstraction hides complexity to expose essential behavior; encapsulation bundles data and hides internal state.
Explain the conceptual difference between public, private, and protected access, and why is package-private or internal visibility useful in large systems?
Select the correct answer
public is visible within a package, private to subclasses, protected everywhere; internal exposes helper methods globally.
public is visible everywhere, private within the class, protected to subclasses; package-private hides module internals.
public is limited to the class, private to the module, protected to callers; package-private restricts inheritance chains.
public is open to subclasses, private to the package, protected within a file; internal keeps constructors fully hidden.
What is the difference between a static member and an instance member, and when is it appropriate to use a static method instead of an instance method?
Select the correct answer
Static members are created per instance and copied; use static methods only when overriding parent class behavior.
Static members belong to the class and are shared; use static methods when they need no instance state.
Static members belong to each object separately; use static methods when they must access private instance fields.
Static members exist only during construction; use static methods when an object requires polymorphic runtime dispatch.
What is an 'Inner Class' (or Nested Class), and when is it conceptually appropriate to use one?
Select the correct answer
A class instantiated statically; used when it must exist before the outer class object is ever created at runtime.
A class defined inside another; used when it is tightly bound to and only meaningful within the outer class.
A class that inherits from another; used when it must reuse and extend the outer class's public behavior.
A class shared across packages; used when many unrelated classes need access to the same reusable helper logic.
What is an anonymous class, and in what situations is it conceptually appropriate to use one?
Select the correct answer
A class created at runtime by reflection, ideal for dynamic plugin type loading.
A class with no fields or methods, ideal for marking a type without behavior.
A class hidden from other modules, ideal for keeping internal helpers private.
A class defined without a name and used once, ideal for quick one-off behavior.
What is the purpose of a sealed or final class, and when would you prevent a class from being extended?
Select the correct answer
To prevent modification so the class's fields become read-only after creation.
To prevent inheritance so the class's behavior and invariants stay guaranteed.
To prevent overriding so subclasses reuse but cannot alter any parent methods.
To prevent instantiation so the class can only expose static utility methods.
Can a class be both Abstract and Final? Why or why not?
Select the correct answer
No, since final requires all methods to be abstract and fully implemented.
No, since abstract demands subclassing while final blocks any subclass.
Yes, because final only stops method overriding, not class inheritance itself.
Yes, because abstract and final describe unrelated aspects of a class design.
What is name mangling, and what problem does it solve in the context of overloading or private members?
Select the correct answer
It rewrites private names with a class prefix to avoid subclass name clashes.
It merges duplicate method names into one entry to shrink the symbol table.
It renames overloaded methods so each signature maps to one unique symbol.
It encrypts private member names so external code can never reach them at all.
Explain the purpose of a Constructor. Can a Constructor be inherited or overridden?
Select the correct answer
It allocates memory for objects; it can be inherited but never overridden at all.
It initializes new objects; it is neither inherited nor overridden by subclasses.
It initializes new objects; it is inherited and may be overridden like any method.
It destroys unused objects; it is neither inherited nor overridden by subclasses.
What is the difference between a default constructor and a parameterised constructor?
Select the correct answer
A default constructor is provided by the base class while a parameterised one is written by the developer.
A default constructor cannot assign any fields while a parameterised one is implicitly declared as static.
A default constructor runs only once whereas a parameterised one executes on every method invocation.
A default constructor takes no arguments while a parameterised one accepts arguments to initialise state.
What is constructor overloading, and why would a class provide multiple constructors?
Select the correct answer
Redefining a parent class constructor inside a child class so the subclass can change its behaviour.
Providing a single constructor that accepts a variable number of arguments resolved later at runtime.
Declaring several constructors with different parameter lists so objects can be built in different ways.
Calling one constructor from another repeatedly to reuse initialisation logic across every subclass.
What is the purpose of a constructor, and can you explain constructor chaining and why it is used in inheritance hierarchies?
Select the correct answer
One constructor calls another to reuse setup and initialize the base class first.
One constructor overrides another so the most specific initializer always runs.
One constructor delays another until all subclass fields have been fully assigned.
One constructor copies another's fields to avoid duplicating initialization logic.
Under what circumstances would you define a constructor as private, and what does this achieve conceptually?
Select the correct answer
To block method calls, ensuring only internal code can invoke the object's behavior.
To block subclassing, ensuring the class stays final and cannot be extended later.
To block external instantiation, enabling singletons or factory-controlled creation.
To block field access, ensuring the object's state stays fully encapsulated always.
What is a copy constructor, and when would you use one instead of relying on default copying?
Select the correct answer
It merges two objects into one, combining their fields into a single new instance.
It resets an existing object's fields, reusing the instance instead of allocating one.
It builds a new object from an existing one, giving control over how copies form.
It duplicates a reference to an object, letting two variables share the same state.
What is the concept of a static factory method as a language feature, and how does it differ from using a constructor directly?
Select the correct answer
A static method that mutates shared global state each time it runs instead of returning a new object.
A method that overrides the default constructor to enforce singleton behaviour across the whole app.
A constructor variant that is marked static so it can be invoked without any instance of the class.
A static method returning an instance that, unlike a constructor, can be named and may reuse objects.
Explain the difference between 'Is-A' and 'Has-A' relationships.
Select the correct answer
Is-A models inheritance between types while Has-A models one object containing another object.
Is-A links two classes at runtime while Has-A links them only at compile time through imports.
Is-A describes interface implementation while Has-A describes overriding of inherited methods.
Is-A models object containment while Has-A models a subclass extending its parent class type.
Can you explain the different types of inheritance, single, multilevel, hierarchical, and hybrid?
Select the correct answer
Single shares one parent, multilevel combines types, hierarchical has one parent, hybrid forms a chain.
Single forms a chain, multilevel has one parent, hierarchical combines types, hybrid shares one parent.
Single has one parent, multilevel forms a chain, hierarchical shares one parent, hybrid combines types.
Single combines types, multilevel shares one parent, hierarchical forms a chain, hybrid has one parent.
Explain the difference between association, aggregation, and composition, and how does ownership and lifetime define a composition versus an aggregation?
Select the correct answer
In aggregation the part is owned and dies with the whole, while composition lets the part exist alone.
In association the part is owned and dies with the whole, while composition keeps the part independent.
In composition and aggregation alike the part always shares the exact lifetime of the whole object.
In composition the part is owned and dies with the whole, while aggregation lets the part outlive it.
Explain the is-a relationship, and what are the risks of creating an inheritance hierarchy that is too deep?
Select the correct answer
Is-a denotes composition; deep hierarchies improve reuse and always make the code easier to maintain later.
Is-a denotes inheritance; deep hierarchies raise coupling and fragility, making changes hard to reason about.
Is-a denotes delegation; deep hierarchies remove duplication and guarantee changes stay local to a class.
Is-a denotes aggregation; deep hierarchies reduce coupling but slow the running program down considerably.
What is the difference between Aggregation and Composition in terms of object lifetime?
Select the correct answer
In both composition and aggregation the contained object is destroyed together with its parent container.
In composition the contained object outlives its container, while in aggregation they share one lifetime.
In aggregation the contained object dies with its container, while in composition it exists on its own.
In composition the contained object dies with its container, while in aggregation it exists independently.
Why can a class implement multiple interfaces but not inherit from multiple classes in many languages?
Select the correct answer
Interfaces are resolved at runtime while classes resolve at compile time, avoiding clashes.
Classes are stored differently in memory, which physically prevents linking two parents.
Interfaces cannot contain any methods at all, so nothing they hold could ever conflict.
Interfaces declare behavior without shared state or implementation, so no ambiguity can arise.
What is a dependency relationship between classes, and how does it differ from an association?
Select the correct answer
A dependency is always bidirectional, while an association can only ever point one direction.
A dependency is a transient 'uses' link, while an association is a persistent structural relationship.
A dependency implies ownership of an object, while an association just means two classes coexist.
A dependency stores a reference as a field, while an association is only a temporary method call.
How do UML class diagrams represent relationships like inheritance, composition, and association, including multiplicity?
Select the correct answer
Inheritance uses a hollow diamond, aggregation a solid line, and multiplicity is never drawn on the ends.
Inheritance uses a hollow triangle, composition a filled diamond, and multiplicity numbers label the ends.
Inheritance uses a dashed arrow, association a filled diamond, and multiplicity appears inside each class box.
Inheritance uses a filled diamond, composition a hollow triangle, and multiplicity is shown by dashed lines.
What is the conceptual difference between class-based and prototype-based object orientation?
Select the correct answer
Class-based uses inheritance chains, while prototype-based forbids any reuse between objects.
Class-based supports encapsulation, while prototype-based cannot hide any internal data at all.
Class-based works only at runtime, while prototype-based fixes object structure at compile time.
Class-based creates objects from blueprints, while prototype-based clones and extends live objects.
What is the difference between Method Overloading and Method Overriding?
Select the correct answer
Overloading changes the return type only; overriding changes both the name and the parameter list entirely.
Overloading redefines an inherited method's body; overriding defines methods with differing parameter lists.
Overloading defines same-named methods with different signatures; overriding redefines an inherited method.
Overloading occurs only across classes; overriding occurs only within a single class's own method scope.
What is 'Method Overriding,' and what happens if a child class calls a method that exists in both the parent and the child?
Select the correct answer
Overriding merges both implementations; the parent's version runs first, then the child's version runs automatically.
Overriding replaces the parent's implementation; the child's version runs unless it explicitly calls super.
Overriding requires different signatures; the compiler picks whichever version best matches the arguments given.
Overriding hides the parent method; the parent's version runs unless the child casts itself upward first.
At a high level, what is polymorphism and why is it considered central to object-oriented design?
Select the correct answer
It enables methods to accept any number of arguments of arbitrary differing types.
It allows one class to inherit fields and methods from several parent classes at once.
It permits objects to change their class dynamically depending on the runtime context.
It lets a single interface represent many underlying types, enabling uniform treatment.
Explain the difference between compile-time (static) and runtime (dynamic) polymorphism with a conceptual example of each.
Select the correct answer
Static resolves calls at compile time via overloading; dynamic resolves at runtime via overriding.
Static resolves calls at runtime via overriding; dynamic resolves at compile time via overloading.
Static polymorphism applies to fields and data; dynamic applies to constructors and destructors.
Static polymorphism uses interfaces exclusively; dynamic uses only abstract base class methods.
What is method overriding, and how does it differ from method hiding or shadowing?
Select the correct answer
Overriding is resolved by the reference's declared type; hiding uses dynamic dispatch on the runtime type.
Overriding works only with static methods; hiding works only with instance methods marked as virtual.
Overriding uses dynamic dispatch on virtual methods; hiding is resolved statically by the reference's type.
Overriding requires identical signatures; hiding requires different signatures within the same hierarchy tree.
What is the difference between Upcasting and Downcasting, and what are the risks of the latter?
Select the correct answer
Upcasting converts a subtype to a supertype safely; downcasting reverses it and can fail at runtime.
Upcasting converts a supertype to a subtype and is always safe; downcasting reverses it and never fails.
Downcasting converts a subtype to a supertype safely; upcasting is risky and needs an explicit type check.
Upcasting and downcasting both change the object's actual type in memory, risking data loss on conversion.
What is a 'Virtual Method' conceptually, and how does 'Late Binding' work?
Select the correct answer
A virtual method can be overridden by subclasses, and late binding resolves the actual call at runtime.
A virtual method is abstract with no body, and late binding inlines the correct implementation during compilation.
A virtual method runs only on the base class, and late binding delays object creation until the call.
A virtual method cannot be overridden, and late binding chooses the method at compile time from the reference.
What are the rules for method overloading versus overriding, and can you overload a method by changing only the return type?
Select the correct answer
Overloading needs different parameter lists in a class; you cannot overload by only changing the return type.
Overloading needs the same parameters across classes; you can overload a method by only changing its return type.
Overriding needs different parameter lists; the return type alone is enough to distinguish two overloaded methods.
Overloading requires an inheritance relationship; changing only the return type creates a valid method overload.
Explain the concept of 'Subtype Polymorphism' without using code.
Select the correct answer
A single type is reused with different data structures, each supplying identical behavior for all callers.
A base type inherits behavior from its subtypes, letting callers reuse the most specialized version available.
One function name works on unrelated types by using type checks to select behavior at runtime.
Code written against a base type can operate on any subtype, each supplying its own behavior.
What is the difference between 'Early Binding' and 'Late Binding'?
Select the correct answer
Early binding resolves calls at compile time; late binding resolves them at runtime by actual object type.
Early binding links methods during object creation; late binding links them when the class is first loaded.
Early binding applies to static methods only; late binding applies to any method regardless of the object.
Early binding resolves calls at runtime; late binding resolves them at compile time using the reference type.
Explain the concept of 'Dynamic Dispatch' or 'Late Binding'.
Select the correct answer
The method implementation is fixed when the class loads, before any object is created.
The method implementation is chosen by the number of arguments passed at the call site.
The method implementation is selected at runtime based on the object's actual type.
The method implementation is selected at compile time from the reference's declared type.
Explain 'Covariance' and 'Contravariance' in the context of method overriding and return types.
Select the correct answer
Covariance and contravariance both require an override to keep identical parameter and return types every time.
Covariance allows an override to return a more derived type; contravariance allows accepting more general parameters.
Covariance allows an override to return a more general type; contravariance allows accepting more derived parameters.
Covariance lets an override accept more derived parameters; contravariance lets it return a more general result type.
What is the difference between subtype, parametric, and ad-hoc polymorphism?
Select the correct answer
Subtype, parametric, and ad-hoc all rely on runtime type checks to dispatch to the correct implementation.
Subtype works through generics, parametric through overloading, and ad-hoc through inheritance across broad type hierarchies.
Subtype works through overloading, parametric through inheritance, and ad-hoc through generic type parameters at runtime.
Subtype works through inheritance, parametric through generics over many types, ad-hoc through overloading for specific types.
How does Run-Time Type Information (RTTI) allow a program to determine an object's actual type at runtime?
Select the correct answer
The compiler resolves each object's exact type statically before the program executes.
Runtime metadata stored with each object identifies its actual class during execution.
The garbage collector scans references to infer each object's declared static type.
The linker assigns fixed type identifiers that cannot be inspected once loaded.
What is method resolution order as a concept, and why does it matter when a method exists at multiple levels of a hierarchy?
Select the correct answer
It defines the order base classes are searched to resolve a method appearing at multiple levels.
It defines the order constructors run so parent state is initialized before child state safely.
It defines the order methods compile so overloaded signatures bind to their correct parameters.
It defines the order fields are allocated so memory layout stays consistent across subclasses.
What is a pure virtual (abstract) method, and how does it force subclasses to provide behaviour?
Select the correct answer
A method declared without a body that subclasses must implement before they can be instantiated
A private method hidden from subclasses that supplies a fixed default behaviour for the class
A method with a body that subclasses may optionally override at runtime for polymorphism
A method resolved at compile time that cannot be overridden by any subclass at all
What is the difference between an Abstract Class and an Interface, and when would you choose one over the other?
Select the correct answer
Abstract classes hold state and partial implementation; interfaces declare behavior without state.
Abstract classes are resolved at runtime while interfaces are fully resolved during compilation.
Abstract classes cannot be extended further whereas interfaces can be freely implemented anywhere.
Abstract classes support multiple inheritance while interfaces are restricted to a single parent.
What is a 'Marker Interface,' and what is its purpose if it has no methods?
Select the correct answer
It marks a class as final so no subclass can override or extend its existing functionality.
It forces implementers to write empty method bodies purely to document future intended behavior.
It groups shared constants that many classes import, avoiding duplicate declarations elsewhere.
It tags a class with metadata so code can test type membership, despite having no methods.
What does it mean to say an interface is a contract, and how does this facilitate decoupled development between teams?
Select the correct answer
It enforces that both teams share the same class hierarchy before any development work can begin.
It guarantees runtime behavior is identical across every class that chooses to implement the type.
It records concrete implementation details so consumers know exactly how each operation is performed.
It specifies what operations exist without implementation, letting teams build against it independently.
Can an Interface have a constructor? Why or why not?
Select the correct answer
No, because constructors are inherited from the first concrete class that implements it later.
No, because an interface cannot be instantiated and holds no instance state to initialize.
Yes, but only a private constructor used internally to set up its default constant values.
Yes, provided the constructor takes no arguments and simply returns the interface instance.
How do 'Default Methods' in interfaces change the traditional definition of an interface?
Select the correct answer
They let interfaces be instantiated directly, so simple types no longer need an implementing class.
They let interfaces declare private fields, so implementing classes can share mutable state safely.
They let interfaces run before construction, so setup logic executes ahead of any concrete class.
They let interfaces provide method implementations, so interfaces are no longer purely abstract.
What is the difference between a default (interface) method and a regular abstract method, and how do default methods affect interface evolution?
Select the correct answer
A default method can only be called statically and cannot be overridden by any implementing class
A default method has no body and must be implemented, while abstract methods carry a fallback body
A default method forces every existing implementer to recompile and supply its own new behaviour
A default method provides a body so implementers need not override it, easing interface evolution
Why is it often said that you should favour composition over inheritance, and what are the specific trade-offs in flexibility?
Select the correct answer
Composition assembles behaviour from objects at runtime, giving more flexibility than rigid inheritance
Composition always runs faster than inheritance because no virtual dispatch is ever needed
Composition removes all coupling entirely, so classes never depend on one another anymore
Inheritance is preferred because composition breaks encapsulation and exposes internal object state
Explain the concept of substitutability: why should a derived class be able to stand in for its base class without breaking the program?
Select the correct answer
A subclass must honour the base class contract so client code works unchanged with either
A subclass must add new methods so it can fully replace the base class in all cases
A subclass must be smaller than its base class to safely stand in wherever it is used
A base class must expose all its fields publicly so subclasses can override behaviour freely
What does it mean for two objects to be 'Tightly Coupled,' and how does OOP help achieve 'Loose Coupling'?
Select the correct answer
Tightly coupled objects share a common base class; polymorphism removes the shared inheritance need
Tightly coupled objects depend on each other's details; interfaces and abstraction reduce that dependency
Tightly coupled objects run in the same thread; message passing separates them into different threads
Tightly coupled objects have identical methods; encapsulation hides those methods to loosen the link
How do you identify potential classes and responsibilities from a set of requirements?
Select the correct answer
Verbs in the requirements suggest candidate classes and nouns suggest their responsibilities
Classes are derived only from the database schema, not from the written requirements text
Each requirement sentence becomes exactly one class with one responsibility by definition
Nouns in the requirements suggest candidate classes and verbs suggest their responsibilities
What does 'High Cohesion' mean for a class, and why is it desirable?
Select the correct answer
A class exposes all its fields directly so related objects can share state more efficiently
A class holds as many methods as possible so callers rarely need other classes around
A class depends heavily on other classes so its behaviour stays consistent across the system
A class's members focus on a single, well-defined responsibility, making it easier to maintain
In the context of object design, what does it mean to have high cohesion and low coupling, and why is this the gold standard?
Select the correct answer
A class handles one focused responsibility with minimal dependencies on other classes.
A class depends heavily on others while keeping its internal methods loosely related.
A class handles many responsibilities but shares no data with other classes at all.
A class exposes all of its fields publicly so other classes can freely reuse them.
How do you decide what should be a class versus what should be an attribute when modeling a real-world system?
Select the correct answer
Make it a class if it stores a single value, else always model it as an attribute.
Make it a class only when it holds numbers, and an attribute when it holds text.
Make it a class if it appears once, else an attribute when it repeats many times.
Make it a class if it has its own behavior and identity, else an attribute.
What is the fragile base class problem, and how does it affect the long-term maintenance of a system?
Select the correct answer
Subclasses fail to compile whenever the base class exposes any protected or private fields
Adding a new subclass forces the base class to be rewritten to support that subclass
A base class becomes unusable once too many subclasses inherit from it at the same time
Changes to a base class can silently break subclasses that depend on its internal behaviour
What are the tradeoffs of using deep Inheritance hierarchies?
Select the correct answer
It improves runtime speed but forces every subclass to override all parent methods.
It simplifies testing but makes the base class impossible to instantiate on its own.
It reduces memory usage but stops subclasses from adding any new behavior later on.
It maximizes code reuse but makes subclasses fragile and tightly coupled to parents.
Explain the gorilla-banana problem in inheritance.
Select the correct answer
Inheriting deeply makes the compiler load classes slowly due to long parent chains.
Inheriting one feature drags in all the parent's unwanted state and behavior too.
Inheriting an interface forces you to implement methods you will never actually call.
Inheriting from two parents causes conflicting method names that cannot be resolved.
What is the purpose of an object's string representation (toString), and why is overriding it useful?
Select the correct answer
It produces a human-readable textual form of an object, and overriding it yields meaningful output for logging and debugging
It compares two objects for equality, and overriding it lets collections locate and deduplicate stored items correctly
It serializes an object into a binary format, and overriding it ensures the stored bytes remain portable across systems
It generates a unique hash for an object, and overriding it keeps hash-based containers balanced and performant
What is the difference between a Shallow Copy and a Deep Copy when cloning an object?
Select the correct answer
A shallow copy duplicates all nested objects; a deep copy only copies the top level.
A shallow copy shares nested objects by reference; a deep copy duplicates them fully.
A shallow copy is always faster while a deep copy always fails on immutable fields.
A shallow copy clones primitives only while a deep copy clones nothing but pointers.
Explain the concept of 'Object Equality' versus 'Object Identity.' How do they differ?
Select the correct answer
Equality checks the memory address; identity compares the contents of two objects.
Equality applies only to primitives; identity applies only to reference-type objects.
Equality compares values or state; identity checks if it's the very same instance.
Equality is always reflexive but identity can change whenever an object is mutated.
What is an immutable object, and what are the benefits of designing classes to be immutable by default?
Select the correct answer
Its methods are all static, so instances never need to be created or destroyed later.
Its state cannot change after creation, making it thread-safe and easy to share.
Its fields are all public constants, letting other objects modify them without copying.
Its state can change only once after creation, which prevents accidental data races.
What is the contract between equals and hashCode, and why must two 'equal' objects produce the same hash code?
Select the correct answer
Unequal objects must always share a hash code to avoid collisions inside the map.
Equal objects must share a hash code so hash-based collections can find them.
Equal objects must have different hash codes so they occupy separate hash buckets.
Hash codes must equal the object's identity so equals can reuse the same address.
What is the purpose of generics in OOP, and how do they improve type safety without sacrificing reusability?
Select the correct answer
They cast objects dynamically at runtime, giving flexible storage while a single container tolerates any inserted concrete type
They parameterize code over types, giving compile-time checking while a single implementation works for many concrete types
They overload methods per type signature, giving distinct behavior while one class name covers many parameter combinations
They defer type resolution to reflection, giving late binding while a single interface adapts to unknown concrete types
What is operator overloading conceptually, and what are the risks of abusing it?
Select the correct answer
Defining multiple methods with one operator name; abuse yields ambiguous resolution that forces explicit casting everywhere
Giving operators custom meaning for user types; abuse yields surprising, unintuitive semantics that reduce code readability
Redefining built-in operators globally for all types; abuse yields runtime conflicts that break unrelated library code silently
Mapping operators to virtual dispatch at runtime; abuse yields slower arithmetic that degrades performance in tight loops
What is a finalizer or destructor conceptually, and why are finalizers considered unreliable for resource cleanup?
Select the correct answer
A method invoked explicitly by the programmer at end of use; unreliable because forgetting to call it leaves resources permanently leaked
A method that frees memory as soon as an object is created; unreliable because it blocks other threads during allocation cycles
A method run by the garbage collector before reclaiming an object; unreliable because its timing is nondeterministic and it may never run
A method run automatically when an object leaves scope; unreliable because it cannot safely access any of the object's instance fields
What is 'Reflection' (or Introspection) in OOP, and what are its use cases and risks?
Select the correct answer
Resolving method calls through the vtable at runtime; useful for polymorphism but risks slower dispatch and tight coupling
Inspecting and modifying types and members at runtime; useful for frameworks but risks poor performance and broken encapsulation
Rewriting compiled bytecode ahead of time; useful for optimization but risks portability loss and difficult debugging sessions
Copying an object graph deeply at runtime; useful for caching but risks stale references and heavy memory consumption
What is the 'Diamond Problem' in multiple inheritance, and how do different languages conceptually resolve it?
Select the correct answer
Deadlock when two classes reference each other cyclically; resolved by lazy loading, forward declarations, or weak reference pointers
Leakage when a base class exposes private state; resolved by sealing classes, hiding fields, or enforcing strict accessor rules
Slowdown when a deep hierarchy resolves virtual calls; resolved by caching dispatch, inlining methods, or flattening the class tree
Ambiguity when a class inherits one member via two paths; resolved by linearization, virtual bases, or banning multiple inheritance
What are mixins or traits conceptually, and how do they provide a middle ground for languages that don't support multiple inheritance?
Select the correct answer
Reusable bundles of behavior composed into a class, sharing methods across types without full multiple inheritance
Abstract contracts declaring only signatures, forcing each class to supply its own concrete implementation of behavior
Parameterized templates generating specialized classes, letting types share code while remaining strongly typed at compile time
Runtime wrappers that intercept method calls, injecting shared logic around existing behavior without altering the class
What is the purpose of a Virtual Destructor?
Select the correct answer
It guarantees a destructor is invoked exactly once even when multiple threads share the same object pointer, preventing races
It forces derived classes to declare their own destructor so cleanup logic is never accidentally inherited from a base
It ensures the correct derived destructor runs when an object is deleted through a base-class pointer, preventing leaks
It defers destruction until every reference is gone by reference counting, so the object is freed once safely at the end
What is virtual inheritance conceptually, and what problem in inheritance hierarchies is it meant to address?
Select the correct answer
It ensures constructors run in a deterministic order, addressing uninitialized members across a deep inheritance chain
It ensures a base class cannot be instantiated directly, addressing accidental creation of incomplete abstract object types
It ensures a shared base class is inherited only once, addressing duplicated base subobjects in diamond hierarchies
It ensures derived methods override base ones dynamically, addressing incorrect static binding when calling through pointers