System Design (LLD)Polymorphism Patterns in Practice

Polymorphism Patterns in Practice

LevelIntermediate

Duration60 mins

TopicPolymorphism Patterns in Practice

4 / 4

Real-World Polymorphism Examples

Polymorphism in Production

Throughout this module, we've explored individual polymorphism patterns—factory methods, strategies, and polymorphic collections. In real-world systems, these patterns rarely exist in isolation. They combine, layer, and interact to create architectures that are simultaneously flexible, testable, and maintainable.

This page presents comprehensive case studies from production systems, showing how polymorphism patterns work together to solve complex design challenges. These aren't theoretical examples—they're simplified versions of architectures used by major technology companies processing millions of requests daily.

By studying how polymorphism manifests in real systems, you'll develop the intuition to recognize opportunities for polymorphic design in your own work.

What You Will Learn

By the end of this page, you will see polymorphism in action across multiple domains: payment processing, content rendering, plugin architectures, and rule engines. You'll understand how polymorphism patterns combine to create elegant solutions to complex problems.

Case Study: Payment Processing System

Payment processing is one of the most demanding domains for software design. Systems must support multiple payment methods (credit cards, PayPal, Apple Pay, cryptocurrency), multiple currencies, various fraud detection rules, and evolving regulatory requirements—all while processing transactions reliably and securely.

Let's examine how a production payment system uses polymorphism at every layer:

PaymentSystemArchitecture.java
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
// LAYER 1: Payment Method Polymorphism
// Each payment method implements a common interface
interface PaymentMethod {
    PaymentMethodType getType();
    boolean isValid();
    String getMaskedIdentifier();  // "****4242" for card, "j***@email.com" for PayPal
    Map<String, Object> getMetadata();
}
 
class CreditCard implements PaymentMethod {
    private final String number;
    private final String expiryMonth;
    private final String expiryYear;
    private final String cvv;
    
    @Override
    public PaymentMethodType getType() { return PaymentMethodType.CREDIT_CARD; }
    
    @Override
    public boolean isValid() {
        return LuhnValidator.isValid(number) 
            && !isExpired() 
            && cvv.length() >= 3;
    }
    
    @Override
    public String getMaskedIdentifier() {
        return "****" + number.substring(number.length() - 4);
    }
}
 
class PayPalAccount implements PaymentMethod {
    private final String email;
    private final String authorizationCode;
    
    @Override
    public PaymentMethodType getType() { return PaymentMethodType.PAYPAL; }
    
    @Override
    public boolean isValid() {
        return email != null && authorizationCode != null;
    }
    
    @Override
    public String getMaskedIdentifier() {
        String[] parts = email.split("@");
        return parts[0].charAt(0) + "***@" + parts[1];
    }
}
 
class CryptoWallet implements PaymentMethod {
    private final String walletAddress;
    private final CryptoCurrency currency;
    
    // Similar implementation...
}
 
// LAYER 2: Payment Processor Strategy
// Different processors for different payment methods
interface PaymentProcessor {
    boolean supports(PaymentMethod method);
    ProcessorResult charge(PaymentMethod method, Money amount);
    ProcessorResult refund(String transactionId, Money amount);
    ProcessorResult authorize(PaymentMethod method, Money amount);
    ProcessorResult capture(String authorizationId);
}
 
class StripeProcessor implements PaymentProcessor {
    private final StripeClient stripeClient;
    
    @Override
    public boolean supports(PaymentMethod method) {
        return method.getType() == PaymentMethodType.CREDIT_CARD
            || method.getType() == PaymentMethodType.APPLE_PAY;
    }
    
    @Override
    public ProcessorResult charge(PaymentMethod method, Money amount) {
        // Stripe-specific API calls
        StripeCharge charge = stripeClient.charges().create(
            new ChargeCreateParams.Builder()
                .setAmount(amount.toCents())
                .setCurrency(amount.getCurrency().getCode())
                .setSource(toStripeToken(method))
                .build()
        );
        return mapToResult(charge);
    }
}
 
class PayPalProcessor implements PaymentProcessor {
    private final PayPalClient paypalClient;
    
    @Override
    public boolean supports(PaymentMethod method) {
        return method.getType() == PaymentMethodType.PAYPAL;
    }
    
    @Override
    public ProcessorResult charge(PaymentMethod method, Money amount) {
        // PayPal-specific API calls...
    }
}
 
class CoinbaseProcessor implements PaymentProcessor {
    // Crypto-specific implementation...
}

The system continues with polymorphic fraud detection, validation, and routing:

PaymentSystemContinued.java
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
// LAYER 3: Fraud Detection Rules (Polymorphic Collection)
interface FraudRule {
    FraudScore evaluate(PaymentContext context);
    String getRuleName();
    boolean isBlocking();  // If true, high score immediately rejects
}
 
class VelocityRule implements FraudRule {
    @Override
    public FraudScore evaluate(PaymentContext context) {
        int recentAttempts = countRecentAttempts(context.getCustomerId());
        if (recentAttempts > 10) return FraudScore.high("Too many attempts");
        if (recentAttempts > 5) return FraudScore.medium("Elevated velocity");
        return FraudScore.low();
    }
}
 
class GeolocationRule implements FraudRule {
    @Override
    public FraudScore evaluate(PaymentContext context) {
        Location cardLocation = context.getCardIssuingCountry();
        Location ipLocation = context.getIpLocation();
        if (!cardLocation.isSameContinent(ipLocation)) {
            return FraudScore.high("Geographic mismatch");
        }
        return FraudScore.low();
    }
}
 
class DeviceFingerprintRule implements FraudRule {
    @Override
    public FraudScore evaluate(PaymentContext context) {
        if (isKnownFraudDevice(context.getDeviceFingerprint())) {
            return FraudScore.critical("Known fraud device");
        }
        return FraudScore.low();
    }
}
 
// LAYER 4: Payment Service orchestrates everything
class PaymentService {
    private final List<PaymentProcessor> processors;  // Polymorphic collection
    private final List<FraudRule> fraudRules;         // Polymorphic collection
    private final PaymentRepository repository;
    
    public PaymentResult processPayment(PaymentRequest request) {
        // 1. Validate payment method polymorphically
        if (!request.getPaymentMethod().isValid()) {
            return PaymentResult.invalid("Payment method validation failed");
        }
        
        // 2. Run fraud checks polymorphically
        PaymentContext context = buildContext(request);
        FraudScore totalScore = FraudScore.zero();
        
        for (FraudRule rule : fraudRules) {
            FraudScore score = rule.evaluate(context);  // Polymorphic call
            totalScore = totalScore.add(score);
            
            if (rule.isBlocking() && score.isCritical()) {
                return PaymentResult.rejected(score.getReason());
            }
        }
        
        if (totalScore.isAboveThreshold()) {
            return PaymentResult.reviewRequired(totalScore);
        }
        
        // 3. Find appropriate processor polymorphically
        PaymentProcessor processor = findProcessor(request.getPaymentMethod());
        if (processor == null) {
            return PaymentResult.unsupported("No processor for payment method");
        }
        
        // 4. Process payment polymorphically
        ProcessorResult result = processor.charge(
            request.getPaymentMethod(),
            request.getAmount()
        );
        
        // 5. Store result
        Payment payment = Payment.from(request, result);
        repository.save(payment);
        
        return PaymentResult.from(result);
    }
    
