Multiple Choice Questions on Object-Oriented Design Principles (AP Computer Science A)

📚 Quick Study Guide: Object-Oriented Design Principles

• 🔒 Encapsulation: The practice of bundling data (attributes) and methods (behaviors) that operate on the data into a single unit, a class, and restricting direct access to some of the object's components. It's about data hiding and information protection.
• 🧬 Inheritance: A mechanism where one class (subclass/child class) acquires the properties and behaviors of another class (superclass/parent class). It promotes code reusability and establishes an "is-a" relationship.
• 🎭 Polymorphism: The ability of an object to take on many forms. In Java, this often refers to method overriding (runtime polymorphism) and method overloading (compile-time polymorphism), allowing a single interface to represent different underlying forms.
• 👻 Abstraction: The process of hiding the complex implementation details and showing only the essential features of the object. It focuses on "what" an object does rather than "how" it does it, often achieved through abstract classes and interfaces.
• 📐 SOLID Principles: A set of five design principles intended to make software designs more understandable, flexible, and maintainable.
  • 🎯 S - Single Responsibility Principle (SRP): A class should have only one reason to change, meaning it should have only one job or responsibility.
  • 🔓 O - Open/Closed Principle (OCP): Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.
  • 🔄 L - Liskov Substitution Principle (LSP): Objects of a superclass should be replaceable with objects of its subclasses without breaking the application.
  • ✂️ I - Interface Segregation Principle (ISP): Clients should not be forced to depend on interfaces they do not use. Better to have many small, specific interfaces than one large, general-purpose interface.
  • 🤝 D - Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.

📝 Practice Quiz: Object-Oriented Design Principles

1. Which OOP principle involves bundling data and the methods that operate on the data into a single unit, and restricting direct access to some of the object's components?
   A) Inheritance
   B) Polymorphism
   C) Encapsulation
   D) Abstraction
2. In Object-Oriented Programming, what does the "is-a" relationship primarily represent?
   A) Polymorphism
   B) Encapsulation
   C) Inheritance
   D) Abstraction
3. Consider a `Shape` class with a `draw()` method, and a `Circle` subclass that overrides the `draw()` method. When an object of type `Shape` that is actually a `Circle` calls `draw()`, which method will be executed?
   A) The `draw()` method of the `Shape` class.
   B) The `draw()` method of the `Circle` class.
   C) A compile-time error will occur.
   D) Both `draw()` methods will be executed simultaneously.
4. Which OOP concept allows you to define a contract for a class without providing the full implementation details, often using abstract methods or interfaces?
   A) Encapsulation
   B) Inheritance
   C) Polymorphism
   D) Abstraction
5. According to the Single Responsibility Principle (SRP), a class should ideally have:
   A) Multiple reasons to change, to maximize reusability.
   B) Exactly two responsibilities, one for data and one for methods.
   C) Only one reason to change, focusing on a single responsibility.
   D) No responsibilities, acting purely as a data holder.
6. The Open/Closed Principle (OCP) states that software entities (classes, modules, functions, etc.) should be:
   A) Closed for extension, open for modification.
   B) Open for extension, closed for modification.
   C) Closed for both extension and modification.
   D) Open for both extension and modification.
7. The Liskov Substitution Principle (LSP) emphasizes that:
   A) Subclasses must exactly replicate all methods of their superclass.
   B) Objects of a superclass should be replaceable with objects of its subclasses without altering the correctness of the program.
   C) All methods in a superclass must be declared as final.
   D) Subclasses are only allowed to add new functionality, not override existing ones.