Master the Modern Java: Records, Pattern Matching, and Sealed Types for Clean Domain Models and Smarter Error Handling

What you'll learn

Understand the core principles of Data Oriented Programming (DOP) and how it differs from traditional Object Oriented Programming (OOP)

Use Java Records to model immutable data structures cleanly and concisely

Design clear and controlled hierarchies using sealed classes and interfaces

Handle domain-specific errors using algebraic data types (ADTs) and sealed hierarchies

Replace verbose inheritance-based models with expressive, data-driven design

Use guarded and nested patterns to handle complex business rules with ease

Refactor legacy OOP codebases into modern, maintainable DOP-style architectures

Understand how modern Java features lead to better readability

Build real-world applications using pure data models, functional logic, and modern Java syntax

Model business rules, responses, and error cases using type-safe alternatives to exceptions

Learn how to use records and sealed types in serialization for clean APIs

Gain practical experience through a hands-on project

Requirements

Knowledge on Java

It is a Hands-On course. You should be willing to write code!

Comfortable with Indian Accent

Patience To Learn!

Description

Lets deep dive into Data Oriented Programming (DOP) in Java. A modern, practical, and forward-looking programming paradigm that is reshaping how Java applications are designed and developed.In this masterclass, you will learn how to write clearer, safer, and more maintainable Java code by shifting your mindset from objects and inheritance to data and behavior separation. Through hands-on lessons and real-world use cases, you will discover how to leverage Java's latest language features Records, Sealed Types, and Pattern Matching to build data-centric applications that are easy to reason about and evolve.What You Will LearnCrash Courses on Key Modern Java FeaturesRecords: Learn how Java Records simplify data modeling, enforce immutability, and reduce boilerplate & when to choose records over classes.Sealed Types: Master sealed classes and interfaces to build expressive, restricted hierarchies and eliminate misuse of inheritance.Pattern Matching: Simplify conditionals using pattern matching with switch expressions, including nested and guarded patterns.Foundations of Data Oriented ProgrammingUnderstand the principles of DOP and how it contrasts with traditional OOP.Dive into Algebraic Data Types (ADTs) in Java using Records and Sealed Types to model domain logic precisely and safely.Practical Use Cases and Real-World IntegrationImplement DOP in real-world scenarios, from API modeling to complex business rules.Serialize and deserialize sealed hierarchies using Jackson including how to work with polymorphic types in JSON.Explore data modeling, validation logic, and how DOP can simplify state machines, complex business workflows.Better Error HandlingUse sealed hierarchies to represent all possible error cases.Apply pattern matching to handle errors in a concise and exhaustive way. No missed edge cases. Hands-On Final ProjectWhy Take This Course?This course is designed for Java developers who want to:Stay ahead with modern Java features Write more declarative, composable, and readable codeReplace legacy boilerplate with expressive data modelsUnderstand the real value of Records, Sealed Types, and Pattern Matching beyond syntaxLearn data oriented thinking, ADTs, and functional ideas without leaving JavaWhether you are building APIs, business systems or modern backend services, this course will transform how you model, process, and reason about data in Java.

Overview

Section 1: Introduction

Lecture 1 Before You Enroll

Section 2: Records

Lecture 2 *** Resource ***

Lecture 3 Project Setup

Lecture 4 How Records Work

Lecture 5 Code With Me & Package Structure

Lecture 6 Record Equality

Lecture 7 Canonical Constructor

Lecture 8 CompactConstructor

Lecture 9 Compact Constructor - Validation

Lecture 10 Non-Canonical Constructor

Lecture 11 Are Records Immutable?

Lecture 12 Accessor Method Override

Lecture 13 Nullable Fields

Lecture 14 No Extra Instance Fields

Lecture 15 Static Members

Lecture 16 Records Implementing Interface

Lecture 17 Reflection

Lecture 18 Organizing Records

Lecture 19 Summary

Section 3: Sealed Types

Lecture 20 Need For Sealed Types

Lecture 21 Sealed Type Demo - Part 1

Lecture 22 Sealed Type Demo - Part 2

Lecture 23 Sealed Interface With Records

Lecture 24 [Clarification] - Records With Side Effects!!

Lecture 25 Summary

Section 4: Pattern Matching

Lecture 26 Is instanceof Bad?

Lecture 27 Pattern Matching - instanceof

Lecture 28 Switch Expression

Lecture 29 Type Pattern

Lecture 30 Pattern Label Dominance

Lecture 31 Guarded Pattern

Lecture 32 Unnamed Variable

Lecture 33 Record Pattern

Lecture 34 Nested Record Pattern

Lecture 35 Switch Exhaustiveness

Lecture 36 Summary

Section 5: Principles Of Data Oriented Programming

Lecture 37 Introduction To Data Oriented Programming

