How to implement the Command design pattern in Java?
Jul 09, 2025 am 12:28 AM
To implement the command design pattern, it must first clarify its core composition and implement it step by step. 1. Understand the core components of the command mode: including command interface, specific command classes, receivers, callers and clients; 2. Define command interfaces, usually including execute() method; 3. Create recipient classes that perform actual operations such as Light; 4. Implement specific command classes such as LightOnCommand and LightOffCommand to encapsulate receiver methods; 5. Use callers such as RemoteControl to trigger commands; 6. Create and bind commands and receivers on the client, and execute operations through the caller. This mode implements requested encapsulation, operation decoupling and functional expansion.
Implementing the Command design pattern in Java is a solid way to encapsulate requests as objects, allowing you to parameterize clients with operations, queue or log requests, and support undoable actions. It's especially useful when you want to decouple the object that invokes an operation from the one that knows how to perform it.
Let's walk through how to do this step by step.
1. Understand the core components of the Command pattern
Before writing any code, it helps to understand what parts make up the Command pattern:
- Command – an interface or abstract class that declares an
execute()method. - Concrete Command – implements the
execute()method by calling the appropriate method on a Receiver. - Receiver – the actual object that performs the action.
- Invoker – holds a command and calls its
execute()method when needed. - Client – ??creates the command and sets the receiver.
This structure allows for flexibility, such as queuing commands or adding undo functionality later.
2. Define the Command interface
Start by creating a simple interface that all concrete commands will implement. The most basic version includes just one method: execute() .
public interface Command {
void execute();
} You can also extend this interface to include things like undo() , but keep it simple at first.
3. Create a Receiver class
The receiver does the real work. For example, imagine a light switch system. You might have a Light class like this:
public class Light {
public void turnOn() {
System.out.println("The light is on");
}
public void turnOff() {
System.out.println("The light is off");
}
}This is where the actual logic resides — the command will call these methods indirectly.
4. Implement Concrete Command classes
Now create a command that uses the receiver. For turning the light on:
public class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOn();
}
}And if you want to support turning it off:
public class LightOffCommand implements Command {
private Light light;
public LightOffCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOff();
}
}These command objects act as wrappers around the receiver's methods.
5. Use an Invoker to trigger commands
An invoker doesn't know what the command does — it just triggers execution. Here's a simple one:
public class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
}
}You could expand this to handle multiple buttons or queues, but this gives you the idea.
6. Put it all together in the Client
Finally, wire everything up in your main class or client code:
public class Client {
public static void main(String[] args) {
// Create the receiver
Light light = new Light();
// Create the command and pass the receiver
Command lightOn = new LightOnCommand(light);
// Create the invoker and set the command
RemoteControl remote = new RemoteControl();
remote.setCommand(lightOn);
// Trigger the command
remote.pressButton();
}
}If you run this, you'll see:
The light is on
Change the command to LightOffCommand , and pressing the button turns it off instead.
This setup keeps your code modular and makes it easy to add new commands without modifying existing ones. Once you've got the basics down, you can easily extend it to support undo, logging, or macro-style batched commands.
Basically that's it.
The above is the detailed content of How to implement the Command design pattern in Java?. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Hot Topics
How Java ClassLoaders Work Internally
Jul 06, 2025 am 02:53 AM
Java's class loading mechanism is implemented through ClassLoader, and its core workflow is divided into three stages: loading, linking and initialization. During the loading phase, ClassLoader dynamically reads the bytecode of the class and creates Class objects; links include verifying the correctness of the class, allocating memory to static variables, and parsing symbol references; initialization performs static code blocks and static variable assignments. Class loading adopts the parent delegation model, and prioritizes the parent class loader to find classes, and try Bootstrap, Extension, and ApplicationClassLoader in turn to ensure that the core class library is safe and avoids duplicate loading. Developers can customize ClassLoader, such as URLClassL
Asynchronous Programming Techniques in Modern Java
Jul 07, 2025 am 02:24 AM
Java supports asynchronous programming including the use of CompletableFuture, responsive streams (such as ProjectReactor), and virtual threads in Java19. 1.CompletableFuture improves code readability and maintenance through chain calls, and supports task orchestration and exception handling; 2. ProjectReactor provides Mono and Flux types to implement responsive programming, with backpressure mechanism and rich operators; 3. Virtual threads reduce concurrency costs, are suitable for I/O-intensive tasks, and are lighter and easier to expand than traditional platform threads. Each method has applicable scenarios, and appropriate tools should be selected according to your needs and mixed models should be avoided to maintain simplicity
Understanding Java NIO and Its Advantages
Jul 08, 2025 am 02:55 AM
JavaNIO is a new IOAPI introduced by Java 1.4. 1) is aimed at buffers and channels, 2) contains Buffer, Channel and Selector core components, 3) supports non-blocking mode, and 4) handles concurrent connections more efficiently than traditional IO. Its advantages are reflected in: 1) Non-blocking IO reduces thread overhead, 2) Buffer improves data transmission efficiency, 3) Selector realizes multiplexing, and 4) Memory mapping speeds up file reading and writing. Note when using: 1) The flip/clear operation of the Buffer is easy to be confused, 2) Incomplete data needs to be processed manually without blocking, 3) Selector registration must be canceled in time, 4) NIO is not suitable for all scenarios.
Best Practices for Using Enums in Java
Jul 07, 2025 am 02:35 AM
In Java, enums are suitable for representing fixed constant sets. Best practices include: 1. Use enum to represent fixed state or options to improve type safety and readability; 2. Add properties and methods to enums to enhance flexibility, such as defining fields, constructors, helper methods, etc.; 3. Use EnumMap and EnumSet to improve performance and type safety because they are more efficient based on arrays; 4. Avoid abuse of enums, such as dynamic values, frequent changes or complex logic scenarios, which should be replaced by other methods. Correct use of enum can improve code quality and reduce errors, but you need to pay attention to its applicable boundaries.
How to handle exceptions properly in Java?
Jul 06, 2025 am 02:43 AM
The key to handling exceptions in Java is to catch them, handle them clearly, and not cover up problems. First, we must catch specific exception types as needed, avoid general catches, and prioritize checkedexceptions. Runtime exceptions should be judged in advance; second, we must use the log framework to record exceptions, and retry, rollback or throw based on the type; third, we must use the finally block to release resources, and recommend try-with-resources; fourth, we must reasonably define custom exceptions, inherit RuntimeException or Exception, and carry context information for easy debugging.
What is a Singleton design pattern in Java?
Jul 09, 2025 am 01:32 AM
Singleton design pattern in Java ensures that a class has only one instance and provides a global access point through private constructors and static methods, which is suitable for controlling access to shared resources. Implementation methods include: 1. Lazy loading, that is, the instance is created only when the first request is requested, which is suitable for situations where resource consumption is high and not necessarily required; 2. Thread-safe processing, ensuring that only one instance is created in a multi-threaded environment through synchronization methods or double check locking, and reducing performance impact; 3. Hungry loading, which directly initializes the instance during class loading, is suitable for lightweight objects or scenarios that can be initialized in advance; 4. Enumeration implementation, using Java enumeration to naturally support serialization, thread safety and prevent reflective attacks, is a recommended concise and reliable method. Different implementation methods can be selected according to specific needs
What is an anonymous inner class?
Jul 07, 2025 am 02:18 AM
Anonymous internal classes are used in Java to create subclasses or implement interfaces on the fly, and are often used to override methods to achieve specific purposes, such as event handling in GUI applications. Its syntax form is a new interface or class that directly defines the class body, and requires that the accessed local variables must be final or equivalent immutable. Although they are convenient, they should not be overused. Especially when the logic is complex, they can be replaced by Java8's Lambda expressions.
Java String vs StringBuilder vs StringBuffer
Jul 09, 2025 am 01:02 AM
String is immutable, StringBuilder is mutable and non-thread-safe, StringBuffer is mutable and thread-safe. 1. Once the content of String is created cannot be modified, it is suitable for a small amount of splicing; 2. StringBuilder is suitable for frequent splicing of single threads, and has high performance; 3. StringBuffer is suitable for multi-threaded shared scenarios, but has a slightly lower performance; 4. Reasonably set the initial capacity and avoid using String splicing in loops can improve performance.
