OOP and Design Patterns Interview Questions

What should you focus on when preparing?

Which questions should you start with?

Start with OOP principles, dependency injection, and polymorphism. These were the most asked questions in these interviews. The question about OOP and its main principles appeared in 41 of 347 interviews. Overloading versus overriding, SOLID, and interfaces versus abstract classes also ranked among the most asked.

Use these questions to check what you can explain. Can you explain each OOP principle with an example? Can you tell a class from an object, and overloading from overriding?

What did real OOP answers miss?

Reviewed answers missed key differences between concepts and details of how objects behave. Check whether you can explain these points:

• Abstraction and encapsulation: Can you explain each clearly and say how they differ? Reviewed answers did not clearly explain abstraction or distinguish it from encapsulation.
• Polymorphism: Can you show a shared interface or base-class reference referring to different implementations, with the overridden method chosen at runtime?
• Interfaces and abstract classes: Can you explain when you need a contract across unrelated classes, and when you need shared state and base behavior?
• Static and instance methods: Can you explain why a static method can be called without creating an object, while an instance method is tied to a particular object?

What should your dependency injection and SOLID answers cover?

The question about dependency injection and its container appeared in 38 of 347 interviews. Reviewed answers missed how DI helps with testing, loose coupling, and maintenance. Can you explain how DI makes code easier to test, reduces dependence between classes, and makes changes easier to manage?

Also check whether you can explain injection styles, service lifetimes, and circular dependencies. For SOLID, can you expand the whole acronym correctly and explain every principle? Reviewed answers included incomplete or incorrect expansions.

Should you also write code?

Code-writing tasks appeared in 17 of 347 interviews. Use the recorded tasks to check concrete skills: can you write a simple Apex class, create an object in Python, call an instance method to get its returned string, and check an object's type? Another task asked how to retrieve a class's public methods using reflection.

What should you cover beyond the basics?

Can you choose a design pattern for an application and explain how you would implement it? Pattern questions covered these skills as well as pattern categories.

For MVC, MVP, and MVVM, can you explain where responsibilities and state updates belong? For Clean Architecture and domain-driven design, can you identify domain boundaries and where business rules belong? For test automation, can you explain the structure and trade-offs of a framework using Page Objects, Screenplay, or shared test components?

Who gets asked OOP and Design Patterns

The 20 most asked OOP and Design Patterns questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. What is object-oriented programming, and can you explain its four main principles with examples?

   Asked in 41 of 347 interviews · last asked Oct 22 · Concept · Junior

   Show answer

   Object-oriented programming (OOP) organizes code around objects that combine data and behavior. Encapsulation controls access to an object's state, while abstraction exposes useful operations without showing implementation details. Inheritance lets a class build on another class. Polymorphism lets different object types respond to the same operation in their own ways.

   • Encapsulation: a bank account hides its balance and allows changes only through methods that enforce valid transactions.
   • Abstraction: callers use account.withdraw(amount) without knowing how the account stores transactions.
   • Inheritance: ElectricCar extends Car, reusing its behavior and adding battery-related features.
   • Polymorphism: Circle and Rectangle both provide draw(), but each draws a different shape.

   What the interviewer checks: The interviewer checks whether you can explain all four principles, distinguish them, and connect them to practical examples.

   Common mistake (in 6 of 15 reviewed answers): Many answers forget that abstraction hides implementation details, while encapsulation controls access to an object's state.

   Other ways it was asked

   • “What is object-oriented programming?”
   • “What is OOP?”
   • “What are the main principles of object-oriented programming?”

2. What is dependency injection, and how does a dependency injection container work?

   Asked in 38 of 347 interviews · last asked Oct 21 · Concept · Junior

   Show answer

   Dependency injection means a class receives its dependencies from outside instead of creating them itself. This supports loose coupling, easier testing, and easier maintenance. A DI container uses service registrations to find or create dependencies and supply them to objects. It also manages configured lifetimes, such as transient, scoped, or singleton in .NET.

   • Constructor injection makes required dependencies clear.
   • Tests can supply fake implementations instead of real services.
   • DI does not require a container; you can supply dependencies yourself.
   • In .NET, transient means each resolution, scoped means once per scope, and singleton means one shared instance.

   What the interviewer checks: The interviewer checks whether you understand DI’s benefits and can separate injection from the container’s role.

   Common mistake (in 8 of 20 reviewed answers): Many answers forget that DI helps testing and maintenance by letting you replace dependencies without changing the class.

   Other ways it was asked

   • “What is dependency injection?”
   • “What is dependency injection, and when would you use it?”
   • “Can you explain what dependency injection is?”

