separated-interface/README.md
The Separated Interface design pattern defines a client interface in a separate package from its implementation to allow for easier swapping of implementations and better separation of concerns.
Real-world example
Consider a restaurant where the menu (interface) is separate from the kitchen operations (implementation).
In this analogy, the menu lists the dishes customers can order, without detailing how they are prepared. Different restaurants (or even different chefs within the same restaurant) can use their own recipes and methods to prepare the dishes listed on the menu. This separation allows the restaurant to update its menu or change its chefs without disrupting the overall dining experience. Similarly, in software, the Separated Interface pattern decouples the interface from its implementation, allowing changes and variations in the implementation without affecting the client code that relies on the interface.
In plain words
Defines a client interface separate from its implementation to allow for flexible and interchangeable components.
Sequence diagram
The Java Separated Interface design pattern is a crucial software architecture strategy that promotes separating the interface definition from its implementation, crucial for enhancing system flexibility and scalability. This allows the client to be completely unaware of the implementation, promoting loose coupling and enhancing flexibility.
In the given code, the InvoiceGenerator class is the client that uses the TaxCalculator interface to calculate tax. The TaxCalculator interface is implemented by two classes: ForeignTaxCalculator and DomesticTaxCalculator. These implementations are injected into the InvoiceGenerator class at runtime, demonstrating the Separated Interface pattern.
Let's break down the code:
First, we have the TaxCalculator interface. This interface defines a single method calculate that takes an amount and returns the calculated tax.
public interface TaxCalculator {
double calculate(double amount);
}
Next, we have two classes ForeignTaxCalculator and DomesticTaxCalculator that implement the TaxCalculator interface. These classes provide the concrete logic for tax calculation.
public class ForeignTaxCalculator implements TaxCalculator {
public static final double TAX_PERCENTAGE = 60;
@Override
public double calculate(double amount) {
return amount * TAX_PERCENTAGE / 100.0;
}
}
public class DomesticTaxCalculator implements TaxCalculator {
public static final double TAX_PERCENTAGE = 20;
@Override
public double calculate(double amount) {
return amount * TAX_PERCENTAGE / 100.0;
}
}
The InvoiceGenerator class is the client that uses the TaxCalculator interface. It doesn't know about the concrete implementations of the TaxCalculator interface. It just knows that it has a TaxCalculator that can calculate tax.
public class InvoiceGenerator {
private final TaxCalculator taxCalculator;
private final double amount;
public InvoiceGenerator(double amount, TaxCalculator taxCalculator) {
this.amount = amount;
this.taxCalculator = taxCalculator;
}
public double getAmountWithTax() {
return amount + taxCalculator.calculate(amount);
}
}
Finally, in the App class, we create instances of InvoiceGenerator with different TaxCalculator implementations. This demonstrates how the Separated Interface pattern allows us to inject different implementations at runtime.
public class App {
public static final double PRODUCT_COST = 50.0;
public static void main(String[] args) {
var internationalProductInvoice = new InvoiceGenerator(PRODUCT_COST, new ForeignTaxCalculator());
LOGGER.info("Foreign Tax applied: {}", "" + internationalProductInvoice.getAmountWithTax());
var domesticProductInvoice = new InvoiceGenerator(PRODUCT_COST, new DomesticTaxCalculator());
LOGGER.info("Domestic Tax applied: {}", "" + domesticProductInvoice.getAmountWithTax());
}
}
Console output:
11:38:53.208 [main] INFO com.iluwatar.separatedinterface.App -- Foreign Tax applied: 80.0
11:38:53.210 [main] INFO com.iluwatar.separatedinterface.App -- Domestic Tax applied: 60.0
In this way, the Separated Interface pattern allows us to decouple the interface of a component from its implementation, enhancing flexibility and maintainability and making it ideal for dynamic Java application environments.
Benefits:
Trade-offs: