Object-Oriented Programming Concepts MCQ

What is a "class" in object-oriented programming?

What is an "object" in object-oriented programming?

What does "encapsulation" mean in OOP?

What is "inheritance" in OOP?

What is "polymorphism" in OOP?

What is "abstraction" in OOP?

What is a "constructor"?

What is the term for a variable that belongs to an object (an instance of a class)?

What is a "method" in OOP?

In OOP, what is a "parent class" (or "base class")?

What is a "child class" (or "derived class" / "subclass")?

What does "this" (or "self") typically refer to inside an instance method?

What is "method overriding"?

What is "method overloading"?

What access modifier typically makes a class member accessible only within its own class?

What access modifier typically allows a class member to be accessed from any code that has access to the object?

What access modifier typically allows access from the declaring class and its subclasses, but not from unrelated classes?

What is an "interface" in OOP?

What is an "abstract class"?

What is "composition" in OOP?

What is a "static" method or field?

What is a "destructor"?

What term describes the real-world relationship "a Car has an Engine"?

What term describes the relationship "a Dog is an Animal"?

What is the purpose of a "getter" method?

What is the purpose of a "setter" method?

In most class-based OOP languages, what keyword is commonly used to create a new object instance?

What does it mean for a method to be "final" (or non-overridable)?

What is a "constant" in the context of a class?

What is the main benefit of encapsulation?

What is a "namespace" (or "package" / "module") used for in OOP languages?

What is "dot notation" commonly used for in OOP?

What is the term for creating a new object from a class called?

Which of these is an example of a real-world analogy for a class and its objects?

Why might a class have multiple constructors with different parameters?

What does it mean for a class to "implement" an interface?

What is a "property" (or "field") of a class?

In OOP, what does "is-a" describe, as opposed to "has-a"?

What happens if a subclass does not override a method from its parent class?

What is a key advantage of using OOP for large software systems?

What is the difference between "method overloading" and "method overriding"?

What is "dynamic (runtime) polymorphism" typically implemented through?

Why might a class be designed to favor composition over inheritance?

What problem does the "diamond problem" refer to?

What is an "abstract method"?

What is the purpose of the "Liskov Substitution Principle" (the L in SOLID)?

What does the "Single Responsibility Principle" (the S in SOLID) state?

What does the "Open/Closed Principle" (the O in SOLID) state?

What does the "Interface Segregation Principle" (the I in SOLID) state?

What does the "Dependency Inversion Principle" (the D in SOLID) state?

What is a "design pattern"?

Which design pattern ensures a class has only one instance and provides a global access point to it?

Which design pattern defines a one-to-many dependency so that when one object changes state, all its dependents are notified?

Which design pattern provides an interface for creating objects without specifying their concrete classes?

What is the purpose of the "Strategy" design pattern?

What is the purpose of the "Decorator" design pattern?

What is the purpose of the "Adapter" design pattern?

What does "duck typing" mean (notably in languages like Python or Ruby)?

What is a "mixin"?

In OOP, what is a "shallow copy" of an object?

In OOP, what is a "deep copy" of an object?

What is "operator overloading"?

Why are immutable objects (objects whose state cannot change after creation) often preferred in certain designs?

What is the purpose of an abstract class's constructor if the class cannot be instantiated directly?

What does it mean for a class to have "high cohesion"?

What does "loose coupling" between classes mean, and why is it desirable?

What is a "constructor chaining" (or calling another constructor from within a constructor, e.g. via super() or this())?

What is the difference between an interface and an abstract class (in languages that support both)?

What is "multiple inheritance"?

What is a "virtual method" (in languages like C++ or C#)?

What is the benefit of programming "to an interface" rather than a concrete implementation?

What is a "factory" in the context of object creation patterns?

What does the term "god object" (or "god class") describe as an anti-pattern?

What does it mean to "compose" behaviors via dependency injection?

In a class hierarchy, what is "covariant return type"?

What is the main risk of using "protected" fields extensively in a class hierarchy?

What is "encapsulation" most directly in tension with, if overused without any public interface?

What is a "value object" in OOP design?

When designing class hierarchies, why is "is-a" sometimes a misleading guide for inheritance (e.g. "a Square is-a Rectangle")?

What is a common reason to use the "Template Method" design pattern?

What is "double dispatch" and why is it relevant to polymorphism?

How does the "Visitor" design pattern relate to double dispatch?

What is "object slicing" in languages like C++?

In the context of the SOLID principles, what is a "fragile base class" problem?

What is "mixin composition" used to solve compared to traditional multiple inheritance?

What is the difference between "structural subtyping" and "nominal subtyping"?

Why can excessive use of inheritance lead to violation of encapsulation, sometimes summarized as "inheritance breaks encapsulation"?

What is "covariance" and "contravariance" as applied to method parameters and return types in OOP type systems?

What is the purpose of the "Null Object" pattern?

In languages supporting "generics" or "templates", how does this relate to OOP polymorphism?

What does "favor delegation over inheritance" mean as a design heuristic?

How do "abstract classes" and "interfaces with default methods" (e.g. Java 8+ default methods) compare in terms of evolving APIs?

What subtle issue can arise from calling an overridable (virtual) method from within a constructor?

What is "interface pollution" and how do SOLID principles address it?

How does the "Open/Closed Principle" relate to the Strategy and Template Method patterns?

In a deep inheritance hierarchy, what is the "yo-yo problem"?

What does it mean for a method to be "idempotent" in the context of object state mutation, and why might this matter for OOP API design?

How can "encapsulation" and "testability" sometimes conflict, and what is a common resolution?

What is the relationship between the "Composite" design pattern and polymorphism?

Why might overusing "static" methods and classes undermine the benefits of OOP design?