3. What is polymorphism, and can you explain it with an example?

   Asked in 22 of 347 interviews · last asked Oct 22 · Concept · Junior

   Show answer

   Polymorphism lets you use different implementations through the same interface or base type. With method overriding, the object's actual class determines which method runs at runtime. In Java, method overloading is different: the compiler chooses between methods with different parameter lists using compile-time types.

   • An interface or base-class reference can refer to objects of different implementing classes or subclasses.
   • Overridden instance methods are selected at runtime.
   • Java resolves overloaded methods at compile time, not by the argument object's runtime class.

   CodeCopy

   interface Animal { void speak(); }
   class Dog implements Animal { public void speak() { System.out.println("Woof"); } }
   class Cat implements Animal { public void speak() { System.out.println("Meow"); } }
   public class Main {
       public static void main(String[] args) {
           Animal[] animals = {new Dog(), new Cat()};
           for (Animal animal : animals) animal.speak(); // Woof, then Meow
       }
   }

   What the interviewer checks: The interviewer checks whether you understand shared types, runtime method selection, and how overriding differs from overloading.

   Common mistake (in 3 of 8 reviewed answers): Many answers forget that the example should use a shared type and show overridden methods being selected at runtime.

   Other ways it was asked

   • “What is polymorphism?”
   • “What is polymorphism in Java?”
   • “What is polymorphism in object-oriented programming?”

4. What are method overloading and method overriding?

   Asked in 18 of 347 interviews · last asked Oct 22 · Concept · Junior

   Show answer

   Method overloading means using the same method name with different parameter lists. Method overriding means a subclass provides a new implementation of an inherited instance method with the same signature. In Java, overload selection happens at compile time, while overridden method selection happens at runtime based on the actual object.

   • Overloads differ by parameter count, types, or order; changing only the return type is not enough.
   • An override must have a compatible return type and cannot reduce access.
   • In Java, final methods cannot be overridden; static methods are hidden, not overridden.

   CodeCopy

   class Printer {
       void print(int value) { System.out.println(value); }
       void print(String value) { System.out.println(value); } // Overloading
   }
   class LoudPrinter extends Printer {
       @Override
       void print(String value) { // Overriding
           System.out.println(value.toUpperCase());
       }
   }

   What the interviewer checks: The interviewer checks whether you understand parameter-based method selection and runtime polymorphism.

   Other ways it was asked

   • “What is method overriding in Java?”
   • “What is method overloading?”
   • “What is the difference between method overloading and method overriding?”

5. What does SOLID stand for, and what does each principle mean?

   Asked in 18 of 347 interviews · last asked Oct 15 · Concept · Mid-level

   Show answer

   SOLID stands for Single Responsibility (a class has one reason to change), Open/Closed (extend behavior without changing existing code), and Liskov Substitution (subtypes must honor base-type contracts). It also includes Interface Segregation (clients should not depend on methods they do not need) and Dependency Inversion (high-level and low-level code depend on abstractions).

   • Single Responsibility groups code that changes for the same reason, not necessarily code with only one method.
   • A subtype must work wherever its base type is expected, without breaking expected behavior.
   • With Dependency Inversion, details depend on abstractions; abstractions do not depend on details.
   • These principles guide design; adding interfaces everywhere can create needless complexity.

   What the interviewer checks: The interviewer checks whether you can name all five principles and explain how they guide software design.

   Common mistake (in 4 of 7 reviewed answers): Many answers forget that SOLID has five principles; name each one and explain its meaning.

   Other ways it was asked

   • “What are the SOLID principles?”
   • “Can you explain the SOLID principles?”
   • “What are the SOLID principles, and how do they guide software design?”

6. What is the difference between an interface and an abstract class?

   Asked in 16 of 347 interviews · last asked Oct 21 · Concept · Junior

   Show answer

   An interface defines a contract that different classes can follow. An abstract class provides a shared base with state and behavior, but cannot be created directly. Use an interface for a common role across unrelated classes, and an abstract class when related classes need shared code or state.

   • An abstract class can contain both implemented methods and abstract methods that concrete subclasses must implement.
   • In Java, a class can implement multiple interfaces but extend only one class.
   • Interface features depend on the language and version; Java 8+ interfaces support default method implementations.
   • Abstraction is the idea of hiding details; interfaces and abstract classes are tools for it.

   What the interviewer checks: The interviewer checks whether you can choose between a shared contract and a shared base class.

   Common mistake (in 3 of 5 reviewed answers): Many answers forget that interfaces suit unrelated classes sharing a contract, while abstract classes suit shared state and behavior.

   Other ways it was asked

   • “What is the difference between an abstract class and an interface?”
   • “What is the difference between an abstract class and an interface, and why would you use an abstract class instead of an interface?”
   • “What is the difference between abstraction and an interface?”

