Polymorphism Patterns in Practice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Polymorphic collection: typed to interface, contains various implementations
List<Drawable> canvas = new ArrayList<>();
 
// Add different shapes—all implement Drawable
canvas.add(new Circle(50, 50, 25));        // Circle implementation
canvas.add(new Rectangle(100, 100, 50, 30)); // Rectangle implementation
canvas.add(new Line(0, 0, 200, 200));       // Line implementation
canvas.add(new Text("Hello", 150, 50));     // Text implementation
 
// Polymorphic iteration: each element draws itself its own way
for (Drawable shape : canvas) {
    shape.draw(graphics);  // Dynamic dispatch to each type's draw() method
}
 
// What happens at runtime:
// 1. Circle.draw() is called for the first element
// 2. Rectangle.draw() is called for the second element
// 3. Line.draw() is called for the third element
// 4. Text.draw() is called for the fourth element
 
// The loop code doesn't know or care about concrete types
// It works with the Drawable interface only

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// Step 1: Define the common interface
interface NotificationChannel {
    void send(Notification notification);
    boolean isAvailable();
    String getChannelName();
}
 
// Step 2: Implement concrete channels
class EmailChannel implements NotificationChannel {
    private final EmailService emailService;
    
    public EmailChannel(EmailService emailService) {
        this.emailService = emailService;
    }
    
    @Override
    public void send(Notification notification) {
        emailService.sendEmail(
            notification.getRecipient().getEmail(),
            notification.getSubject(),
            notification.getMessage()
        );
    }
    
    @Override
    public boolean isAvailable() {
        return emailService.isConnected();
    }
    
    @Override
    public String getChannelName() {
        return "Email";
    }
}
 
class SmsChannel implements NotificationChannel {
    private final SmsGateway smsGateway;
    
    public SmsChannel(SmsGateway smsGateway) {
        this.smsGateway = smsGateway;
    }
    
    @Override
    public void send(Notification notification) {
        smsGateway.sendSms(
            notification.getRecipient().getPhoneNumber(),
            notification.getMessage()
        );
    }
    
    @Override
    public boolean isAvailable() {
        return smsGateway.hasCredits();
    }
    
    @Override
    public String getChannelName() {
        return "SMS";
    }
}
 
class PushNotificationChannel implements NotificationChannel {
    private final PushService pushService;
    
    public PushNotificationChannel(PushService pushService) {
        this.pushService = pushService;
    }
    
    @Override
    public void send(Notification notification) {
        pushService.sendPush(
            notification.getRecipient().getDeviceTokens(),
            notification.getTitle(),
            notification.getMessage()
        );
    }
    
    @Override
    public boolean isAvailable() {
        return true;  // Push is always available
    }
    
    @Override
    public String getChannelName() {
        return "Push Notification";
    }
}
 
class SlackChannel implements NotificationChannel {
    private final SlackClient slackClient;
    private final String channelId;
    
    public SlackChannel(SlackClient slackClient, String channelId) {
        this.slackClient = slackClient;
        this.channelId = channelId;
    }
    
    @Override
    public void send(Notification notification) {
        slackClient.postMessage(channelId, notification.getMessage());
    }
    
    @Override
    public boolean isAvailable() {
        return slackClient.isAuthenticated();
    }
    
