Object-Oriented Programming Quiz & Flashcards

Polymorphism allows objects of different classes to be treated as objects of a common superclass.

The open/closed principle promotes flexibility by allowing classes to be extended without modifying existing code.

Encapsulation is used to hide the implementation details and protect the internal state of an object.

The 'extends' keyword is used to inherit a class in Java, establishing an 'is-a' relationship.

Method overriding allows a subclass to define a specific implementation of a method already defined in its superclass.

The Iterator pattern provides a way to access elements of a collection sequentially without exposing the collection's structure.

The 'super' keyword is used to access methods and constructors of a parent class.

The Dependency Inversion Principle encourages classes to depend on abstractions rather than concrete implementations.

The 'final' keyword prevents a method from being overridden by subclasses.

The Singleton pattern ensures a class has only one instance and provides a global point of access to it.

'Self' represents the instance of the class calling the method, allowing access to its attributes and other methods.

Method overloading allows multiple methods with the same name but different parameter lists to coexist in a class.

An interface defines abstract methods that must be implemented by classes, promoting a form of multiple inheritance.

Composition models a 'has-a' relationship, promoting flexible design by combining behaviors from other classes.

The Single Responsibility Principle states that a class should have only one reason to change, focusing on a single responsibility.

Method overriding allows a subclass to offer its own implementation of a method from its superclass.

A constructor is used to initialize the state of an object when it is created.

An abstract class cannot be instantiated and typically includes abstract methods that subclasses must implement.

The 'final' keyword is used to declare a class that cannot be subclassed, preventing inheritance.

Inheritance promotes code reuse by allowing a new class to use methods and properties of an existing class.

The Facade pattern provides a simplified interface to a complex subsystem, making it easier for clients to use.

Dynamic binding refers to linking a method call to the method body at runtime, enabling polymorphism.

The Interface Segregation Principle suggests creating specific interfaces for different clients to avoid forcing them to implement unused methods.

The 'instanceof' keyword checks whether an object is an instance of a specific class or interface.

Data hiding restricts access to the internal state of an object, promoting encapsulation and preventing unauthorized modification.

The factory method pattern provides an interface for creating objects but lets subclasses decide which class to instantiate.

The observer pattern defines a one-to-many dependency such that when one object changes state, all its dependents are notified.

The Liskov Substitution Principle ensures that a subclass can stand in for its superclass without affecting the program's correctness.

The singleton pattern restricts a class to a single instance and provides a global point of access to that instance.

Deep inheritance hierarchies can become complex, making the code difficult to maintain and understand.

The decorator pattern adds responsibilities to individual objects dynamically without affecting other objects of the same class.

Polymorphism in Python is achieved through method overriding and duck typing, allowing objects to be used interchangeably.

The strategy pattern allows the selection of algorithms at runtime, providing flexibility and extensibility.

The 'final' keyword is used to declare a method that cannot be overridden in subclasses, ensuring its behavior remains unchanged.

Polymorphism allows different classes to be treated as instances of a parent class, promoting flexibility and reuse.

The interface segregation principle encourages the use of smaller, more specific interfaces to avoid forcing clients to implement unused methods.

A mixin is a class that provides methods to other classes without being part of an inheritance hierarchy, promoting code reuse.

The Iterator pattern provides a way to access elements of a collection sequentially without exposing its underlying representation.

Encapsulation protects an object's internal state from outside interference and misuse, promoting modularity and maintainability.

The template method pattern defines the skeleton of an algorithm in a method, with some steps deferred to subclasses for implementation.

Method overloading allows multiple methods with the same name but different parameter lists to coexist, providing flexibility.

A constructor is used to initialize an object's state when it is created, preparing it for use.

The Factory pattern provides a way to create objects without specifying the exact class type, simplifying object creation and management.

The Proxy pattern provides a surrogate or placeholder to control access to an object, often used for lazy initialization or access control.

Polymorphism allows for code generalization and reuse by enabling objects to be manipulated as instances of their parent class.

The Liskov Substitution Principle is violated when a subclass cannot be used as a substitute for its superclass without affecting program correctness.

Design patterns provide proven solutions to common software design problems, promoting best practices and improving code maintainability.

The 'abstract' keyword in Java is used to declare a class or method that cannot be instantiated or directly implemented, requiring subclass implementation.

The Decorator pattern adds new functionality to an existing object without altering its structure, allowing dynamic behavior changes.

The Observer pattern notifies all dependent objects when a change occurs, establishing a one-to-many relationship for event handling.