7. What is inheritance in object-oriented programming?

   Asked in 14 of 347 interviews · last asked Oct 17 · Concept · Junior

   Show answer

   Inheritance lets a class build on another class by reusing and extending its behavior. The child class can add features or override methods supported by the language. It is used to model an “is-a” relationship, such as a dog being an animal.

   • The existing class is the parent or superclass; the new class is the child or subclass.
   • Inheritance supports code reuse and polymorphism.
   • Use inheritance for an “is-a” relationship, not just to share code.
   • Access rules and support for multiple parent classes depend on the language.

   What the interviewer checks: The interviewer is checking whether you understand how inheritance relates classes and when it is appropriate.

   Other ways it was asked

   • “What is inheritance?”
   • “What is the concept of inheritance?”
   • “Can you briefly explain the concept of inheritance?”

8. What are classes and objects, and how do they differ?

   Asked in 10 of 347 interviews · last asked Oct 17 · Concept · Junior

   Show answer

   A class defines the fields and methods that its objects can have. An object is an instance of a class, with its own identity and values for its instance fields. One class can be used to create many objects.

   • A class describes a type; an object is a specific instance of that type.
   • Objects of the same class can hold different values in their instance fields.
   • In Java, static fields belong to the class, not to each object.

   CodeCopy

   class Car {
       String color;
   }
   
   class Demo {
       public static void main(String[] args) {
           Car car = new Car();
           car.color = "red";
       }
   }

   What the interviewer checks: The interviewer is checking whether you can separate a class definition from an instance and its state.

   Other ways it was asked

   • “What is the difference between a class and an object?”
   • “What is a class?”
   • “What is an object?”

9. What are static methods, and how do they differ from instance methods?

   Asked in 9 of 347 interviews · last asked Oct 18 · Concept · Junior

   Show answer

   Static methods belong to a class and can be called without creating an object. In Python, they receive no automatic instance or class argument. Instance methods receive the object as `self` and can use its state. Python class methods receive the class as `cls`, so they can work with class-level state.

   • In Python, use `@staticmethod` for static methods and `@classmethod` for class methods.
   • Static methods can access object state if an object is explicitly passed to them.
   • Use instance methods for object behavior; use static methods for related helpers that need no instance.

   What the interviewer checks: The interviewer checks whether you understand which methods receive an object, a class, or neither automatically.

   Common mistake (in 6 of 9 reviewed answers): Many answers forget that static methods need no object, while instance methods receive a particular object automatically.

   Other ways it was asked

   • “What are static variables and static member functions in C++?”
   • “How do static variables and static member functions differ from their non-static counterparts in C++?”
   • “What is a static member function in C++?”

10. What is encapsulation, and can you explain its benefits with an example?

    Asked in 9 of 347 interviews · last asked Oct 22 · Concept · Junior

    Show answer

    Encapsulation keeps an object's data and the code that manages it together, and controls access through a defined interface. It helps prevent invalid state and allows internal changes without changing how callers use the object. Hiding means callers need not depend on implementation details, not that the source code is secret.

    • Private fields prevent callers from changing data directly.
    • Public methods enforce rules and expose only the operations callers need.
    • Internal storage and helper methods can change while the public interface stays stable.

    CodeCopy

    class Thermostat {
        private int temperature = 20;
        public void setTemperature(int value) {
            if (value < 10 || value > 30) {
                throw new IllegalArgumentException("Temperature must be 10 to 30");
            }
            temperature = value;
        }
        public int getTemperature() { return temperature; }
    }

    What the interviewer checks: The interviewer checks whether you understand how controlled access protects valid state and reduces dependence on internal details.

    Other ways it was asked

    • “What is encapsulation?”
    • “Can you give examples of implementation details that encapsulation hides?”
    • “How does encapsulation hide implementation details when the source code is accessible?”

11. What is abstraction in object-oriented programming?

    Asked in 9 of 347 interviews · last asked Sep 22 · Concept · Junior

    Show answer

    Abstraction means showing what an object can do without requiring callers to know how it works. It exposes essential operations and leaves out unnecessary details. In Java, interfaces and abstract classes are common ways to define these operations while letting concrete classes provide implementations.

    • Callers depend on a clear contract rather than implementation details.
    • Different classes can implement the same abstraction in different ways.
    • Abstraction focuses on what is exposed; encapsulation controls access to internal state and implementation.

    What the interviewer checks: The interviewer checks whether you understand separating an object's public operations from how they are implemented.

    Other ways it was asked

    • “What is abstraction?”
    • “What do you mean by abstraction?”
    • “What is abstraction in Java?”

12. How do transient, scoped, and singleton dependency injection lifetimes work in ASP.NET Core?

    Asked in 8 of 347 interviews · last asked Sep 18 · Concept · Mid-level

    Show answer

    Transient creates a new instance each time the container resolves it. Scoped reuses one instance within a scope, usually one HTTP request. Singleton reuses one instance for the root container's lifetime and must be safe for concurrent use. Choose based on how long state should live and whether sharing is safe.

    • Use transient for lightweight services that do not need shared state, such as a formatter.
    • Use scoped for request-level work; AddDbContext registers DbContext as scoped by default.
    • Use singleton for shared, thread-safe services, such as an in-memory cache.
    • Injecting DbContext into a singleton fails scope validation; without validation, requests may share a non-thread-safe context.

    What the interviewer checks: The interviewer checks whether you understand instance reuse, request boundaries, and the risks of sharing services across requests.

    Other ways it was asked

    • “Can you explain the differences between transient, scoped, and singleton service lifetimes in ASP.NET Core, and give a concrete example of when you would use each?”
    • “In ASP.NET Core, what's the difference between transient, scoped, and singleton lifetimes?”
    • “Explain transient, scoped, and singleton lifetimes in ASP.NET Core.”

13. Which design patterns do you know, and when would you use them?

    Asked in 8 of 347 interviews · last asked Oct 14 · Concept · Mid-level

    Show answer

    I know Strategy, Factory Method, Adapter, and Observer. I use Strategy to swap algorithms, and Factory Method when subclasses should choose which object to create. I use Adapter to make an existing class work with an interface the client expects. I use Observer when several objects need updates after another object changes.

    • Factory Method is creational; Adapter is structural; Strategy and Observer are behavioral.
    • Choose a pattern for a real problem, not just to use a pattern.
    • Patterns add structure, but can also add complexity.
    • Explain the problem solved and the trade-offs, not just the pattern name.

    What the interviewer checks: The interviewer is checking whether you can connect patterns to practical problems and explain when they help.

    Other ways it was asked

    • “Which design patterns do you know, and when do you apply them?”
    • “Which design patterns are you familiar with?”
    • “What do you know about design patterns?”

14. What is the Singleton design pattern?

    Asked in 7 of 347 interviews · last asked Oct 22 · Concept · Junior

    Show answer

    The Singleton pattern limits a class to one instance and provides a shared way to access it. I would use it when one object must coordinate a shared resource. It controls access, but shared state can hide dependencies and make testing harder.

    • The class controls instance creation; callers cannot freely create new instances.
    • The instance can be created immediately or only when first needed.
    • Concurrent access needs safe initialization; the object's methods may also need synchronization.
    • One instance usually means within one application process, not across multiple processes.

    What the interviewer checks: The interviewer is checking whether you understand controlled instance creation, suitable uses, and the risks of shared state.

    Other ways it was asked

    • “What are the advantages and disadvantages of the Singleton design pattern?”
    • “What is the singleton pattern?”
    • “What is the Singleton design pattern, and when would you use it?”

15. What is the MVC architecture?

    Asked in 7 of 347 interviews · last asked Oct 22 · Concept · Junior

    Show answer

    MVC stands for Model–View–Controller. It separates an application into three parts: the Model manages data and business rules, the View presents information, and the Controller handles user input and coordinates actions. This separation makes code easier to change and test.

    • The Model contains application data and business rules, not just database access.
    • The View displays information; it should not contain core business rules.
    • The Controller handles input and calls the appropriate application logic.
    • The exact flow between these parts depends on the framework.

    What the interviewer checks: The interviewer is checking whether you understand each part’s role and how MVC separates responsibilities.

    Other ways it was asked

    • “What is MVC?”
    • “At a basic level, what is MVC?”
    • “Explain MVC.”

16. What is a UML class diagram?

    Asked in 6 of 347 interviews · last asked Mar 27 · Concept · Junior

    Show answer

    A UML class diagram shows the static structure of a system: its classes, their attributes and operations, and their relationships. Each class is usually drawn as a box with sections for its name, attributes, and operations. It describes how the system is organized, not how it runs step by step.

    • UML stands for Unified Modeling Language.
    • Relationships include association, inheritance, aggregation, and composition.
    • Visibility symbols include + for public, - for private, and # for protected.
    • Multiplicity shows how many objects can be linked, such as one or many.

    What the interviewer checks: The interviewer is checking whether you can read and explain a basic object-oriented design diagram.

    Other ways it was asked

    • “What do you mean by a class diagram?”
    • “What is a class in UML?”
    • “What is a class diagram?”