    @Override
    public String getChannelName() {
        return "Slack";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// Step 3: Use polymorphic collection
class NotificationService {
    private final List<NotificationChannel> channels;
    private final Logger logger;
    
    public NotificationService(List<NotificationChannel> channels) {
        this.channels = channels;
        this.logger = LoggerFactory.getLogger(getClass());
    }
    
    // Send through all available channels
    public void broadcast(Notification notification) {
        for (NotificationChannel channel : channels) {
            if (channel.isAvailable()) {
                try {
                    channel.send(notification);  // Polymorphic call
                    logger.info("Sent via {}", channel.getChannelName());
                } catch (Exception e) {
                    logger.error("Failed to send via {}: {}", 
                                 channel.getChannelName(), e.getMessage());
                }
            } else {
                logger.warn("{} is not available", channel.getChannelName());
            }
        }
    }
    
    // Send through first available channel
    public boolean sendFirst(Notification notification) {
        for (NotificationChannel channel : channels) {
            if (channel.isAvailable()) {
                try {
                    channel.send(notification);  // Polymorphic call
                    return true;
                } catch (Exception e) {
                    // Try next channel
                }
            }
        }
        return false;  // All channels failed
    }
    
    // Get status of all channels
    public Map<String, Boolean> getChannelStatus() {
        Map<String, Boolean> status = new LinkedHashMap<>();
        for (NotificationChannel channel : channels) {
            status.put(channel.getChannelName(), channel.isAvailable());
        }
        return status;
    }
}
 
// Usage: configure which channels to use
List<NotificationChannel> channels = new ArrayList<>();
channels.add(new EmailChannel(emailService));
channels.add(new SmsChannel(smsGateway));
channels.add(new PushNotificationChannel(pushService));
channels.add(new SlackChannel(slackClient, "#alerts"));
 
NotificationService notificationService = new NotificationService(channels);
 
// Broadcast goes to ALL channels
notificationService.broadcast(urgentNotification);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Six months later: add Discord support
class DiscordChannel implements NotificationChannel {
    private final DiscordWebhook webhook;
    
    public DiscordChannel(DiscordWebhook webhook) {
        this.webhook = webhook;
    }
    
    @Override
    public void send(Notification notification) {
        webhook.send(new DiscordEmbed(
            notification.getTitle(),
            notification.getMessage(),
            notification.getSeverity().getColor()
        ));
    }
    
    @Override
    public boolean isAvailable() {
        return webhook.isConfigured();
    }
    
    @Override
    public String getChannelName() {
        return "Discord";
    }
}
 
// Adding the new channel requires NO changes to NotificationService
channels.add(new DiscordChannel(discordWebhook));
 
// The notification service automatically supports Discord now
// It iterates over all channels including the new one
notificationService.broadcast(notification);
 
// This is the Open/Closed Principle in action:
// - Open for extension: new channels can be added
// - Closed for modification: NotificationService code unchanged

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// PATTERN 1: Apply to All (Broadcast)
// Execute the same operation on every element
for (Validator validator : validators) {
    validator.validate(input);  // Each validator checks differently
}
 
// PATTERN 2: Filter and Process
// Process only elements meeting criteria
for (Task task : tasks) {
    if (task.isReady()) {        // Polymorphic check
        task.execute();          // Polymorphic execution
    }
}
 
// PATTERN 3: Find First Match
// Return the first element that succeeds
for (Handler handler : handlers) {
    if (handler.canHandle(request)) {   // Polymorphic check
        return handler.handle(request); // Polymorphic handling
    }
}
throw new NoHandlerException(request);
 
// PATTERN 4: Chain of Responsibility
// Pass through all handlers that can contribute
Object result = request;
for (Processor processor : processors) {
    result = processor.process(result);  // Each transforms the result
}
return result;
 
// PATTERN 5: Collect Results
// Gather results from all elements
List<Result> results = new ArrayList<>();
for (Analyzer analyzer : analyzers) {
    Result r = analyzer.analyze(data);   // Each analyzes differently
    results.add(r);
}
return aggregateResults(results);
 
// PATTERN 6: Vote/Consensus
// Combine decisions from multiple sources
int yesVotes = 0;
for (Decider decider : deciders) {
    if (decider.decide(proposal)) {      // Each decides differently
        yesVotes++;
    }
}
return yesVotes > deciders.size() / 2;   // Majority wins

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Polymorphic collection
List<Shape> shapes = getShapes();  // Contains circles, rectangles, triangles, etc.
 
// Calculate total area (polymorphic area() calls)
double totalArea = shapes.stream()
    .mapToDouble(Shape::area)  // Each shape calculates its own area
    .sum();
 
// Filter by area and sort by perimeter
List<Shape> largeShapesSorted = shapes.stream()
    .filter(s -> s.area() > 100)         // Polymorphic filter
    .sorted(Comparator.comparingDouble(Shape::perimeter)) // Polymorphic sort
    .collect(Collectors.toList());
 
// Group shapes by type (using polymorphic getType())
Map<ShapeType, List<Shape>> shapesByType = shapes.stream()
    .collect(Collectors.groupingBy(Shape::getType));
 
// Find any shape that contains a point
Optional<Shape> containingShape = shapes.stream()
    .filter(s -> s.contains(point))      // Polymorphic containment check
    .findFirst();
 
// Parallel polymorphic processing
double averageArea = shapes.parallelStream()
    .mapToDouble(Shape::area)            // Parallel polymorphic calls
    .average()
    .orElse(0.0);
 
// Complex pipeline: transform, filter, collect
List<ShapeInfo> shapeInfos = shapes.stream()
    .filter(Shape::isVisible)            // Polymorphic visibility check
    .map(s -> new ShapeInfo(
        s.getType(),                      // Polymorphic type
        s.area(),                         // Polymorphic area
        s.perimeter(),                    // Polymorphic perimeter
        s.getBoundingBox()                // Polymorphic bounds
    ))
    .sorted(Comparator.comparingDouble(ShapeInfo::getArea).reversed())
    .collect(Collectors.toList());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// APPROACH 1: instanceof checks (sometimes necessary, often avoidable)
for (Shape shape : shapes) {
    if (shape instanceof Circle) {
        Circle circle = (Circle) shape;
        System.out.println("Circle radius: " + circle.getRadius());
    } else if (shape instanceof Rectangle) {
        Rectangle rect = (Rectangle) shape;
        System.out.println("Rectangle dimensions: " 
            + rect.getWidth() + "x" + rect.getHeight());
    }
}
// Problem: Violates Open/Closed—new types require new branches
 
// ============================================
 
// APPROACH 2: Pattern matching (Java 16+)
for (Shape shape : shapes) {
    switch (shape) {
        case Circle c -> System.out.println("Radius: " + c.getRadius());
        case Rectangle r -> System.out.println("Area: " + r.getWidth() * r.getHeight());
        case Triangle t -> System.out.println("Base: " + t.getBase());
        default -> System.out.println("Unknown shape");
    }
}
// Cleaner syntax, but still requires modification for new types
 
// ============================================
 
// APPROACH 3: Visitor pattern (when type-specific operations are common)
interface ShapeVisitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
    void visit(Triangle triangle);
}
 
interface Shape {
    void accept(ShapeVisitor visitor);  // Double dispatch
}
 
class Circle implements Shape {
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this);  // Calls visit(Circle)
    }
}
 