Lecture 38 Algebraic Data Types

Lecture 39 Sealed Record - Pattern Matching - Demo 1

Lecture 40 Sealed Record - Pattern Matching - Demo 2

Lecture 41 Enum vs Sealed

Lecture 42 Data Oriented Programming Principles

Lecture 43 Importance Of Types

Lecture 44 [Clarification] - Can Records Have Methods?

Lecture 45 Summary

Section 6: Domain Modeling

Lecture 46 Domain Modeling

Lecture 47 Modeling State Change

Lecture 48 Loan Application Workflow - Requirements

Lecture 49 Loan Models

Lecture 50 Modeling Loan Status & Processor

Lecture 51 Loan State Transition - Implementation - Part 1

Lecture 52 Loan State Transition - Implementation - Part 2

Lecture 53 Loan Workflow - Demo

Lecture 54 [Clarification] - Why Does Loan Status Contain Loan?

Lecture 55 Summary

Section 7: Modeling Uncertainty With Types

Lecture 56 Option Type

Lecture 57 Either Type

Lecture 58 [Clarification] - What About More Than 2 Options?

Section 8: Error Handling

Lecture 59 Problems With Checked Exceptions

Lecture 60 Error Handling With Sealed Types

Lecture 61 Generic Result Type - Part 1

Lecture 62 Generic Result Type - Part 2

Lecture 63 [Clarification] - Is Throwing Exception Bad?

Section 9: Polymorphic Deserialization

Lecture 64 Polymorphic Deserialization - Introduction

Lecture 65 Auto Deduction

Lecture 66 Property Based Deduction

Lecture 67 Mixin

Lecture 68 Summary

Section 10: [Application Development] - Order Workflow Processing - Phase 1

Lecture 69 *** Resource ***

Lecture 70 Order Processing System

Lecture 71 External Services

Lecture 72 Order Workflow Discussion

Lecture 73 Implementation Discussion

Lecture 74 Project Setup

Lecture 75 Code With Me

Lecture 76 Creating Models - Part 1

Lecture 77 Creating Models - Part 2

Lecture 78 Creating Models - Part 3

Lecture 79 Modeling Errors

Lecture 80 Application Exceptions

Lecture 81 [Clarification] - Why Do We Have Interface For Single Implementation?

Lecture 82 Product Client - Implementation

Lecture 83 Customer Client & Payment Client

Lecture 84 Billing Client & Shipping Client

Lecture 85 Request Validator Service

Lecture 86 Price Calculator

Lecture 87 Payment & Billing Service

Lecture 88 Shipping Service

Lecture 89 Order States

Lecture 90 Order Orchestrator - State Transition - Part 1

Lecture 91 Order Orchestrator - State Transition - Part 2

Lecture 92 [Clarification] - Do We Need Fulfilled State?

Lecture 93 Order Service & Mapper

Lecture 94 Order REST Controller

Lecture 95 @ControllerAdvice - Problem Detail

Lecture 96 Application Exception Handling

Lecture 97 Logging Interceptor

Lecture 98 Application Configuration

Lecture 99 Jackson Mixin

Lecture 100 Final Demo Preparation

Lecture 101 Final Demo

Lecture 102 [Clarification] - Order Cancellation Workflow Orchestrator

Section 11: [Application Development] - Order Workflow Processing - Phase 2

Lecture 103 *** Resource ***

Lecture 104 Phase 2 - Adding Support For Coupon

Lecture 105 [Clarification] - Why Do We Call Coupon Service From Request Validator?

Lecture 106 External Service

Lecture 107 Modeling Coupon

Lecture 108 Coupon None vs Optional Coupon

Lecture 109 Updating Other Models

Lecture 110 Coupon Client

Lecture 111 Request Validator Changes For Coupon

Lecture 112 Applying Coupon

Lecture 113 Application Configuration Changes

Lecture 114 Phase 2 - Final Demo

Section 12: [Application Development] - Order Workflow Processing - Phase 3

Lecture 115 *** Resource ***

Lecture 116 Phase 3 - Requirements Discussion

Lecture 117 External Services

Lecture 118 Modeling Shipping Status

Lecture 119 Declined Shipping - Domain Error

Lecture 120 Handling Refund, Invoice, Declined Shipping - Part 1

Lecture 121 Handling Refund, Invoice, Declined Shipping - Part 2

Lecture 122 Updating Orchestrator For Declined Shipping

Lecture 123 Application Exception Handling

Lecture 124 Phase 3 - Final Demo

Section 13: Persistence

Lecture 125 Sealed Types With Persistence

Lecture 126 1 Table For All Subclasses

Lecture 127 1 Table Per Subclass

Lecture 128 What About Document DB?

Section 14: Whats Next?

Lecture 129 Whats Next?

Any Java Developer / Architect who is interested in learning modern Java features