17. What is the Page Object Model, and what are its benefits in test automation?

    Asked in 6 of 347 interviews · last asked Oct 12 · Concept · Mid-level

    Show answer

    The Page Object Model is a test design pattern that represents each UI page or component as an object. It keeps element locators and UI actions separate from test logic. This makes tests easier to read, reuse, and maintain because UI changes often need fixing in only one place. Use it when several UI tests share pages or interactions.

    • Page objects expose actions such as signing in, while hiding element locators and interaction details.
    • Tests describe scenarios and usually keep the assertions.
    • Shared page objects reduce duplicate code and limit fixes when the UI changes.
    • It adds structure and setup work, so very small test suites may benefit less.

    What the interviewer checks: The interviewer wants to see whether you can separate UI details from test intent and explain the maintenance benefits.

    Other ways it was asked

    • “What is the Page Object Model, and when would you use it?”
    • “What is the Page Object Model, and how have you used it in test automation?”
    • “What is the Page Object Model, and how do you use it in test automation?”

18. What is an interface in Java?

    Asked in 5 of 347 interviews · last asked Sep 30 · Concept · Junior

    Show answer

    An interface in Java is a type that defines a contract for classes to follow. It lets code use different implementations through the same type, without depending on a specific class. This supports polymorphism and makes implementations easier to replace or test.

    • A class uses implements and must implement abstract methods unless the class is abstract.
    • A class can implement multiple interfaces.
    • Interfaces cannot be instantiated directly.
    • Since Java 8, interfaces can also contain default and static methods with bodies.

    What the interviewer checks: The interviewer is checking whether you understand interfaces as contracts and how they reduce dependencies on specific classes.

    Other ways it was asked

    • “What is an interface in Java, and what is it used for?”
    • “What advantages do interfaces provide in Java?”

19. How would you design an immutable class in Java?

    Asked in 5 of 347 interviews · last asked Oct 6 · Concept · Mid-level

    Show answer

    An immutable Java class cannot change its state after construction. Make the class final, keep fields private and final, and provide no methods that change its state. Copy mutable inputs and return defensive copies of mutable fields, so callers cannot change the object's internal state.

    • A final class prevents subclasses from adding behavior that breaks immutability.
    • A final reference cannot be reassigned, but the referenced object may still change.
    • Copy mutable data on input and output; immutable values can be shared.
    • Do not let this escape during construction.

    CodeCopy

    public final class Event {
        private final java.util.Date when;
        public Event(java.util.Date when) {
            this.when = new java.util.Date(when.getTime());
        }
        public java.util.Date getWhen() {
            return new java.util.Date(when.getTime());
        }
    }

    What the interviewer checks: The interviewer checks whether you can prevent state changes through methods, subclasses, and shared mutable objects.

    Other ways it was asked

    • “How do you make a class immutable in Java?”
    • “Can you explain immutable class design?”
    • “What does immutable class design mean in Java?”

20. What is inversion of control?

    Asked in 5 of 347 interviews · last asked Oct 7 · Concept · Junior

    Show answer

    Inversion of control (IoC) means handing control of part of your program to a framework or container. In Spring, the container creates and manages objects called beans and supplies their dependencies. Dependency injection is one way to apply IoC: objects receive what they need instead of creating it themselves.

    • IoC is a broader principle than dependency injection.
    • Spring manages bean creation, wiring, and lifecycle.
    • Dependency injection helps separate components and makes them easier to test.

    What the interviewer checks: The interviewer wants to know whether you understand who controls object creation and how IoC relates to dependency injection.

    Other ways it was asked

    • “What is inversion of control (IoC)?”
    • “What does inversion of control mean in a Spring application?”
    • “What is inversion of control in Spring Boot?”

Live coding round next? Coding mode in the MeetAssist desktop app solves the problem on your screen, with your phone as the remote.

Related interview questions

• Software Engineer interview questions
• QA Engineer interview questions
• Data Structures and Algorithms interview questions
• System Design interview questions
• Microservices interview questions
• REST API interview questions
• Kafka and Message Queues interview questions
• Caching and Redis interview questions
• Operating Systems interview questions
• Computer Networks interview questions
• Git interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every OOP and Design Patterns interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

347 interviews, 240 candidates, Sep 2025 to Oct 2026. Updated every month with new interviews.