class ShapeInfoPrinter implements ShapeVisitor {
    @Override
    public void visit(Circle circle) {
        System.out.println("Circle with radius: " + circle.getRadius());
    }
    
    @Override
    public void visit(Rectangle rectangle) {
        System.out.println("Rectangle: " + rectangle.getWidth() 
                         + "x" + rectangle.getHeight());
    }
    
    @Override
    public void visit(Triangle triangle) {
        System.out.println("Triangle with base: " + triangle.getBase());
    }
}
 
// Usage
ShapeVisitor printer = new ShapeInfoPrinter();
for (Shape shape : shapes) {
    shape.accept(printer);  // Type-specific behavior without instanceof
}
 
// ============================================
 
// APPROACH 4: Polymorphic method (best when possible)
// Add the operation to the interface
interface Shape {
    String getDescription();  // Each type describes itself
}
 
class Circle implements Shape {
    @Override
    public String getDescription() {
        return "Circle with radius: " + radius;
    }
}
 
// Now type-specific logic is encapsulated in each class
for (Shape shape : shapes) {
    System.out.println(shape.getDescription());  // No type checking needed
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// Spring's Filter chain processes HTTP requests
// Each filter is called in order—polymorphic doFilter() calls
public class FilterChainProxy implements Filter {
    private List<Filter> filters;
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        // Wrap in virtual filter chain
        VirtualFilterChain virtualChain = new VirtualFilterChain(chain, filters);
        virtualChain.doFilter(request, response);
    }
    
    private class VirtualFilterChain implements FilterChain {
        private final List<Filter> additionalFilters;
        private int currentPosition = 0;
        
        @Override
        public void doFilter(ServletRequest request, ServletResponse response) {
            if (currentPosition < additionalFilters.size()) {
                Filter nextFilter = additionalFilters.get(currentPosition++);
                nextFilter.doFilter(request, response, this);  // Polymorphic call
            } else {
                originalChain.doFilter(request, response);
            }
        }
    }
}
 
// ============================================
 
// JUnit 5 extension mechanism
public class JupiterTestEngine {
    private List<Extension> extensions;
    
    public void executeTest(TestDescriptor descriptor) {
        // Notify all extensions before test
        for (Extension extension : extensions) {
            if (extension instanceof BeforeEachCallback) {
                ((BeforeEachCallback) extension).beforeEach(context);
            }
        }
        
        // Run test
        invoke(descriptor);
        
        // Notify all extensions after test
        for (Extension extension : extensions) {
            if (extension instanceof AfterEachCallback) {
                ((AfterEachCallback) extension).afterEach(context);
            }
        }
    }
}
 
// ============================================
 
// Jackson module registration for JSON processing
ObjectMapper mapper = new ObjectMapper();
mapper.registerModules(
    new JavaTimeModule(),      // Date/time support
    new Jdk8Module(),          // Optional support  
    new ParameterNamesModule() // Parameter name access
);
 
// Internally, Jackson iterates over modules:
for (Module module : registeredModules) {
    module.setupModule(context);  // Each module configures itself
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

// Good interface design: all methods meaningful for all implementations
interface PaymentProcessor {
    boolean supports(PaymentMethod method);  // All processors can check this
    PaymentResult process(Payment payment);   // All processors can do this
    void refund(String transactionId);        // All processors can refund
}
 
// Bad interface design: some methods don't apply to all implementations
interface PaymentProcessor {
    PaymentResult process(Payment payment);
    void setApiKey(String key);      // Not all need API keys
    void configureBankAccount(...);   // Only bank transfers need this
    CryptoWallet getWallet();         // Only crypto payments have wallets
}
 
// ============================================
 
// Immutable collection for safety
public class ValidationService {
    private final List<Validator> validators;
    
    public ValidationService(List<Validator> validators) {
        // Defensive copy to immutable list
        this.validators = List.copyOf(validators);
    }
    
    public ValidationResult validate(Input input) {
        // Safe iteration—collection can't be modified
        for (Validator v : validators) {
            // ...
        }
    }
}
 
// ============================================
 
// Error handling: continue despite failures
public class MultiNotifier {
    private final List<Notifier> notifiers;
    
    public NotificationReport notifyAll(Event event) {
        List<String> successes = new ArrayList<>();
        List<String> failures = new ArrayList<>();
        
        for (Notifier n : notifiers) {
            try {
                n.notify(event);
                successes.add(n.getName());
            } catch (Exception e) {
                failures.add(n.getName() + ": " + e.getMessage());
                // Continue with remaining notifiers
            }
        }
        
        return new NotificationReport(successes, failures);
    }
}