public class RefEx { public static class PdfProcessor implements DocumentProcessor { } public static class DocxProcessor implements DocumentProcessor { @Override public void process(Document document) { // Specific logic for processing Word } } public static class XmlProcessor implements DocumentProcessor { @Override public void process(Document document) { // Specific logic for processing XML } } public static class DocumentService { private final Map<DocumentType, DocumentProcessor> processors = Map.of( DocumentType.PDF, new PdfProcessor(), DocumentType.DOCX, new DocxProcessor(), DocumentType.XML, new XmlProcessor() ); public void process(Document[] documents) { for (Document doc : documents) { DocumentProcessor processor = processors.get(doc.type); if (processor == null) { break; } // General document processing logic processor.process(doc); } } } }

The provided code implements the strategy pattern for handling different document types. There is an interface DocumentProcessor (not shown, but implied), which is implemented by specific processors for PDF, DOCX, and XML.

In the DocumentService class, a dictionary processors stores the key as the document type and the value as the corresponding processor. The process method iterates over an array of documents, selects the appropriate processor by type, and calls its process method.

This approach allows easy extension to support new formats by adding new processor classes and updating the map. The general processing logic is encapsulated in the service, while specific logic resides in separate classes.

Example of interface and usage:

public interface DocumentProcessor {
    void process(Document document);
}

// In DocumentService
public void process(Document[] documents) {
    for (Document doc : documents) {
        DocumentProcessor processor = processors.get(doc.type);
        if (processor == null) {
            break; // or throw an exception
        }
        // General logic
        processor.process(doc);
    }
}

This is a classic example of using polymorphism and inversion of control for a flexible architecture.