    private PaymentProcessor findProcessor(PaymentMethod method) {
        for (PaymentProcessor processor : processors) {
            if (processor.supports(method)) {  // Polymorphic check
                return processor;
            }
        }
        return null;
    }
}

Polymorphism Everywhere

Notice how polymorphism appears at every layer: payment methods implement a common interface, processors use the Strategy pattern, fraud rules form a polymorphic collection, and the service orchestrates them all through abstract interfaces. Adding a new payment method, processor, or fraud rule requires no changes to PaymentService.

Case Study: Content Management System

Content management systems must render diverse content types—text, images, videos, code blocks, embeds, interactive widgets—in a unified way. Let's examine how a CMS like those used by major publishing platforms leverages polymorphism:

ContentRenderingSystem.java
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
113
114
115
116
117
118
119
120
121
122
123
// Core content block interface
interface ContentBlock {
    String getBlockType();
    JsonObject toJson();
    String renderHtml(RenderContext context);
    String renderPlainText();  // For email, search indexing
    boolean isMediaBlock();
    Set<String> extractUrls();  // For link checking, prefetching
}
 
// Text content with rich formatting
class RichTextBlock implements ContentBlock {
    private final List<TextNode> nodes;  // Paragraphs, headings, lists
    
    @Override
    public String renderHtml(RenderContext context) {
        StringBuilder html = new StringBuilder();
        for (TextNode node : nodes) {
            html.append(node.toHtml());  // Nested polymorphism!
        }
        return html.toString();
    }
    
