7a:T426,// Customer is an ENTITY - identity matters public class Customer { private final CustomerId id; private String name; private Email email; private Address address; public Customer(CustomerId id, String name, Email email, Address address) { this.id = id; this.name = name; this.email = email; this.address = address; } // Customer 42 is STILL Customer 42 even after changing name public void changeName(String newName) { this.name = newName; } // Identity comparison - two customers are equal only if same ID @Override public boolean equals(Object obj) { if (!(obj instanceof Customer other)) return false; return this.id.equals(other.id); } } // Two different Customer objects with same attributes // are NOT the same customer Customer customer1 = new Customer(new CustomerId(42), "Alice", email, address); Customer customer2 = new Customer(new CustomerId(99), "Alice", email, address); // customer1.equals(customer2) is FALSE - different identities7b:T9a2,// Money - a canonical value object class Money { private readonly amount: number; private readonly currency: Currency; private constructor(amount: number, currency: Currency) { // Validation at construction if (amount < 0) { throw new Error("Amount cannot be negative"); } this.amount = Money.roundToMinorUnits(amount, currency); this.currency = currency; } // Factory methods for creation static of(amount: number, currency: Currency): Money { return new Money(amount, currency); } static usd(amount: number): Money { return new Money(amount, Currency.USD); } static zero(currency: Currency): Money { return new Money(0, currency); } // Operations return NEW instances (immutability) add(other: Money): Money { this.ensureSameCurrency(other); return new Money(this.amount + other.amount, this.currency); } subtract(other: Money): Money { this.ensureSameCurrency(other); const result = this.amount - other.amount; if (result < 0) { throw new Error("Insufficient amount"); } return new Money(result, this.currency); } multiply(factor: number): Money { return new Money(this.amount * factor, this.currency); } // Value equality - two Money objects are equal if same amount AND currency equals(other: Money): boolean { return this.amount === other.amount && this.currency === other.currency; } // Immutable - no setters, no mutation methods getAmount(): number { return this.amount; } getCurrency(): Currency { return this.currency; } private ensureSameCurrency(other: Money): void { if (this.currency !== other.currency) { throw new Error(`Currency mismatch: ${this.currency} vs ${other.currency}`); } } private static roundToMinorUnits(amount: number, currency: Currency): number { const minorUnits = currency.getMinorUnits(); const factor = Math.pow(10, minorUnits); return Math.round(amount * factor) / factor; } } // Usage const price = Money.usd(99.99); const tax = Money.usd(8.00); const total = price.add(tax); // Returns NEW Money instance // These are equal - same value const fifty1 = Money.usd(50.00); const fifty2 = Money.usd(50.00); console.log(fifty1.equals(fifty2)); // true7c:T9af,// Money - a canonical value object public final class Money { private final BigDecimal amount; private final Currency currency; private Money(BigDecimal amount, Currency currency) { if (amount.compareTo(BigDecimal.ZERO) < 0) { throw new IllegalArgumentException("Amount cannot be negative"); } this.amount = amount.setScale( currency.getMinorUnits(), RoundingMode.HALF_UP ); this.currency = Objects.requireNonNull(currency); } // Factory methods for creation public static Money of(BigDecimal amount, Currency currency) { return new Money(amount, currency); } public static Money usd(double amount) { return new Money(BigDecimal.valueOf(amount), Currency.USD); } public static Money zero(Currency currency) { return new Money(BigDecimal.ZERO, currency); } // Operations return NEW instances (immutability) public Money add(Money other) { ensureSameCurrency(other); return new Money(this.amount.add(other.amount), this.currency); } public Money subtract(Money other) { ensureSameCurrency(other); BigDecimal result = this.amount.subtract(other.amount); if (result.compareTo(BigDecimal.ZERO) < 0) { throw new IllegalStateException("Insufficient amount"); } return new Money(result, this.currency); } public Money multiply(double factor) { return new Money( this.amount.multiply(BigDecimal.valueOf(factor)), this.currency ); } // Value equality @Override public boolean equals(Object obj) { if (!(obj instanceof Money other)) return false; return this.amount.equals(other.amount) && this.currency.equals(other.currency); } @Override public int hashCode() { return Objects.hash(amount, currency); } public BigDecimal getAmount() { return amount; } public Currency getCurrency() { return currency; } private void ensureSameCurrency(Money other) { if (!this.currency.equals(other.currency)) { throw new IllegalArgumentException( "Currency mismatch: " + currency + " vs " + other.currency ); } } } // Usage Money price = Money.usd(99.99); Money tax = Money.usd(8.00); Money total = price.add(tax); // Returns NEW Money instance7d:T796,// DateRange - a value object for temporal spans class DateRange { private readonly start: Date; private readonly end: Date; private constructor(start: Date, end: Date) { if (start > end) { throw new Error("Start date must be before or equal to end date"); } this.start = new Date(start); // Defensive copy this.end = new Date(end); } static between(start: Date, end: Date): DateRange { return new DateRange(start, end); } static singleDay(date: Date): DateRange { return new DateRange(date, date); } // Query methods contains(date: Date): boolean { return date >= this.start && date <= this.end; } overlaps(other: DateRange): boolean { return this.start <= other.end && this.end >= other.start; } getDurationInDays(): number { const diffTime = this.end.getTime() - this.start.getTime(); return Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1; } // Operations return new instances extend(days: number): DateRange { const newEnd = new Date(this.end); newEnd.setDate(newEnd.getDate() + days); return new DateRange(this.start, newEnd); } intersect(other: DateRange): DateRange | null { if (!this.overlaps(other)) { return null; } const newStart = this.start > other.start ? this.start : other.start; const newEnd = this.end < other.end ? this.end : other.end; return new DateRange(newStart, newEnd); } // Value equality equals(other: DateRange): boolean { return this.start.getTime() === other.start.getTime() && this.end.getTime() === other.end.getTime(); } // Immutable accessors (return copies to prevent mutation) getStart(): Date { return new Date(this.start); } getEnd(): Date { return new Date(this.end); } }7e:Tb2b,// Address - a composite value object class Address { private readonly street: string; private readonly city: string; private readonly state: string; private readonly postalCode: PostalCode; private readonly country: Country; private constructor( street: string, city: string, state: string, postalCode: PostalCode, country: Country ) { // Validation if (!street.trim()) { throw new Error("Street is required"); } if (!city.trim()) { throw new Error("City is required"); } this.street = street.trim(); this.city = city.trim(); this.state = state.trim(); this.postalCode = postalCode; this.country = country; } static create( street: string, city: string, state: string, postalCode: string, country: string ): Address { return new Address( street, city, state, PostalCode.of(postalCode), Country.of(country) ); } // Returns new address with changed street // (used when customer provides correction, for example) withStreet(newStreet: string): Address { return new Address( newStreet, this.city, this.state, this.postalCode, this.country ); } isSameCity(other: Address): boolean { return this.city === other.city && this.country.equals(other.country); } formatForMailing(): string { return `${this.street} ${this.city}, ${this.state} ${this.postalCode} ${this.country}`; } // Value equality - all fields must match equals(other: Address): boolean { return this.street === other.street && this.city === other.city && this.state === other.state && this.postalCode.equals(other.postalCode) && this.country.equals(other.country); } } // PostalCode is ALSO a value object class PostalCode { private readonly value: string; private constructor(value: string) { if (!PostalCode.isValid(value)) { throw new Error(`Invalid postal code: ${value}`); } this.value = value.toUpperCase().replace(/\s/g, ''); } static of(value: string): PostalCode { return new PostalCode(value); } private static isValid(value: string): boolean { // Simple validation - adjust for your country const normalized = value.replace(/\s/g, ''); return /^[A-Z0-9]{3,10}$/.test(normalized.toUpperCase()); } equals(other: PostalCode): boolean { return this.value === other.value; } toString(): string { return this.value; } }7f:T773,// ✅ PROPER VALUE OBJECT: Email with behavior class Email { private readonly value: string; private constructor(value: string) { const normalized = value.toLowerCase().trim(); if (!Email.isValid(normalized)) { throw new InvalidEmailError(value); } this.value = normalized; } static of(value: string): Email { return new Email(value); } private static isValid(email: string): boolean { // Comprehensive validation in ONE place const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; return emailRegex.test(email) && email.length <= 254; } getDomain(): string { return this.value.split('@')[1]; } getLocalPart(): string { return this.value.split('@')[0]; } isBusinessEmail(): boolean { const personalDomains = ['gmail.com', 'yahoo.com', 'hotmail.com']; return !personalDomains.includes(this.getDomain()); } equals(other: Email): boolean { return this.value === other.value; } toString(): string { return this.value; } } // Now the Customer class is cleaner and safer class Customer { private email: Email; // Type system enforces validity setEmail(email: Email): void { this.email = email; // Already validated at creation } } // Newsletter can't receive invalid emails class Newsletter { subscribe(email: Email): void { // email is GUARANTEED to be valid if (email.isBusinessEmail()) { this.addToCorporateList(email); } else { this.addToPersonalList(email); } } } // Type system prevents mixing incompatible values function processCustomer( email: Email, // Must pass Email object phone: PhoneNumber // Must pass PhoneNumber object ): void { // Can't accidentally pass phone where email is expected }80:T416,class Money { private readonly amount: number; private readonly currency: Currency; // ... constructor and other methods ... equals(other: Money | null | undefined): boolean { if (other === null || other === undefined) { return false; } if (!(other instanceof Money)) { return false; } return this.amount === other.amount && this.currency === other.currency; } // In TypeScript/JavaScript, also override for collections // that might use string keys hashCode(): number { let hash = 17; hash = hash * 31 + Math.floor(this.amount * 100); hash = hash * 31 + this.currency.hashCode(); return hash; } } // Usage demonstrating value equality const m1 = Money.usd(100); const m2 = Money.usd(100); const m3 = Money.usd(50); console.log(m1.equals(m2)); // true - same value console.log(m1.equals(m3)); // false - different amounts console.log(m1 === m2); // false - different references (expected!)81:T42f,public final class Money { private final BigDecimal amount; private final Currency currency; // ... constructor and other methods ... @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null || getClass() != obj.getClass()) return false; Money other = (Money) obj; return Objects.equals(amount, other.amount) && Objects.equals(currency, other.currency); } @Override public int hashCode() { return Objects.hash(amount, currency); } } // Usage demonstrating value equality Money m1 = Money.usd(100); Money m2 = Money.usd(100); Money m3 = Money.usd(50); System.out.println(m1.equals(m2)); // true - same value System.out.println(m1.equals(m3)); // false - different amounts System.out.println(m1 == m2); // false - different references (expected!) // Works correctly in collections Set prices = new HashSet<>(); prices.add(m1); prices.add(m2); // Set detects duplicate, doesn't add System.out.println(prices.size()); // 182:T416,from dataclasses import dataclass from decimal import Decimal from typing import Self @dataclass(frozen=True) # frozen=True makes it immutable class Money: amount: Decimal currency: str def __post_init__(self): # Validation if self.amount < 0: raise ValueError("Amount cannot be negative") # Note: Can't modify in frozen dataclass # Use object.__setattr__ for normalization @classmethod def usd(cls, amount: float) -> Self: return cls(Decimal(str(amount)).quantize(Decimal('0.01')), 'USD') def add(self, other: 'Money') -> 'Money': self._require_same_currency(other) return Money(self.amount + other.amount, self.currency) def _require_same_currency(self, other: 'Money') -> None: if self.currency != other.currency: raise ValueError(f"Currency mismatch: {self.currency} vs {other.currency}") # frozen=True provides: # - Immutability (AttributeError on assignment) # - __hash__ implementation # - __eq__ based on all fields72:{"json":{"id":"seed_e6f048c20ba338728a3fd78c117b6788","slug":"ddd-value-objects","category":"System Design (LLD)","topic":"Value Objects","title":"Value Objects in Domain-Driven Design","description":"Master the art of designing value objects—immutable, identity-less building blocks that capture descriptive aspects of your domain. Learn when and how to use value objects to create more expressive, safer, and maintainable domain models.","difficulty":"INTERMEDIATE","estimatedMinutes":55,"pages":[{"id":"seed_7042e5685332f2a1e4eb1b3ac1d70552","title":"What is a Value Object","order":0,"content":[{"id":"opening-hook","title":"Beyond Identity: Objects That Describe","content":[{"data":{"content":"In Domain-Driven Design, we often focus on **Entities**—objects with distinct identities that we track throughout their lifecycle. A `Customer` with ID 42 remains the same customer even if they change their name or address. But there's another category of domain objects that's equally fundamental, yet frequently overlooked or misunderstood: **Value Objects**.\n\nValue Objects represent the *descriptive* aspects of your domain. They don't have identity—they are defined entirely by their attributes. A `Money` object representing $100.00 USD doesn't have an identity; there's nothing distinguishing one \"$100.00 USD\" from another. What matters is what it *describes*, not which particular instance it is.\n\nUnderstanding and properly implementing value objects is a hallmark of sophisticated domain modeling. They reduce bugs, improve expressiveness, and create self-documenting code that captures domain concepts with precision."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand what value objects are, how they differ from entities, and why they are essential building blocks in any well-designed domain model. You'll see concrete examples that illuminate when an object should be a value object and how to recognize them in your domain.","variant":"info"},"type":"callout"}]},{"id":"concept-of-identity","title":"The Concept of Identity in Domain Modeling","content":[{"data":{"content":"To understand value objects, we must first crystallize the concept of **identity** in domain modeling.\n\n**Identity means:**\n- An object remains \"the same object\" even when its attributes change\n- We track the object across time and through state transitions\n- Two objects with identical attributes are NOT the same if they have different identities\n\n**Consider a Customer entity:**"},"type":"text"},{"data":{"fileName":"customer-entity.ts","languages":[{"code":"// Customer is an ENTITY - identity matters\nclass Customer {\n private readonly id: CustomerId;\n private name: string;\n private email: Email;\n private address: Address;\n\n constructor(id: CustomerId, name: string, email: Email, address: Address) {\n this.id = id;\n this.name = name;\n this.email = email;\n this.address = address;\n }\n\n // Customer 42 is STILL Customer 42 even after changing name\n changeName(newName: string): void {\n this.name = newName;\n }\n\n // Identity comparison - two customers are equal only if same ID\n equals(other: Customer): boolean {\n return this.id.equals(other.id);\n }\n}\n\n// Two different Customer objects with same attributes \n// are NOT the same customer\nconst customer1 = new Customer(new CustomerId(42), \"Alice\", email, address);\nconst customer2 = new Customer(new CustomerId(99), \"Alice\", email, address);\n// customer1.equals(customer2) is FALSE - different identities","label":"TypeScript","value":"typescript"},{"code":"$7a","label":"Java","value":"java"}]},"type":"code"},{"data":{"content":"Now consider: Does the `address` within that customer have identity? If the customer moves from \"123 Main St\" to \"456 Oak Ave\", is it the *same* address that transformed, or did the customer simply switch to a *different* address?\n\n**The answer is crucial:** The address itself doesn't have identity. We don't track addresses across their \"lifecycle.\" We care about *what the address is*, not *which specific address instance* it is. An address at \"123 Main St, New York, NY 10001\" is indistinguishable from any other address with those same values.\n\nThis is the essence of a **Value Object**."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"defining-value-objects","title":"Defining Value Objects","content":[{"data":{"content":"A **Value Object** is an object that:\n\n1. **Has no conceptual identity** — It is defined entirely by its attributes\n2. **Is immutable** — Once created, its state never changes\n3. **Compares by value** — Two value objects are equal if all their attributes are equal\n4. **Is replaceable** — Interchangeable with any other instance having the same attributes\n5. **Is side-effect free** — Operations return new instances rather than modifying existing ones\n\nEric Evans, in his seminal book *Domain-Driven Design*, describes value objects as objects that \"describe some characteristic or attribute but carry no concept of identity.\""},"type":"text"},{"data":{"icon":"Lightbulb","title":"The Litmus Test for Value Objects","content":"Ask yourself: \"If I have two instances with identical attributes, does it matter which one I use?\" If the answer is NO—if they're completely interchangeable—you have a value object. If the answer is YES—if you need to track which specific instance—you have an entity.","variant":"tip"},"type":"callout"},{"data":{"rows":[["Identity","None — defined by attributes","Distinct identity, tracked over time"],["Equality","By value (all attributes)","By identity (ID only)"],["Mutability","Immutable","Typically mutable"],["Lifecycle","No lifecycle, replaceable","Has lifecycle, state transitions"],["Examples","Money, DateRange, Address, Email","Customer, Order, Account, Product"],["Persistence","Embedded in entity","Has own table/document"]],"caption":"Value Object vs Entity Comparison","headers":["Characteristic","Value Object","Entity"]},"type":"table"}],"titleType":"number","titleNumber":2},{"id":"canonical-examples","title":"Canonical Value Object Examples","content":[{"data":{"content":"Let's examine several canonical examples of value objects that appear across countless domains. Understanding these patterns will help you recognize value objects in your own domain."},"type":"text"},{"data":{"content":"### Money: The Quintessential Value Object\n\nMoney is perhaps the most universally applicable value object. A $50.00 USD is completely interchangeable with any other $50.00 USD. We don't track individual instances of \"fifty dollars\"—we care only about the amount and currency."},"type":"text"},{"data":{"fileName":"money-value-object.ts","languages":[{"code":"$7b","label":"TypeScript","value":"typescript"},{"code":"$7c","label":"Java","value":"java"}]},"type":"code"},{"data":{"content":"### DateRange: Capturing Temporal Concepts\n\nA date range defines a period between two dates. The specific instance doesn't matter—what matters is the start and end dates."},"type":"text"},{"data":{"fileName":"date-range.ts","languages":[{"code":"$7d","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"content":"### Address: Compositional Value Objects\n\nAddresses are composed of multiple parts (street, city, postal code), but the address as a whole has no identity. It describes a location."},"type":"text"},{"data":{"fileName":"address-value-object.ts","languages":[{"code":"$7e","label":"TypeScript","value":"typescript"}]},"type":"code"}],"titleType":"number","titleNumber":3},{"id":"vs-primitive-obsession","title":"Value Objects vs Primitive Obsession","content":[{"data":{"content":"One of the most common code smells addressed by value objects is **Primitive Obsession**—the overuse of primitive types (strings, numbers, booleans) to represent domain concepts.\n\nConsider an email address. In many codebases, you'll see:"},"type":"text"},{"data":{"fileName":"primitive-obsession.ts","languages":[{"code":"// ❌ PRIMITIVE OBSESSION: Email as string\nclass Customer {\n private email: string; // Just a string!\n \n setEmail(email: string): void {\n // Validation scattered everywhere email is used\n if (!email.includes('@')) {\n throw new Error('Invalid email');\n }\n this.email = email;\n }\n}\n\n// Same validation repeated in different classes\nclass Newsletter {\n subscribe(email: string): void {\n if (!email.includes('@')) {\n throw new Error('Invalid email');\n }\n // ... subscribe logic\n }\n}\n\n// Bug: someone forgot to validate\nclass NotificationService {\n send(email: string, message: string): void {\n // Oops, no validation here!\n this.emailClient.send(email, message);\n }\n}","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"AlertCircle","title":"Problems with Primitive Obsession","content":"When domain concepts are represented as primitives: (1) Validation is scattered and duplicated, (2) Invalid values can slip through cracks, (3) Domain logic has no natural home, (4) Code loses domain expressiveness, (5) Mixing incompatible values (email vs phone number) causes silent bugs.","variant":"warning"},"type":"callout"},{"data":{"content":"The solution is to create a proper value object:"},"type":"text"},{"data":{"fileName":"email-value-object.ts","languages":[{"code":"$7f","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"items":["**Validation in one place** — Create once, trust everywhere. If you have an `Email` object, it's valid.","**Type safety** — Can't accidentally pass a phone number where email is expected.","**Domain behavior has a home** — `email.getDomain()`, `email.isBusinessEmail()` belong here.","**Self-documenting code** — Method signatures reveal intent: `send(Email email)` vs `send(String email)`.","**Encapsulated normalization** — Lowercase, trim, format conversions happen automatically."],"title":{"icon":"CheckCircle","text":"Benefits of Value Objects over Primitives","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"titleType":"number","titleNumber":4},{"id":"characteristics","title":"Characteristics of Well-Designed Value Objects","content":[{"data":{"content":"A well-designed value object is:"},"type":"text"},{"data":{"items":["**Immutable** — No setters, no mutation methods. All operations create new instances. This guarantees thread-safety and eliminates aliasing bugs.","**Self-validating** — Invalid instances cannot exist. Validation happens at construction, throwing immediately if constraints are violated.","**Equality by value** — Two objects are equal if and only if all their attributes are equal. Implements `equals()` and `hashCode()` properly.","**Side-effect free** — Methods query state or return new values; they never modify the object or produce observable side effects.","**Expressiveness via behavior** — Contains domain-relevant methods that reveal what can be done with this concept."],"title":{"icon":"Target","text":"Essential Characteristics","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"icon":"Info","title":"Immutability is Non-Negotiable","content":"Immutability is the cornerstone of value objects. A mutable value object is a contradiction—if it can change, it has state that persists across changes, which implies tracking identity. Immutability also provides thread-safety for free: you can share value objects across threads without synchronization.","variant":"note"},"type":"callout"},{"data":{"content":"### Implementing Proper Equality\n\nValue equality must be implemented correctly. Two Money objects of $50.00 USD must be equal regardless of which instance they are:"},"type":"text"},{"data":{"fileName":"value-equality.ts","languages":[{"code":"$80","label":"TypeScript","value":"typescript"},{"code":"$81","label":"Java","value":"java"}]},"type":"code"}],"titleType":"number","titleNumber":5},{"id":"common-value-objects","title":"Common Domain Value Objects","content":[{"data":{"content":"While value objects are domain-specific, certain patterns appear across most business domains. Recognizing these helps you identify candidates in your own domain:"},"type":"text"},{"data":{"rows":[["Monetary","Money, Currency, Tax, Discount, Price","Arithmetic, formatting, currency conversion"],["Temporal","DateRange, TimeSlot, Duration, Deadline","Overlap detection, containment, comparison"],["Geographic","Address, Coordinates, Distance, Region","Formatting, proximity, containment"],["Identity Tokens","Email, PhoneNumber, URL, SSN, VIN","Validation, normalization, parsing"],["Quantities","Weight, Volume, Length, Temperature","Unit conversion, arithmetic, comparison"],["Business","SKU, OrderNumber, InvoiceNumber","Validation, formatting, parsing"],["Ranges","PriceRange, AgeRange, QuantityRange","Containment, overlap, intersection"],["Composite","FullName, PersonName, CompanyName","Formatting, parsing, comparison"]],"caption":"Common Value Objects Across Domains","headers":["Category","Value Objects","Key Behaviors"]},"type":"table"},{"data":{"icon":"Lightbulb","title":"Value Object Discovery Heuristic","content":"Look for attributes in your entities that are primitives but carry domain meaning. Ask: 'What validation should this have? What operations make sense on this value?' If there are behaviors beyond simple get/set, you likely have a value object hiding inside a primitive.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"language-implementations","title":"Value Objects Across Languages","content":[{"data":{"content":"Different programming languages offer varying levels of support for value object implementation. Some languages have built-in constructs; others require more ceremony."},"type":"text"},{"data":{"tabs":[{"id":"java","label":"Java (Records)","content":[{"data":{"content":"Java 16+ introduced **records**, which are ideal for simple value objects:"},"type":"text"},{"data":{"languages":[{"code":"// Java Record - immutable value object with minimal boilerplate\npublic record Money(BigDecimal amount, Currency currency) {\n \n // Compact constructor for validation\n public Money {\n if (amount.compareTo(BigDecimal.ZERO) < 0) {\n throw new IllegalArgumentException(\"Amount cannot be negative\");\n }\n amount = amount.setScale(2, RoundingMode.HALF_UP);\n }\n\n // Additional factory methods\n public static Money usd(double amount) {\n return new Money(BigDecimal.valueOf(amount), Currency.USD);\n }\n\n // Operations return new instances\n public Money add(Money other) {\n requireSameCurrency(other);\n return new Money(amount.add(other.amount), currency);\n }\n}\n\n// Records provide:\n// - equals() based on all components\n// - hashCode() based on all components \n// - toString() showing all components\n// - Immutability (fields are final)","label":"Java","value":"java"}]},"type":"code"}],"titleIcon":"Code2"},{"id":"csharp","label":"C# (Records)","content":[{"data":{"content":"C# 9+ **records** provide excellent value object support:"},"type":"text"},{"data":{"languages":[{"code":"// C# Record - immutable value type\npublic record Money(decimal Amount, Currency Currency)\n{\n // Validation via init\n public decimal Amount { get; init; } = Amount >= 0 \n ? Math.Round(Amount, 2) \n : throw new ArgumentException(\"Amount cannot be negative\");\n\n // Factory method\n public static Money Usd(decimal amount) => \n new Money(amount, Currency.USD);\n\n // Operations return new instances\n public Money Add(Money other)\n {\n RequireSameCurrency(other);\n return this with { Amount = Amount + other.Amount };\n }\n\n // 'with' expressions for creating modified copies\n public Money WithCurrency(Currency newCurrency, decimal rate) =>\n this with { \n Amount = Amount * rate, \n Currency = newCurrency \n };\n}\n\n// Records provide:\n// - Value-based equality \n// - Immutability\n// - 'with' expressions for copies\n// - Deconstruction","label":"C#","value":"csharp"}]},"type":"code"}],"titleIcon":"Code2"},{"id":"python","label":"Python (dataclass)","content":[{"data":{"content":"Python uses **frozen dataclasses** for value objects:"},"type":"text"},{"data":{"languages":[{"code":"$82","label":"Python","value":"python"}]},"type":"code"}],"titleIcon":"Code2"},{"id":"kotlin","label":"Kotlin (data class)","content":[{"data":{"content":"Kotlin **data classes** with val properties provide value semantics:"},"type":"text"},{"data":{"languages":[{"code":"// Kotlin data class - immutable when using val\ndata class Money(\n val amount: BigDecimal,\n val currency: Currency\n) {\n init {\n require(amount >= BigDecimal.ZERO) { \"Amount cannot be negative\" }\n }\n\n companion object {\n fun usd(amount: Double): Money = \n Money(BigDecimal.valueOf(amount).setScale(2, RoundingMode.HALF_UP), Currency.USD)\n }\n\n // Operations return new instances using copy()\n fun add(other: Money): Money {\n requireSameCurrency(other)\n return copy(amount = amount + other.amount)\n }\n\n fun multiply(factor: Double): Money =\n copy(amount = amount * BigDecimal.valueOf(factor))\n\n private fun requireSameCurrency(other: Money) {\n require(currency == other.currency) { \n \"Currency mismatch: $currency vs ${other.currency}\" \n }\n }\n}\n\n// data class provides:\n// - equals() and hashCode() based on properties\n// - copy() for creating modified copies\n// - componentN() for destructuring\n// - toString()","label":"Kotlin","value":"kotlin"}]},"type":"code"}],"titleIcon":"Code2"}],"defaultTab":"java"},"type":"tabs"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: What is a Value Object","content":[{"data":{"content":"We've established the foundational understanding of value objects. Let's consolidate the key insights:"},"type":"text"},{"data":{"type":"ordered","items":["**Value objects have no identity** — They are defined entirely by their attributes. Two objects with the same values are interchangeable.","**Value objects are immutable** — Once created, they never change. Operations return new instances.","**Value objects compare by value** — Equality is based on all attributes, not object reference or ID.","**Value objects combat primitive obsession** — They encapsulate validation and behavior for domain concepts.","**Value objects are self-validating** — Invalid instances cannot exist; validation happens at construction.","**Value objects reveal domain language** — They make code more expressive and self-documenting."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's next:**\n\nNow that we understand what value objects are, we'll dive deep into their two most critical characteristics: **immutability** and **equality**. The next page explores why immutability is non-negotiable, how to implement proper equality, and the subtle bugs that arise when these are done incorrectly."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the fundamental nature of value objects—identity-less, immutable objects defined by their attributes. You can recognize when a domain concept should be a value object and understand how they differ from entities. Next, we'll explore the critical topics of immutability and equality in depth.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_6bc7177051cf0600b2f9fc9d6504ca20","title":"Immutability and Equality","order":1,"content":null,"isLocked":true},{"id":"seed_e41c19ce67485bfaad2ffd1e69f4239c","title":"Value Object Design","order":2,"content":null,"isLocked":true},{"id":"seed_53170260af2fbc82d5da11cd36889a24","title":"When to Use Value Objects","order":3,"content":null,"isLocked":true}]}}