What is the difference between the State and Strategy patterns?
- None of the above
- The State and Strategy patterns are the same
- The State pattern allows an object to alter its behavior when its internal state changes, while the Strategy pattern allows an object to change its behavior based on the context it is in
- The State pattern allows an object to change its behavior based on the context it is in, while the Strategy pattern allows an object to alter its behavior when its internal state changes
The State pattern allows an object to alter its behavior when its internal state changes, while the Strategy pattern allows an object to change its behavior based on the context it is in
What is the Visitor pattern?
- A behavioral design pattern that lets you pass requests along a dynamic chain of receivers until one of them handles it.
- A behavioral design pattern that separates an algorithm from an object structure on which it operates. The pattern allows you to define a new operation without changing the classes of the objects on which it operates.
- A creational design pattern that uses factory methods to deal with the problem of creating objects without specifying the exact class of object that will be created.
- A structural design pattern that allows you to compose objects into tree structures to represent part-whole hierarchies.
A behavioral design pattern that separates an algorithm from an object structure on which it operates. The pattern allows you to define a new operation without changing the classes of the objects on which it operates.
What is Inversion of Control?
- A mechanism for managing dependencies between software components, such as libraries or services, that are required to run an application.
- A method of testing in which dependencies are replaced with mock objects to isolate the test subject from the rest of the system.
- A software design principle in which the flow of control of a system is inverted compared to the traditional approach. Instead of the system calling a component to perform a task, the component is notified when a task is ready and performs it. This leads to a more flexible and decoupled system, allowing for easier maintenance and testing.
- A technique for structuring software components into a tree-like hierarchy to organize dependencies and reduce coupling between components.
Inversion of Control is a design principle in which the flow of control in a system is inverted. Instead of a system calling components to perform tasks, components are notified when tasks are ready and perform them. This leads to a more flexible and decoupled system, allowing for easier maintenance and testing.
Name the actor classes used in Memento pattern.
- Caretaker, Originator, Memento
- Memento, Caretaker, Originator
- Originator, Caretaker, Memento
- Originator, Memento, Caretaker
The actor classes used in the Memento pattern are: Originator, Memento, and Caretaker. The Originator class is responsible for creating the memento and restoring its state. The Memento class is responsible for storing the internal state of the Originator. The Caretaker class is responsible for maintaining a list of mementos and providing the Originator with the appropriate memento at the appropriate time.
Give an example where Interpreter pattern is used?
- Interpreter pattern is used in compilers, where expressions in a programming language need to be parsed and evaluated
- Interpreter pattern is used in database management systems, where SQL queries need to be interpreted and executed
- Interpreter pattern is used in game engines, where game rules need to be interpreted and executed
- Interpreter pattern is used in web applications, where user requests need to be interpreted and processed
One example of where Interpreter pattern is used is in compilers, where expressions in a programming language need to be parsed and evaluated. The Interpreter pattern can be used to evaluate the syntax and semantics of a programming language, and generate code or perform other actions based on the results of the evaluation.
What is the Command and Query Responsibility Segregation (CQRS) Pattern?
- A pattern in which read and write operations are separated into separate models.
- A pattern that helps to avoid race conditions and deadlocks in multithreaded applications.
- A pattern used to implement inter-process communication.
- A pattern used to improve database performance by caching results in memory.
CQRS is a pattern that separates the responsibilities of querying data (read) from modifying data (write) into separate models, improving scalability and maintainability of the application.
What is Null Object pattern?
- A design pattern in which a special object, called the null object, is used to represent the absence of a value, avoiding the need for explicit checks for null values
- A design pattern in which an object, called the context, holds a reference to an instance of one of several possible concrete state objects, each of which represents a distinct state of the context and implements a common state interface
- A design pattern in which an object, called the decorator, adds or overrides behavior of an existing object, dynamically
- A design pattern in which an object, called the prototype, is used as a template to create new objects, without specifying their concrete classes
The Null Object pattern is a design pattern in which a special object, called the null object, is used to represent the absence of a value, avoiding the need for explicit checks for null values. The Null Object pattern is used to provide a default implementation of an interface, reducing the amount of error-prone null checks in the code. The Null Object pattern can also be used to simplify the code and reduce coupling by eliminating the need for explicit checks for null values.
What is the difference between a Singleton and a Prototype pattern?
- None of the above
- The Singleton and Prototype patterns are the same
- The Singleton pattern creates multiple instances, while the Prototype pattern creates only one instance
- The Singleton pattern creates only one instance, while the Prototype pattern creates multiple instances
The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance, while the Prototype pattern provides a mechanism for creating object instances that are exact copies of a prototype object
Name some of the design patterns used in JDK library.
- Abstract Factory, Builder, Factory Method, Singleton
- Adapter, Facade, Observer, Prototype
- Chain of Responsibility, Command, Interpreter, Iterator
- Decorator, Mediator, State, Strategy
Some of the design patterns used in the JDK library include Decorator, Mediator, State, and Strategy. These patterns are used in various classes and APIs of the Java Standard Library to provide a clean and efficient implementation of common design problems.
How can you create Singleton class in Java?
- By declaring a private constructor and a public static method that returns the only instance of the class
- By declaring all of its variables and methods as final
- By declaring all of its variables and methods as static
- By implementing the Cloneable interface
A Singleton class in Java can be created by declaring a private constructor and a public static method that returns the only instance of the class. This ensures that there is only one instance of the class in the JVM and that it can be easily accessed by other objects in the system.