    @Override
    public String renderPlainText() {
        return nodes.stream()
            .map(TextNode::toPlainText)
            .collect(Collectors.joining("
"));
    }
}
 
// Image with responsive variants
class ImageBlock implements ContentBlock {
    private final String src;
    private final String alt;
    private final Map<String, String> responsiveSources;
    
    @Override
    public String renderHtml(RenderContext context) {
        StringBuilder html = new StringBuilder();
        html.append("<picture>");
        
        for (var entry : responsiveSources.entrySet()) {
            html.append(String.format(
                "<source srcset="%s" media="%s">",
                context.transformUrl(entry.getValue()),
                entry.getKey()
            ));
        }
        
        html.append(String.format(
            "<img src="%s" alt="%s" loading="lazy">",
            context.transformUrl(src), 
            escapeHtml(alt)
        ));
        html.append("</picture>");
        
        return html.toString();
    }
    
    @Override
    public boolean isMediaBlock() { return true; }
}
 
// Code block with syntax highlighting
class CodeBlock implements ContentBlock {
    private final String code;
    private final String language;
    private final boolean showLineNumbers;
    
    @Override
    public String renderHtml(RenderContext context) {
        SyntaxHighlighter highlighter = context.getHighlighter(language);
        String highlighted = highlighter.highlight(code);
        
        return String.format(
            "<pre class="language-%s"><code>%s</code></pre>",
            language, highlighted
        );
    }
}
 
// Embedded content (YouTube, Twitter, etc.)
class EmbedBlock implements ContentBlock {
    private final String embedType;  // youtube, twitter, etc.
    private final String embedId;
    private final Map<String, Object> options;
    
    private static final Map<String, EmbedRenderer> renderers = Map.of(
        "youtube", new YouTubeEmbedRenderer(),
        "twitter", new TwitterEmbedRenderer(),
        "codepen", new CodePenEmbedRenderer()
    );
    
    @Override
    public String renderHtml(RenderContext context) {
        EmbedRenderer renderer = renderers.get(embedType);
        if (renderer == null) {
            return renderFallback();
        }
        return renderer.render(embedId, options, context);
    }
}
 
// Interactive widget (polls, quizzes, etc.)
class InteractiveBlock implements ContentBlock {
    private final String widgetType;
    private final JsonObject configuration;
    
    @Override
    public String renderHtml(RenderContext context) {
        // Render placeholder that JavaScript will hydrate
        return String.format(
            "<div class="interactive-widget" " +
            "data-widget-type="%s" " +
            "data-config='%s'>" +
            "<noscript>Interactive content requires JavaScript</noscript>" +
            "</div>",
            widgetType, configuration.toString()
        );
    }
}

The article renderer processes all blocks polymorphically:

ArticleRenderer.java
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
// Article composed of polymorphic content blocks
class Article {
    private final String id;
    private final String title;
    private final List<ContentBlock> blocks;  // Polymorphic collection
    private final Author author;
    private final Instant publishedAt;
    
    // Factory method with polymorphic deserialization
    public static Article fromJson(JsonObject json) {
        List<ContentBlock> blocks = new ArrayList<>();
        
        for (JsonObject blockJson : json.getArray("blocks")) {
            ContentBlock block = ContentBlockFactory.create(blockJson);
            blocks.add(block);
        }
        
        return new Article(
            json.getString("id"),
            json.getString("title"),
            blocks,
            Author.fromJson(json.getObject("author")),
            Instant.parse(json.getString("publishedAt"))
        );
    }
}
 
// Factory for creating appropriate block types
class ContentBlockFactory {
    private static final Map<String, BlockCreator> creators = Map.of(
        "rich-text", RichTextBlock::fromJson,
        "image", ImageBlock::fromJson,
        "code", CodeBlock::fromJson,
        "embed", EmbedBlock::fromJson,
        "interactive", InteractiveBlock::fromJson
    );
    
    public static ContentBlock create(JsonObject json) {
        String type = json.getString("type");
        BlockCreator creator = creators.get(type);
        
        if (creator == null) {
            return new UnknownBlock(json);  // Graceful degradation
        }
        
        return creator.create(json);
    }
}
 
// Render service processes articles
class ArticleRenderer {
    public String renderToHtml(Article article) {
        RenderContext context = createContext(article);
        
        StringBuilder html = new StringBuilder();
        html.append("<article>");
        html.append("<h1>").append(article.getTitle()).append("</h1>");
        
        // Polymorphic rendering of each block
        for (ContentBlock block : article.getBlocks()) {
            html.append("<div class="block block-")
                .append(block.getBlockType())
                .append("">");
            html.append(block.renderHtml(context));  // Polymorphic call
            html.append("</div>");
        }
        
        html.append("</article>");
        return html.toString();
    }
    
    // Same blocks, different output format
    public String renderToPlainText(Article article) {
        StringBuilder text = new StringBuilder();
        text.append(article.getTitle()).append("
 
");
        
        for (ContentBlock block : article.getBlocks()) {
            text.append(block.renderPlainText());  // Polymorphic call
            text.append("
 
");
        }
        
        return text.toString();
    }
    
    // Extract all media for prefetching
    public List<String> extractMediaUrls(Article article) {
        return article.getBlocks().stream()
            .filter(ContentBlock::isMediaBlock)  // Polymorphic check
            .flatMap(b -> b.extractUrls().stream())  // Polymorphic extraction
            .distinct()
            .collect(Collectors.toList());
    }
}

Multiple Rendering Targets

The polymorphic design allows the same article to be rendered to HTML, plain text, AMP, email, or any other format by simply calling different methods on each block. Adding a new block type (e.g., 3D model viewer) requires only a new class—no changes to the renderer.

Case Study: Plugin Architecture

Plugin architectures enable applications to be extended without modifying core code. IDEs, build tools, and content management systems all use plugin architectures built on polymorphism. Here's how a build tool like Maven or Gradle might structure its plugin system:

PluginArchitecture.java
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
// Core plugin interface
interface BuildPlugin {
    String getName();
    String getVersion();
    
    // Lifecycle hooks
    void initialize(BuildContext context);
    void beforeBuild(BuildContext context);
    void afterBuild(BuildContext context);
    void cleanup(BuildContext context);
    
    // Extension points
    List<Task> getTasks();
    List<ConfigurationExtension> getConfigurationExtensions();
}
 
// Abstract base with default implementations
abstract class AbstractBuildPlugin implements BuildPlugin {
    @Override
    public void initialize(BuildContext context) { }
    
    @Override
    public void beforeBuild(BuildContext context) { }
    
    @Override
    public void afterBuild(BuildContext context) { }
    
    @Override
    public void cleanup(BuildContext context) { }
    
    @Override
    public List<ConfigurationExtension> getConfigurationExtensions() {
        return Collections.emptyList();
    }
}
 
// Concrete plugins
class JavaCompilerPlugin extends AbstractBuildPlugin {
    @Override
    public String getName() { return "java-compiler"; }
    
    @Override
    public String getVersion() { return "2.1.0"; }
    
    @Override
    public List<Task> getTasks() {
        return List.of(
            new CompileJavaTask(),
            new CompileTestJavaTask()
        );
    }
    
    @Override
    public void initialize(BuildContext context) {
        context.registerSourceSet("main/java");
        context.registerSourceSet("test/java");
    }
}
 
class DockerPlugin extends AbstractBuildPlugin {
    @Override
    public String getName() { return "docker"; }
    
    @Override
    public String getVersion() { return "1.5.0"; }
    
    @Override
    public List<Task> getTasks() {
        return List.of(
            new DockerBuildTask(),
            new DockerPushTask(),
            new DockerComposeUpTask()
        );
    }
    
    @Override
    public List<ConfigurationExtension> getConfigurationExtensions() {
        return List.of(new DockerConfigurationExtension());
    }
}
 
class TestCoveragePlugin extends AbstractBuildPlugin {
    @Override
    public String getName() { return "coverage"; }
    
    @Override
    public void afterBuild(BuildContext context) {
        // Generate coverage report after build completes
        CoverageReport report = generateReport(context);
        context.getOutputDirectory().resolve("coverage").write(report);
    }
}

The build engine orchestrates plugins polymorphically:

BuildEngine.java
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
// Build engine coordinates plugins
class BuildEngine {
    private final List<BuildPlugin> plugins;  // Polymorphic collection
    private final TaskExecutor taskExecutor;
    private final PluginLoader pluginLoader;
    
    public BuildEngine(BuildConfiguration config) {
        // Load plugins from configuration
        this.plugins = new ArrayList<>();
        for (String pluginId : config.getPlugins()) {
            BuildPlugin plugin = pluginLoader.load(pluginId);
            plugins.add(plugin);
        }
        this.taskExecutor = new TaskExecutor();
    }
    
    public BuildResult build(List<String> taskNames) {
        BuildContext context = createContext();
        
        try {
            // Phase 1: Initialize all plugins
            for (BuildPlugin plugin : plugins) {
                plugin.initialize(context);  // Polymorphic initialization
            }
            
            // Phase 2: Collect all tasks from plugins
            Map<String, Task> allTasks = new LinkedHashMap<>();
            for (BuildPlugin plugin : plugins) {
                for (Task task : plugin.getTasks()) {  // Polymorphic task collection
                    allTasks.put(task.getName(), task);
                }
            }
            
            // Phase 3: Before build hooks
            for (BuildPlugin plugin : plugins) {
                plugin.beforeBuild(context);  // Polymorphic hook
            }
            
            // Phase 4: Execute requested tasks
            for (String taskName : taskNames) {
                Task task = allTasks.get(taskName);
                if (task == null) {
                    throw new UnknownTaskException(taskName);
                }
                taskExecutor.execute(task, context);
            }
            
            // Phase 5: After build hooks
            for (BuildPlugin plugin : plugins) {
                plugin.afterBuild(context);  // Polymorphic hook
            }
            
            return BuildResult.success(context.getOutputs());
            
        } catch (Exception e) {
            return BuildResult.failure(e);
            
        } finally {
            // Phase 6: Cleanup all plugins
            for (BuildPlugin plugin : plugins) {
                try {
                    plugin.cleanup(context);  // Polymorphic cleanup
                } catch (Exception e) {
                    log.warn("Plugin cleanup failed: {}", plugin.getName(), e);
                }
            }
        }
    }
}
 
// Task interface for plugin-provided tasks
interface Task {
    String getName();
    Set<String> getDependencies();  // Other tasks that must run first
    void execute(BuildContext context) throws TaskExecutionException;
}
 
// Usage: build with configured plugins
BuildConfiguration config = BuildConfiguration.load("build.yaml");
// build.yaml contains:
// plugins:
//   - java-compiler
//   - docker
//   - coverage
 
BuildEngine engine = new BuildEngine(config);
BuildResult result = engine.build(List.of("compile", "test", "dockerBuild"));

Extensibility Through Interface Contracts

Plugin architectures work because the core system defines interfaces (contracts) that plugins implement. The core never knows about specific plugins—it only works with the BuildPlugin interface. New functionality is added by creating new plugins, not by modifying the build engine.

Case Study: Business Rule Engine

Business rule engines evaluate complex business logic that changes frequently. Insurance underwriting, loan approval, promotion eligibility, and pricing all use rule engines. Polymorphism makes these engines flexible and maintainable:

RuleEngine.java
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
// Core rule interface
interface Rule<T> {
    String getRuleName();
    int getPriority();  // Higher priority rules evaluated first
    boolean appliesTo(T context);  // Does this rule apply?
    RuleResult evaluate(T context);  // What's the result?
}
 
// Insurance underwriting rules
interface UnderwritingRule extends Rule<InsuranceApplication> {
    RiskCategory getRiskCategory();  // life, property, liability, etc.
}
 
// Concrete underwriting rules
class AgeRiskRule implements UnderwritingRule {
    @Override
    public String getRuleName() { return "AGE_RISK"; }
    
    @Override
    public int getPriority() { return 100; }
    
    @Override
    public RiskCategory getRiskCategory() { return RiskCategory.LIFE; }
    
    @Override
    public boolean appliesTo(InsuranceApplication app) {
        return app.getProductType() == ProductType.LIFE_INSURANCE;
    }
    
    @Override
    public RuleResult evaluate(InsuranceApplication app) {
        int age = app.getApplicant().getAge();
        
        if (age < 18) {
            return RuleResult.decline("Applicant must be 18 or older");
        } else if (age < 30) {
            return RuleResult.approve().withPremiumModifier(0.9);
        } else if (age < 50) {
            return RuleResult.approve().withPremiumModifier(1.0);
        } else if (age < 65) {
            return RuleResult.approve().withPremiumModifier(1.3);
        } else if (age < 75) {
            return RuleResult.approve().withPremiumModifier(1.8);
        } else {
            return RuleResult.referToUnderwriter("Age over 75 requires manual review");
        }
    }
}
 
class SmokingStatusRule implements UnderwritingRule {
    @Override
    public String getRuleName() { return "SMOKING_STATUS"; }
    
    @Override
    public int getPriority() { return 90; }
    
    @Override
    public boolean appliesTo(InsuranceApplication app) {
        return app.getProductType() == ProductType.LIFE_INSURANCE
            || app.getProductType() == ProductType.HEALTH_INSURANCE;
    }
    
    @Override
    public RuleResult evaluate(InsuranceApplication app) {
        SmokingStatus status = app.getApplicant().getSmokingStatus();
        
        switch (status) {
            case NEVER:
                return RuleResult.approve().withPremiumModifier(0.85);
            case QUIT_MORE_THAN_5_YEARS:
                return RuleResult.approve().withPremiumModifier(0.95);
            case QUIT_LESS_THAN_5_YEARS:
                return RuleResult.approve().withPremiumModifier(1.15);
            case CURRENT_OCCASIONAL:
                return RuleResult.approve().withPremiumModifier(1.4);
            case CURRENT_REGULAR:
                return RuleResult.approve().withPremiumModifier(1.7);
            default:
                return RuleResult.referToUnderwriter("Unknown smoking status");
        }
    }
}
 
class PreExistingConditionRule implements UnderwritingRule {
    private final MedicalCodeDatabase medicalCodes;
    
    @Override
    public String getRuleName() { return "PRE_EXISTING_CONDITIONS"; }
    
    @Override
    public RuleResult evaluate(InsuranceApplication app) {
        List<MedicalCondition> conditions = app.getMedicalHistory().getConditions();
        
        for (MedicalCondition condition : conditions) {
            RiskLevel risk = medicalCodes.getRiskLevel(condition.getCode());
            
            if (risk == RiskLevel.UNINSURABLE) {
                return RuleResult.decline("Uninsurable condition: " + condition.getName());
            } else if (risk == RiskLevel.HIGH) {
                return RuleResult.referToUnderwriter(
                    "High-risk condition requires review: " + condition.getName()
                );
            }
        }
        
        return RuleResult.approve();
    }
}

The rule engine evaluates all applicable rules and combines results:

UnderwritingEngine.java
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
// Rule engine evaluates polymorphic rules
class UnderwritingEngine {
    private final List<UnderwritingRule> rules;  // Polymorphic collection
    
    public UnderwritingEngine(List<UnderwritingRule> rules) {
        // Sort by priority for consistent evaluation order
        this.rules = rules.stream()
            .sorted(Comparator.comparingInt(UnderwritingRule::getPriority).reversed())
            .collect(Collectors.toList());
    }
    
    public UnderwritingDecision evaluate(InsuranceApplication application) {
        List<RuleResult> results = new ArrayList<>();
        double cumulativePremiumModifier = 1.0;
        
        for (UnderwritingRule rule : rules) {
            // Check if rule applies (polymorphic)
            if (!rule.appliesTo(application)) {
                continue;
            }
            
            // Evaluate rule (polymorphic)
            RuleResult result = rule.evaluate(application);
            results.add(result);
            
            // Immediate decline exits early
            if (result.isDecline()) {
                return UnderwritingDecision.decline(
                    result.getReason(),
                    rule.getRuleName()
                );
            }
            
            // Referral pauses automatic processing
            if (result.isReferral()) {
                return UnderwritingDecision.referToUnderwriter(
                    result.getReason(),
                    results  // Include all results so far
                );
            }
            
            // Accumulate premium modifiers
            cumulativePremiumModifier *= result.getPremiumModifier();
        }
        
        // All rules passed—calculate final premium
        Money basePremium = calculateBasePremium(application);
        Money finalPremium = basePremium.multiply(cumulativePremiumModifier);
        
        return UnderwritingDecision.approve(finalPremium, results);
    }
}
 
// Usage
List<UnderwritingRule> rules = List.of(
    new AgeRiskRule(),
    new SmokingStatusRule(),
    new PreExistingConditionRule(),
    new OccupationRiskRule(),
    new GeographicRiskRule(),
    new CoverageAmountRule()
);
 
UnderwritingEngine engine = new UnderwritingEngine(rules);
UnderwritingDecision decision = engine.evaluate(application);
 
// Adding new rules is simple:
rules.add(new CovidRiskRule());  // New pandemic-related rule
rules.add(new GeneticTestingRule());  // New genetic risk assessment

Rules as Data

In production systems, rules are often loaded from databases or configuration files, not hard-coded. The polymorphic design makes this possible—the engine works with the Rule interface regardless of how rules are defined or loaded.

Polymorphism Patterns Combined

The case studies reveal how polymorphism patterns work together. Let's map the patterns we've learned to their appearances in real systems:

Pattern Usage Across Case Studies
System	Factory Method	Strategy	Polymorphic Collection
Payment Processing	PaymentMethod creation	PaymentProcessor selection	FraudRules, Processors
Content Rendering	ContentBlock factory	Block rendering strategies	Article blocks
Plugin Architecture	Plugin loading	Task execution	Plugin list
Rule Engine	Rule instantiation	Rule evaluation	Rule list

Common architectural patterns emerge:

Recurring Architectural Patterns

•Interface + implementations — Every system defines core interfaces with multiple implementations. New requirements mean new implementations, not changes to existing code.
•Factory for creation, strategy for behavior — Factories create the right implementation; strategies execute the right algorithm. Often used together in the same system.
•Collections for orchestration — The orchestrating component (PaymentService, BuildEngine, etc.) iterates over polymorphic collections without knowing concrete types.
•Configuration-driven assembly — Which implementations are used is determined by configuration, not hard-coded. DI containers or custom loaders assemble the system.
•Graceful degradation — Unknown types get default handling (UnknownBlock, fallback processor) rather than crashing.

Designing for Polymorphism

Studying these real-world systems reveals principles for designing polymorphic architectures:

Design Principles for Polymorphism

•Identify the variation points — What aspects of the system will change? New payment methods? New content types? New rules? These become interfaces.
•Define minimal, focused interfaces — Interfaces should capture the essential operations all implementations share. Avoid bloated interfaces that some implementations can't meaningfully implement.
•Make the orchestrator ignorant — The component that coordinates polymorphic objects should know only about interfaces, never about concrete types.
•Use factories for creation complexity — When object creation involves decisions (which type? what configuration?), encapsulate that in factories.
•Prefer composition over conditionals — Instead of if-else chains, compose behavior from polymorphic objects.
•Plan for unknown types — Include fallback handling for types that don't (yet) exist.
•Test through interfaces — Unit tests should work with interfaces. If tests need concrete types, the design may be too coupled.

Avoid Over-Engineering

Not every system needs this level of polymorphism. Apply these patterns when you have real variation that needs to be managed. For simple systems with one implementation and no foreseeable extensions, direct instantiation is fine. Let complexity grow organically.

Summary: Real-World Polymorphism

This page demonstrated how polymorphism patterns combine in production systems. From payment processing to content management to plugin architectures, polymorphism provides the flexibility that large-scale systems require.

Key Takeaways

•Polymorphism enables extensibility — New payment methods, content types, plugins, and rules can be added without modifying existing code.
•Patterns combine naturally — Factories create objects, strategies define behavior, collections group them—all working together.
•Orchestrators remain stable — The code that coordinates polymorphic objects rarely needs to change, even as the system evolves.
•Configuration drives behavior — Which implementations are used is determined by configuration, making systems adaptable.
•Same patterns, different domains — Payment processing, content rendering, plugins, and rules all use the same polymorphic patterns.
•Design for the interfaces, not the implementations — Focus on contracts; implementations can vary independently.

Module Complete:

You've now completed the Polymorphism Patterns in Practice module. You understand how factory methods encapsulate creation, strategies encapsulate algorithms, polymorphic collections enable heterogeneous processing, and how these patterns combine in real-world systems.

These patterns are fundamental to professional software development. As you work on larger systems, you'll recognize opportunities to apply them—and you'll appreciate the flexibility they provide when requirements inevitably change.

Module Complete

Congratulations! You've mastered polymorphism patterns in practice. You can now recognize, design, and implement polymorphic architectures that scale with your system's needs. The patterns you've learned are used daily by engineers at top technology companies worldwide.

4 / 4

Loading learning content...

System Design (LLD)Polymorphism Patterns in Practice

Polymorphism Patterns in Practice

LevelIntermediate

Duration60 mins

TopicPolymorphism Patterns in Practice

4 / 4

Real-World Polymorphism Examples

Polymorphism in Production

By studying how polymorphism manifests in real systems, you'll develop the intuition to recognize opportunities for polymorphic design in your own work.

What You Will Learn

Case Study: Payment Processing System

Let's examine how a production payment system uses polymorphism at every layer:

PaymentSystemArchitecture.java
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
// LAYER 1: Payment Method Polymorphism
// Each payment method implements a common interface
interface PaymentMethod {
    PaymentMethodType getType();
    boolean isValid();
    String getMaskedIdentifier();  // "****4242" for card, "j***@email.com" for PayPal
    Map<String, Object> getMetadata();
}
 
class CreditCard implements PaymentMethod {
    private final String number;
    private final String expiryMonth;
    private final String expiryYear;
    private final String cvv;
    
    @Override
    public PaymentMethodType getType() { return PaymentMethodType.CREDIT_CARD; }
    
    @Override
    public boolean isValid() {
        return LuhnValidator.isValid(number) 
            && !isExpired() 
            && cvv.length() >= 3;
    }
    
    @Override
    public String getMaskedIdentifier() {
        return "****" + number.substring(number.length() - 4);
    }
}
 
class PayPalAccount implements PaymentMethod {
    private final String email;
    private final String authorizationCode;
    
    @Override
    public PaymentMethodType getType() { return PaymentMethodType.PAYPAL; }
    
    @Override
    public boolean isValid() {
        return email != null && authorizationCode != null;
    }
    
    @Override
    public String getMaskedIdentifier() {
        String[] parts = email.split("@");
        return parts[0].charAt(0) + "***@" + parts[1];
    }
}
 
class CryptoWallet implements PaymentMethod {
    private final String walletAddress;
    private final CryptoCurrency currency;
    
    // Similar implementation...
}
 
// LAYER 2: Payment Processor Strategy
// Different processors for different payment methods
interface PaymentProcessor {
    boolean supports(PaymentMethod method);
    ProcessorResult charge(PaymentMethod method, Money amount);
    ProcessorResult refund(String transactionId, Money amount);
    ProcessorResult authorize(PaymentMethod method, Money amount);
    ProcessorResult capture(String authorizationId);
}
 
class StripeProcessor implements PaymentProcessor {
    private final StripeClient stripeClient;
    
    @Override
    public boolean supports(PaymentMethod method) {
        return method.getType() == PaymentMethodType.CREDIT_CARD
            || method.getType() == PaymentMethodType.APPLE_PAY;
    }
    
    @Override
    public ProcessorResult charge(PaymentMethod method, Money amount) {
        // Stripe-specific API calls
        StripeCharge charge = stripeClient.charges().create(
            new ChargeCreateParams.Builder()
                .setAmount(amount.toCents())
                .setCurrency(amount.getCurrency().getCode())
                .setSource(toStripeToken(method))
                .build()
        );
        return mapToResult(charge);
    }
}
 
class PayPalProcessor implements PaymentProcessor {
    private final PayPalClient paypalClient;
    
    @Override
    public boolean supports(PaymentMethod method) {
        return method.getType() == PaymentMethodType.PAYPAL;
    }
    
    @Override
    public ProcessorResult charge(PaymentMethod method, Money amount) {
        // PayPal-specific API calls...
    }
}
 
class CoinbaseProcessor implements PaymentProcessor {
    // Crypto-specific implementation...
}

The system continues with polymorphic fraud detection, validation, and routing:

PaymentSystemContinued.java
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
// LAYER 3: Fraud Detection Rules (Polymorphic Collection)
interface FraudRule {
    FraudScore evaluate(PaymentContext context);
    String getRuleName();
    boolean isBlocking();  // If true, high score immediately rejects
}
 
class VelocityRule implements FraudRule {
    @Override
    public FraudScore evaluate(PaymentContext context) {
        int recentAttempts = countRecentAttempts(context.getCustomerId());
        if (recentAttempts > 10) return FraudScore.high("Too many attempts");
        if (recentAttempts > 5) return FraudScore.medium("Elevated velocity");
        return FraudScore.low();
    }
}
 
class GeolocationRule implements FraudRule {
    @Override
    public FraudScore evaluate(PaymentContext context) {
        Location cardLocation = context.getCardIssuingCountry();
        Location ipLocation = context.getIpLocation();
        if (!cardLocation.isSameContinent(ipLocation)) {
            return FraudScore.high("Geographic mismatch");
        }
        return FraudScore.low();
    }
}
 
class DeviceFingerprintRule implements FraudRule {
    @Override
    public FraudScore evaluate(PaymentContext context) {
        if (isKnownFraudDevice(context.getDeviceFingerprint())) {
            return FraudScore.critical("Known fraud device");
        }
        return FraudScore.low();
    }
}
 
// LAYER 4: Payment Service orchestrates everything
class PaymentService {
    private final List<PaymentProcessor> processors;  // Polymorphic collection
    private final List<FraudRule> fraudRules;         // Polymorphic collection
    private final PaymentRepository repository;
    
    public PaymentResult processPayment(PaymentRequest request) {
        // 1. Validate payment method polymorphically
        if (!request.getPaymentMethod().isValid()) {
            return PaymentResult.invalid("Payment method validation failed");
        }
        
        // 2. Run fraud checks polymorphically
        PaymentContext context = buildContext(request);
        FraudScore totalScore = FraudScore.zero();
        
        for (FraudRule rule : fraudRules) {
            FraudScore score = rule.evaluate(context);  // Polymorphic call
            totalScore = totalScore.add(score);
            
            if (rule.isBlocking() && score.isCritical()) {
                return PaymentResult.rejected(score.getReason());
            }
        }
        
        if (totalScore.isAboveThreshold()) {
            return PaymentResult.reviewRequired(totalScore);
        }
        
        // 3. Find appropriate processor polymorphically
        PaymentProcessor processor = findProcessor(request.getPaymentMethod());
        if (processor == null) {
            return PaymentResult.unsupported("No processor for payment method");
        }
        
        // 4. Process payment polymorphically
        ProcessorResult result = processor.charge(
            request.getPaymentMethod(),
            request.getAmount()
        );
        
        // 5. Store result
        Payment payment = Payment.from(request, result);
        repository.save(payment);
        
        return PaymentResult.from(result);
    }
    
    private PaymentProcessor findProcessor(PaymentMethod method) {
        for (PaymentProcessor processor : processors) {
            if (processor.supports(method)) {  // Polymorphic check
                return processor;
            }
        }
        return null;
    }
}

Polymorphism Everywhere

Case Study: Content Management System

ContentRenderingSystem.java
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
113
114
115
116
117
118
119
120
121
122
123
// Core content block interface
interface ContentBlock {
    String getBlockType();
    JsonObject toJson();
    String renderHtml(RenderContext context);
    String renderPlainText();  // For email, search indexing
    boolean isMediaBlock();
    Set<String> extractUrls();  // For link checking, prefetching
}
 
// Text content with rich formatting
class RichTextBlock implements ContentBlock {
    private final List<TextNode> nodes;  // Paragraphs, headings, lists
    
    @Override
    public String renderHtml(RenderContext context) {
        StringBuilder html = new StringBuilder();
        for (TextNode node : nodes) {
            html.append(node.toHtml());  // Nested polymorphism!
        }
        return html.toString();
    }
    
    @Override
    public String renderPlainText() {
        return nodes.stream()
            .map(TextNode::toPlainText)
            .collect(Collectors.joining("
"));
    }
}
 
// Image with responsive variants
class ImageBlock implements ContentBlock {
    private final String src;
    private final String alt;
    private final Map<String, String> responsiveSources;
    
    @Override
    public String renderHtml(RenderContext context) {
        StringBuilder html = new StringBuilder();
        html.append("<picture>");
        
        for (var entry : responsiveSources.entrySet()) {
            html.append(String.format(
                "<source srcset="%s" media="%s">",
                context.transformUrl(entry.getValue()),
                entry.getKey()
            ));
        }
        
        html.append(String.format(
            "<img src="%s" alt="%s" loading="lazy">",
            context.transformUrl(src), 
            escapeHtml(alt)
        ));
        html.append("</picture>");
        
        return html.toString();
    }
    
    @Override
    public boolean isMediaBlock() { return true; }
}
 
// Code block with syntax highlighting
class CodeBlock implements ContentBlock {
    private final String code;
    private final String language;
    private final boolean showLineNumbers;
    
    @Override
    public String renderHtml(RenderContext context) {
        SyntaxHighlighter highlighter = context.getHighlighter(language);
        String highlighted = highlighter.highlight(code);
        
        return String.format(
            "<pre class="language-%s"><code>%s</code></pre>",
            language, highlighted
        );
    }
}
 
// Embedded content (YouTube, Twitter, etc.)
class EmbedBlock implements ContentBlock {
    private final String embedType;  // youtube, twitter, etc.
    private final String embedId;
    private final Map<String, Object> options;
    
    private static final Map<String, EmbedRenderer> renderers = Map.of(
        "youtube", new YouTubeEmbedRenderer(),
        "twitter", new TwitterEmbedRenderer(),
        "codepen", new CodePenEmbedRenderer()
    );
    
    @Override
    public String renderHtml(RenderContext context) {
        EmbedRenderer renderer = renderers.get(embedType);
        if (renderer == null) {
            return renderFallback();
        }
        return renderer.render(embedId, options, context);
    }
}
 
// Interactive widget (polls, quizzes, etc.)
class InteractiveBlock implements ContentBlock {
    private final String widgetType;
    private final JsonObject configuration;
    
    @Override
    public String renderHtml(RenderContext context) {
        // Render placeholder that JavaScript will hydrate
        return String.format(
            "<div class="interactive-widget" " +
            "data-widget-type="%s" " +
            "data-config='%s'>" +
            "<noscript>Interactive content requires JavaScript</noscript>" +
            "</div>",
            widgetType, configuration.toString()
        );
    }
}

The article renderer processes all blocks polymorphically:

ArticleRenderer.java
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
// Article composed of polymorphic content blocks
class Article {
    private final String id;
    private final String title;
    private final List<ContentBlock> blocks;  // Polymorphic collection
    private final Author author;
    private final Instant publishedAt;
    
    // Factory method with polymorphic deserialization
    public static Article fromJson(JsonObject json) {
        List<ContentBlock> blocks = new ArrayList<>();
        
        for (JsonObject blockJson : json.getArray("blocks")) {
            ContentBlock block = ContentBlockFactory.create(blockJson);
            blocks.add(block);
        }
        
        return new Article(
            json.getString("id"),
            json.getString("title"),
            blocks,
            Author.fromJson(json.getObject("author")),
            Instant.parse(json.getString("publishedAt"))
        );
    }
}
 
// Factory for creating appropriate block types
class ContentBlockFactory {
    private static final Map<String, BlockCreator> creators = Map.of(
        "rich-text", RichTextBlock::fromJson,
        "image", ImageBlock::fromJson,
        "code", CodeBlock::fromJson,
        "embed", EmbedBlock::fromJson,
        "interactive", InteractiveBlock::fromJson
    );
    
    public static ContentBlock create(JsonObject json) {
        String type = json.getString("type");
        BlockCreator creator = creators.get(type);
        
        if (creator == null) {
            return new UnknownBlock(json);  // Graceful degradation
        }
        
        return creator.create(json);
    }
}
 
// Render service processes articles
class ArticleRenderer {
    public String renderToHtml(Article article) {
        RenderContext context = createContext(article);
        
        StringBuilder html = new StringBuilder();
        html.append("<article>");
        html.append("<h1>").append(article.getTitle()).append("</h1>");
        
        // Polymorphic rendering of each block
        for (ContentBlock block : article.getBlocks()) {
            html.append("<div class="block block-")
                .append(block.getBlockType())
                .append("">");
            html.append(block.renderHtml(context));  // Polymorphic call
            html.append("</div>");
        }
        
        html.append("</article>");
        return html.toString();
    }
    
    // Same blocks, different output format
    public String renderToPlainText(Article article) {
        StringBuilder text = new StringBuilder();
        text.append(article.getTitle()).append("
 
");
        
        for (ContentBlock block : article.getBlocks()) {
            text.append(block.renderPlainText());  // Polymorphic call
            text.append("
 
");
        }
        
        return text.toString();
    }
    
    // Extract all media for prefetching
    public List<String> extractMediaUrls(Article article) {
        return article.getBlocks().stream()
            .filter(ContentBlock::isMediaBlock)  // Polymorphic check
            .flatMap(b -> b.extractUrls().stream())  // Polymorphic extraction
            .distinct()
            .collect(Collectors.toList());
    }
}

Multiple Rendering Targets

Case Study: Plugin Architecture

PluginArchitecture.java
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
// Core plugin interface
interface BuildPlugin {
    String getName();
    String getVersion();
    
    // Lifecycle hooks
    void initialize(BuildContext context);
    void beforeBuild(BuildContext context);
    void afterBuild(BuildContext context);
    void cleanup(BuildContext context);
    
    // Extension points
    List<Task> getTasks();
    List<ConfigurationExtension> getConfigurationExtensions();
}
 
// Abstract base with default implementations
abstract class AbstractBuildPlugin implements BuildPlugin {
    @Override
    public void initialize(BuildContext context) { }
    
    @Override
    public void beforeBuild(BuildContext context) { }
    
    @Override
    public void afterBuild(BuildContext context) { }
    
    @Override
    public void cleanup(BuildContext context) { }
    
    @Override
    public List<ConfigurationExtension> getConfigurationExtensions() {
        return Collections.emptyList();
    }
}
 
// Concrete plugins
class JavaCompilerPlugin extends AbstractBuildPlugin {
    @Override
    public String getName() { return "java-compiler"; }
    
    @Override
    public String getVersion() { return "2.1.0"; }
    
    @Override
    public List<Task> getTasks() {
        return List.of(
            new CompileJavaTask(),
            new CompileTestJavaTask()
        );
    }
    
    @Override
    public void initialize(BuildContext context) {
        context.registerSourceSet("main/java");
        context.registerSourceSet("test/java");
    }
}
 
class DockerPlugin extends AbstractBuildPlugin {
    @Override
    public String getName() { return "docker"; }
    
    @Override
    public String getVersion() { return "1.5.0"; }
    
    @Override
    public List<Task> getTasks() {
        return List.of(
            new DockerBuildTask(),
            new DockerPushTask(),
            new DockerComposeUpTask()
        );
    }
    
    @Override
    public List<ConfigurationExtension> getConfigurationExtensions() {
        return List.of(new DockerConfigurationExtension());
    }
}
 
class TestCoveragePlugin extends AbstractBuildPlugin {
    @Override
    public String getName() { return "coverage"; }
    
    @Override
    public void afterBuild(BuildContext context) {
        // Generate coverage report after build completes
        CoverageReport report = generateReport(context);
        context.getOutputDirectory().resolve("coverage").write(report);
    }
}

The build engine orchestrates plugins polymorphically:

BuildEngine.java
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
// Build engine coordinates plugins
class BuildEngine {
    private final List<BuildPlugin> plugins;  // Polymorphic collection
    private final TaskExecutor taskExecutor;
    private final PluginLoader pluginLoader;
    
    public BuildEngine(BuildConfiguration config) {
        // Load plugins from configuration
        this.plugins = new ArrayList<>();
        for (String pluginId : config.getPlugins()) {
            BuildPlugin plugin = pluginLoader.load(pluginId);
            plugins.add(plugin);
        }
        this.taskExecutor = new TaskExecutor();
    }
    
    public BuildResult build(List<String> taskNames) {
        BuildContext context = createContext();
        
        try {
            // Phase 1: Initialize all plugins
            for (BuildPlugin plugin : plugins) {
                plugin.initialize(context);  // Polymorphic initialization
            }
            
            // Phase 2: Collect all tasks from plugins
            Map<String, Task> allTasks = new LinkedHashMap<>();
            for (BuildPlugin plugin : plugins) {
                for (Task task : plugin.getTasks()) {  // Polymorphic task collection
                    allTasks.put(task.getName(), task);
                }
            }
            
            // Phase 3: Before build hooks
            for (BuildPlugin plugin : plugins) {
                plugin.beforeBuild(context);  // Polymorphic hook
            }
            
            // Phase 4: Execute requested tasks
            for (String taskName : taskNames) {
                Task task = allTasks.get(taskName);
                if (task == null) {
                    throw new UnknownTaskException(taskName);
                }
                taskExecutor.execute(task, context);
            }
            
            // Phase 5: After build hooks
            for (BuildPlugin plugin : plugins) {
                plugin.afterBuild(context);  // Polymorphic hook
            }
            
            return BuildResult.success(context.getOutputs());
            
        } catch (Exception e) {
            return BuildResult.failure(e);
            
        } finally {
            // Phase 6: Cleanup all plugins
            for (BuildPlugin plugin : plugins) {
                try {
                    plugin.cleanup(context);  // Polymorphic cleanup
                } catch (Exception e) {
                    log.warn("Plugin cleanup failed: {}", plugin.getName(), e);
                }
            }
        }
    }
}
 
// Task interface for plugin-provided tasks
interface Task {
    String getName();
    Set<String> getDependencies();  // Other tasks that must run first
    void execute(BuildContext context) throws TaskExecutionException;
}
 
// Usage: build with configured plugins
BuildConfiguration config = BuildConfiguration.load("build.yaml");
// build.yaml contains:
// plugins:
//   - java-compiler
//   - docker
//   - coverage
 
BuildEngine engine = new BuildEngine(config);
BuildResult result = engine.build(List.of("compile", "test", "dockerBuild"));

Extensibility Through Interface Contracts

Case Study: Business Rule Engine

RuleEngine.java
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
// Core rule interface
interface Rule<T> {
    String getRuleName();
    int getPriority();  // Higher priority rules evaluated first
    boolean appliesTo(T context);  // Does this rule apply?
    RuleResult evaluate(T context);  // What's the result?
}
 
// Insurance underwriting rules
interface UnderwritingRule extends Rule<InsuranceApplication> {
    RiskCategory getRiskCategory();  // life, property, liability, etc.
}
 
// Concrete underwriting rules
class AgeRiskRule implements UnderwritingRule {
    @Override
    public String getRuleName() { return "AGE_RISK"; }
    
    @Override
    public int getPriority() { return 100; }
    
    @Override
    public RiskCategory getRiskCategory() { return RiskCategory.LIFE; }
    
    @Override
    public boolean appliesTo(InsuranceApplication app) {
        return app.getProductType() == ProductType.LIFE_INSURANCE;
    }
    
    @Override
    public RuleResult evaluate(InsuranceApplication app) {
        int age = app.getApplicant().getAge();
        
        if (age < 18) {
            return RuleResult.decline("Applicant must be 18 or older");
        } else if (age < 30) {
            return RuleResult.approve().withPremiumModifier(0.9);
        } else if (age < 50) {
            return RuleResult.approve().withPremiumModifier(1.0);
        } else if (age < 65) {
            return RuleResult.approve().withPremiumModifier(1.3);
        } else if (age < 75) {
            return RuleResult.approve().withPremiumModifier(1.8);
        } else {
            return RuleResult.referToUnderwriter("Age over 75 requires manual review");
        }
    }
}
 
class SmokingStatusRule implements UnderwritingRule {
    @Override
    public String getRuleName() { return "SMOKING_STATUS"; }
    
    @Override
    public int getPriority() { return 90; }
    
    @Override
    public boolean appliesTo(InsuranceApplication app) {
        return app.getProductType() == ProductType.LIFE_INSURANCE
            || app.getProductType() == ProductType.HEALTH_INSURANCE;
    }
    
    @Override
    public RuleResult evaluate(InsuranceApplication app) {
        SmokingStatus status = app.getApplicant().getSmokingStatus();
        
        switch (status) {
            case NEVER:
                return RuleResult.approve().withPremiumModifier(0.85);
            case QUIT_MORE_THAN_5_YEARS:
                return RuleResult.approve().withPremiumModifier(0.95);
            case QUIT_LESS_THAN_5_YEARS:
                return RuleResult.approve().withPremiumModifier(1.15);
            case CURRENT_OCCASIONAL:
                return RuleResult.approve().withPremiumModifier(1.4);
            case CURRENT_REGULAR:
                return RuleResult.approve().withPremiumModifier(1.7);
            default:
                return RuleResult.referToUnderwriter("Unknown smoking status");
        }
    }
}
 
class PreExistingConditionRule implements UnderwritingRule {
    private final MedicalCodeDatabase medicalCodes;
    
    @Override
    public String getRuleName() { return "PRE_EXISTING_CONDITIONS"; }
    
    @Override
    public RuleResult evaluate(InsuranceApplication app) {
        List<MedicalCondition> conditions = app.getMedicalHistory().getConditions();
        
        for (MedicalCondition condition : conditions) {
            RiskLevel risk = medicalCodes.getRiskLevel(condition.getCode());
            
            if (risk == RiskLevel.UNINSURABLE) {
                return RuleResult.decline("Uninsurable condition: " + condition.getName());
            } else if (risk == RiskLevel.HIGH) {
                return RuleResult.referToUnderwriter(
                    "High-risk condition requires review: " + condition.getName()
                );
            }
        }
        
        return RuleResult.approve();
    }
}

The rule engine evaluates all applicable rules and combines results:

UnderwritingEngine.java
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
// Rule engine evaluates polymorphic rules
class UnderwritingEngine {
    private final List<UnderwritingRule> rules;  // Polymorphic collection
    
    public UnderwritingEngine(List<UnderwritingRule> rules) {
        // Sort by priority for consistent evaluation order
        this.rules = rules.stream()
            .sorted(Comparator.comparingInt(UnderwritingRule::getPriority).reversed())
            .collect(Collectors.toList());
    }
    
    public UnderwritingDecision evaluate(InsuranceApplication application) {
        List<RuleResult> results = new ArrayList<>();
        double cumulativePremiumModifier = 1.0;
        
        for (UnderwritingRule rule : rules) {
            // Check if rule applies (polymorphic)
            if (!rule.appliesTo(application)) {
                continue;
            }
            
            // Evaluate rule (polymorphic)
            RuleResult result = rule.evaluate(application);
            results.add(result);
            
            // Immediate decline exits early
            if (result.isDecline()) {
                return UnderwritingDecision.decline(
                    result.getReason(),
                    rule.getRuleName()
                );
            }
            
            // Referral pauses automatic processing
            if (result.isReferral()) {
                return UnderwritingDecision.referToUnderwriter(
                    result.getReason(),
                    results  // Include all results so far
                );
            }
            
            // Accumulate premium modifiers
            cumulativePremiumModifier *= result.getPremiumModifier();
        }
        
        // All rules passed—calculate final premium
        Money basePremium = calculateBasePremium(application);
        Money finalPremium = basePremium.multiply(cumulativePremiumModifier);
        
        return UnderwritingDecision.approve(finalPremium, results);
    }
}
 
// Usage
List<UnderwritingRule> rules = List.of(
    new AgeRiskRule(),
    new SmokingStatusRule(),
    new PreExistingConditionRule(),
    new OccupationRiskRule(),
    new GeographicRiskRule(),
    new CoverageAmountRule()
);
 
UnderwritingEngine engine = new UnderwritingEngine(rules);
UnderwritingDecision decision = engine.evaluate(application);
 
// Adding new rules is simple:
rules.add(new CovidRiskRule());  // New pandemic-related rule
rules.add(new GeneticTestingRule());  // New genetic risk assessment

Rules as Data

Polymorphism Patterns Combined

The case studies reveal how polymorphism patterns work together. Let's map the patterns we've learned to their appearances in real systems:

Pattern Usage Across Case Studies
System	Factory Method	Strategy	Polymorphic Collection
Payment Processing	PaymentMethod creation	PaymentProcessor selection	FraudRules, Processors
Content Rendering	ContentBlock factory	Block rendering strategies	Article blocks
Plugin Architecture	Plugin loading	Task execution	Plugin list
Rule Engine	Rule instantiation	Rule evaluation	Rule list

Common architectural patterns emerge:

Recurring Architectural Patterns

•Interface + implementations — Every system defines core interfaces with multiple implementations. New requirements mean new implementations, not changes to existing code.
•Factory for creation, strategy for behavior — Factories create the right implementation; strategies execute the right algorithm. Often used together in the same system.
•Collections for orchestration — The orchestrating component (PaymentService, BuildEngine, etc.) iterates over polymorphic collections without knowing concrete types.
•Configuration-driven assembly — Which implementations are used is determined by configuration, not hard-coded. DI containers or custom loaders assemble the system.
•Graceful degradation — Unknown types get default handling (UnknownBlock, fallback processor) rather than crashing.

Designing for Polymorphism

Studying these real-world systems reveals principles for designing polymorphic architectures:

Design Principles for Polymorphism

•Identify the variation points — What aspects of the system will change? New payment methods? New content types? New rules? These become interfaces.
•Define minimal, focused interfaces — Interfaces should capture the essential operations all implementations share. Avoid bloated interfaces that some implementations can't meaningfully implement.
•Make the orchestrator ignorant — The component that coordinates polymorphic objects should know only about interfaces, never about concrete types.
•Use factories for creation complexity — When object creation involves decisions (which type? what configuration?), encapsulate that in factories.
•Prefer composition over conditionals — Instead of if-else chains, compose behavior from polymorphic objects.
•Plan for unknown types — Include fallback handling for types that don't (yet) exist.
•Test through interfaces — Unit tests should work with interfaces. If tests need concrete types, the design may be too coupled.

Avoid Over-Engineering

Summary: Real-World Polymorphism

Key Takeaways

•Polymorphism enables extensibility — New payment methods, content types, plugins, and rules can be added without modifying existing code.
•Patterns combine naturally — Factories create objects, strategies define behavior, collections group them—all working together.
•Orchestrators remain stable — The code that coordinates polymorphic objects rarely needs to change, even as the system evolves.
•Configuration drives behavior — Which implementations are used is determined by configuration, making systems adaptable.
•Same patterns, different domains — Payment processing, content rendering, plugins, and rules all use the same polymorphic patterns.
•Design for the interfaces, not the implementations — Focus on contracts; implementations can vary independently.

Module Complete:

Module Complete

4 / 4