Encapsulation in Practice

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

// ❌ POOR ENCAPSULATION - Everything is exposed
public class BankAccount {
    // Public fields allow unrestricted access
    public String accountNumber;
    public String accountHolderName;
    public double balance;
    public List<String> transactionHistory;
    
    public BankAccount(String accountNumber, String name) {
        this.accountNumber = accountNumber;
        this.accountHolderName = name;
        this.balance = 0.0;
        this.transactionHistory = new ArrayList<>();
    }
}
 
// Client code can do anything
class Client {
    public void problematicUsage(BankAccount account) {
        // Direct field manipulation bypasses all validation
        account.balance = -5000;  // Negative balance? No problem!
        account.balance = account.balance * 2;  // Double the money!
        
        // Account number can be changed arbitrarily
        account.accountNumber = "FAKE123456";
        
        // Transaction history can be modified or deleted
        account.transactionHistory.clear();  // Evidence destroyed!
        account.transactionHistory.add("Fake deposit: $1,000,000");
    }
}

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

// ✅ PROPER ENCAPSULATION - Controlled access, enforced invariants
public final class BankAccount {
    // All fields are private - no direct access possible
    private final String accountNumber;  // Immutable after creation
    private final String accountHolderName;  // Immutable identity
    private double balance;
    private final List<Transaction> transactionHistory;
    
    // Private nested class - implementation detail hidden from clients
    private static class Transaction {
        private final LocalDateTime timestamp;
        private final String type;
        private final double amount;
        private final double balanceAfter;
        
        Transaction(String type, double amount, double balanceAfter) {
            this.timestamp = LocalDateTime.now();
            this.type = type;
            this.amount = amount;
            this.balanceAfter = balanceAfter;
        }
    }
    
    // Constructor enforces initial invariants
    public BankAccount(String accountNumber, String accountHolderName) {
        validateAccountNumber(accountNumber);
        validateAccountHolderName(accountHolderName);
        
        this.accountNumber = accountNumber;
        this.accountHolderName = accountHolderName;
        this.balance = 0.0;
        this.transactionHistory = new ArrayList<>();
    }
    
    // Private validation - implementation detail
    private void validateAccountNumber(String accountNumber) {
        if (accountNumber == null || !accountNumber.matches("[A-Z]{2}\\d{8}")) {
            throw new IllegalArgumentException(
                "Account number must be 2 letters followed by 8 digits"
            );
        }
    }
    
    private void validateAccountHolderName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException(
                "Account holder name cannot be empty"
            );
        }
    }
    
    // Controlled operations - enforce business rules
    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit amount must be positive");
        }
        
        this.balance += amount;
        recordTransaction("DEPOSIT", amount);
    }
    
    public void withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Withdrawal amount must be positive");
        }
        if (amount > this.balance) {
            throw new InsufficientFundsException(
                "Cannot withdraw " + amount + " from balance of " + balance
            );
        }
        
        this.balance -= amount;
        recordTransaction("WITHDRAWAL", amount);
    }
    
    // Private helper - encapsulated implementation
    private void recordTransaction(String type, double amount) {
        transactionHistory.add(new Transaction(type, amount, this.balance));
    }
    
    // Getters provide read-only access
    public String getAccountNumber() {
        return accountNumber;  // String is immutable, safe to return
    }
    
    public String getAccountHolderName() {
        return accountHolderName;
    }
    
    public double getBalance() {
        return balance;  // Primitive, safe to return
    }
    
    // Defensive copy prevents client modification of internal list
    public List<String> getTransactionHistory() {
        return transactionHistory.stream()
            .map(t -> String.format("[%s] %s: $%.2f (Balance: $%.2f)",
                t.timestamp.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME),
                t.type,
                t.amount,
                t.balanceAfter))
            .collect(Collectors.toUnmodifiableList());
    }
}

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

// ❌ SECURITY NIGHTMARE - Exposed internals enable attacks
public class UserSession {
                                            public String sessionId;
                                            public String userId;
                                            public boolean isAuthenticated;
                                            public boolean isAdmin;
                                            public Date expirationTime;
                                            public Map<String, Object> sessionData;
                                            
                                            public UserSession() {
                                                sessionData = new HashMap<>();
                                            }
}
 
// Attack scenarios enabled by poor encapsulation
class Attacker {
    public void elevatePrivileges(UserSession session) {
        // Become admin without proper authorization
        session.isAdmin = true;
        session.isAuthenticated = true;
    }
    
    public void hijackSession(UserSession session) {
        // Steal session by changing the ID
        session.sessionId = "stolen-valid-session-id";
        session.userId = "admin";
    }
    
    public void extendSession(UserSession session) {
        // Never expire
        session.expirationTime = new Date(Long.MAX_VALUE);
    }
    
    public void injectPayload(UserSession session) {
        // Inject malicious data
        session.sessionData.put("serializedObject", maliciousPayload);
    }
}

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

// ✅ SECURE DESIGN - Encapsulation enforces security policies
public final class UserSession {
    private final String sessionId;
    private final String userId;
    private final Instant createdAt;
    private final Instant expiresAt;
    private final Set<Permission> permissions;
    private final Map<String, String> sessionAttributes;
    private volatile boolean invalidated;
    
    // Factory method controls creation, generates cryptographic session ID
    public static UserSession create(User user, Duration validityPeriod) {
        Objects.requireNonNull(user, "User cannot be null");
        Objects.requireNonNull(validityPeriod, "Validity period cannot be null");
        
        if (validityPeriod.isNegative() || validityPeriod.isZero()) {
            throw new IllegalArgumentException("Validity period must be positive");
        }
        
        return new UserSession(
            generateSecureSessionId(),
            user.getId(),
            Instant.now(),
            Instant.now().plus(validityPeriod),
            Set.copyOf(user.getPermissions())  // Defensive copy
        );
    }
    
    // Private constructor - can only be called through factory
    private UserSession(String sessionId, String userId, 
                        Instant createdAt, Instant expiresAt,
                        Set<Permission> permissions) {
        this.sessionId = sessionId;
        this.userId = userId;
        this.createdAt = createdAt;
        this.expiresAt = expiresAt;
        this.permissions = permissions;
        this.sessionAttributes = new ConcurrentHashMap<>();
        this.invalidated = false;
    }
    
    // Secure session ID generation - implementation hidden
    private static String generateSecureSessionId() {
        byte[] randomBytes = new byte[32];
        new SecureRandom().nextBytes(randomBytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(randomBytes);
    }
    
    // Status checks enforce temporal validity
    public boolean isValid() {
        return !invalidated && Instant.now().isBefore(expiresAt);
    }
    
    public boolean hasPermission(Permission permission) {
        if (!isValid()) {
            throw new SessionExpiredException("Session is no longer valid");
        }
        return permissions.contains(permission);
    }
    
    public boolean isAdmin() {
        return hasPermission(Permission.ADMIN);
    }
    
    // Invalidation is one-way - cannot be reversed
    public void invalidate() {
        this.invalidated = true;
        this.sessionAttributes.clear();
    }
    
    // Session attributes with controlled access
    public void setAttribute(String key, String value) {
        if (!isValid()) {
            throw new SessionExpiredException("Cannot modify expired session");
        }
        validateAttributeKey(key);
        sessionAttributes.put(key, value);
    }
    
    public Optional<String> getAttribute(String key) {
        if (!isValid()) {
            return Optional.empty();
        }
        return Optional.ofNullable(sessionAttributes.get(key));
    }
    
    private void validateAttributeKey(String key) {
        if (key == null || key.isEmpty() || key.length() > 100) {
            throw new IllegalArgumentException("Invalid attribute key");
        }
        // Prevent injection of system attributes
        if (key.startsWith("__")) {
            throw new SecurityException("Reserved attribute prefix");
        }
    }
    
    // Read-only access to identity
    public String getSessionId() { return sessionId; }
    public String getUserId() { return userId; }
    public Instant getExpiresAt() { return expiresAt; }
    
    // Defensive copy of permissions
    public Set<Permission> getPermissions() {
        return Set.copyOf(permissions);
    }
}

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

// ❌ BUSINESS LOGIC VIOLATIONS - Invariants can be broken
public class ShoppingCart {
    public List<CartItem> items;
    public double totalPrice;
    public String discountCode;
    public double discountPercentage;
    
    public ShoppingCart() {
        items = new ArrayList<>();
        totalPrice = 0.0;
    }
}
 
public class CartItem {
    public String productId;
    public String productName;
    public int quantity;
    public double unitPrice;
    public double lineTotal;
}
 
// Client can violate all business rules
class FraudulentClient {
    public void manipulateCart(ShoppingCart cart) {
        // Set arbitrary discount
        cart.discountPercentage = 99.9;  // 99.9% off!
        
        // Modify prices directly
        for (CartItem item : cart.items) {
            item.unitPrice = 0.01;  // Everything for a penny!
            item.lineTotal = 0.01;
        }
        
        // Override total
        cart.totalPrice = 0.01;
        
        // Negative quantities?
        CartItem freeItem = new CartItem();
        freeItem.quantity = -100;  // Get paid for taking items!
        cart.items.add(freeItem);
    }
}

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

// ✅ PROPER ENCAPSULATION - Business rules enforced
public final class ShoppingCart {
    private final String cartId;
    private final String customerId;
    private final Map<String, CartItem> items;  // productId -> item
    private DiscountCode appliedDiscount;
    private final Instant createdAt;
    
    public ShoppingCart(String customerId) {
        this.cartId = UUID.randomUUID().toString();
        this.customerId = Objects.requireNonNull(customerId);
        this.items = new LinkedHashMap<>();  // Preserves insertion order
        this.appliedDiscount = null;
        this.createdAt = Instant.now();
    }
    
    // Adding items enforces validation and auto-calculates
    public void addItem(Product product, int quantity) {
        Objects.requireNonNull(product, "Product cannot be null");
        
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        
        if (quantity > product.getMaxOrderQuantity()) {
            throw new QuantityLimitExceededException(
                "Maximum " + product.getMaxOrderQuantity() + " items allowed"
            );
        }
        
        items.compute(product.getId(), (id, existing) -> {
            if (existing == null) {
                return new CartItem(product, quantity);
            }
            int newQuantity = existing.getQuantity() + quantity;
            if (newQuantity > product.getMaxOrderQuantity()) {
                throw new QuantityLimitExceededException(
                    "Cart would exceed maximum quantity"
                );
            }
            return existing.withQuantity(newQuantity);
        });
    }
    
    public void updateQuantity(String productId, int newQuantity) {
        if (newQuantity <= 0) {
            removeItem(productId);
            return;
        }
        
        CartItem item = items.get(productId);
        if (item == null) {
            throw new ItemNotFoundException("Product not in cart: " + productId);
        }
        
        if (newQuantity > item.getProduct().getMaxOrderQuantity()) {
            throw new QuantityLimitExceededException("Maximum quantity exceeded");
        }
        
        items.put(productId, item.withQuantity(newQuantity));
    }
    
    public void removeItem(String productId) {
        if (items.remove(productId) == null) {
            throw new ItemNotFoundException("Product not in cart: " + productId);
        }
    }
    
    // Discount application with business rules
    public void applyDiscountCode(DiscountCode code) {
        Objects.requireNonNull(code);
        
        if (!code.isValid()) {
            throw new InvalidDiscountException("Discount code has expired");
        }
        
        if (!code.isApplicableTo(this)) {
            throw new InvalidDiscountException(
                "Discount requires minimum spend of " + code.getMinimumSpend()
            );
        }
        
        this.appliedDiscount = code;
    }
    
    public void removeDiscount() {
        this.appliedDiscount = null;
    }
    
    // Calculated properties - no setters, always derived
    public Money getSubtotal() {
        return items.values().stream()
            .map(CartItem::getLineTotal)
            .reduce(Money.ZERO, Money::add);
    }
    
    public Money getDiscountAmount() {
        if (appliedDiscount == null) {
            return Money.ZERO;
        }
        return appliedDiscount.calculateDiscount(getSubtotal());
    }
    
    public Money getTotal() {
        return getSubtotal().subtract(getDiscountAmount());
    }
    
    // Read-only access to cart contents
    public List<CartItemView> getItems() {
        return items.values().stream()
            .map(CartItemView::from)  // Transform to read-only view objects
            .collect(Collectors.toUnmodifiableList());
    }
    
    public int getItemCount() {
        return items.values().stream()
            .mapToInt(CartItem::getQuantity)
            .sum();
    }
    
    public boolean isEmpty() {
        return items.isEmpty();
    }
    
    public String getCartId() { return cartId; }
    public String getCustomerId() { return customerId; }
}
 
// Immutable cart item - internal use only
final class CartItem {
    private final Product product;
    private final int quantity;
    private final Money lineTotal;
    
    CartItem(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
        this.lineTotal = product.getPrice().multiply(quantity);
    }
    
    CartItem withQuantity(int newQuantity) {
        return new CartItem(this.product, newQuantity);
    }
    
    // Package-private getters
    Product getProduct() { return product; }
    int getQuantity() { return quantity; }
    Money getLineTotal() { return lineTotal; }
}
 
// View object for external consumption - completely immutable
public record CartItemView(
    String productId,
    String productName,
    int quantity,
    Money unitPrice,
    Money lineTotal
) {
    static CartItemView from(CartItem item) {
        return new CartItemView(
            item.getProduct().getId(),
            item.getProduct().getName(),
            item.getQuantity(),
            item.getProduct().getPrice(),
            item.getLineTotal()
        );
    }
}

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// ✅ ENCAPSULATED CONFIGURATION - Type-safe, validated, immutable
public final class AppConfiguration {
    private final DatabaseConfig database;
    private final CacheConfig cache;
    private final SecurityConfig security;
    private final Map<String, String> featureFlags;
    private final Instant loadedAt;
    
    private AppConfiguration(Builder builder) {
        this.database = Objects.requireNonNull(builder.database);
        this.cache = Objects.requireNonNull(builder.cache);
        this.security = Objects.requireNonNull(builder.security);
        this.featureFlags = Map.copyOf(builder.featureFlags);
        this.loadedAt = Instant.now();
        
        validate();
    }
    
    private void validate() {
        // Cross-cutting validation
        if (database.getMaxConnections() < cache.getPoolSize()) {
            throw new ConfigurationException(
                "Database connections must be >= cache pool size"
            );
        }
        
        if (security.getSessionTimeout().compareTo(Duration.ofMinutes(1)) < 0) {
            throw new ConfigurationException(
                "Session timeout must be at least 1 minute"
            );
        }
    }
    
    // Type-safe access to nested configurations
    public DatabaseConfig database() { return database; }
    public CacheConfig cache() { return cache; }
    public SecurityConfig security() { return security; }
    
    // Feature flag queries with defaults
    public boolean isFeatureEnabled(String feature) {
        return "true".equalsIgnoreCase(featureFlags.getOrDefault(feature, "false"));
    }
    
    public Optional<String> getFeatureFlag(String feature) {
        return Optional.ofNullable(featureFlags.get(feature));
    }
    
    // Builder pattern for controlled construction
    public static Builder builder() {
        return new Builder();
    }
    
    public static class Builder {
        private DatabaseConfig database;
        private CacheConfig cache;
        private SecurityConfig security;
        private Map<String, String> featureFlags = new HashMap<>();
        
        public Builder database(DatabaseConfig config) {
            this.database = config;
            return this;
        }
        
        public Builder cache(CacheConfig config) {
            this.cache = config;
            return this;
        }
        
        public Builder security(SecurityConfig config) {
            this.security = config;
            return this;
        }
        
        public Builder featureFlag(String name, String value) {
            this.featureFlags.put(name, value);
            return this;
        }
        
        public AppConfiguration build() {
            return new AppConfiguration(this);
        }
    }
}
 
// Nested configuration - also immutable and validated
public final class DatabaseConfig {
    private final String host;
    private final int port;
    private final String database;
    private final int maxConnections;
    private final Duration connectionTimeout;
    
    public DatabaseConfig(String host, int port, String database,
                          int maxConnections, Duration connectionTimeout) {
        this.host = requireNonEmpty(host, "host");
        this.port = requireValidPort(port);
        this.database = requireNonEmpty(database, "database");
        this.maxConnections = requirePositive(maxConnections, "maxConnections");
        this.connectionTimeout = requirePositiveDuration(connectionTimeout);
    }
    
    private String requireNonEmpty(String value, String name) {
        if (value == null || value.trim().isEmpty()) {
            throw new ConfigurationException(name + " cannot be empty");
        }
        return value.trim();
    }
    
    private int requireValidPort(int port) {
        if (port < 1 || port > 65535) {
            throw new ConfigurationException("Port must be 1-65535");
        }
        return port;
    }
    
    private int requirePositive(int value, String name) {
        if (value <= 0) {
            throw new ConfigurationException(name + " must be positive");
        }
        return value;
    }
    
    private Duration requirePositiveDuration(Duration duration) {
        if (duration == null || duration.isNegative() || duration.isZero()) {
            throw new ConfigurationException("Duration must be positive");
        }
        return duration;
    }
    
    // Immutable access
    public String getHost() { return host; }
    public int getPort() { return port; }
    public String getDatabase() { return database; }
    public int getMaxConnections() { return maxConnections; }
    public Duration getConnectionTimeout() { return connectionTimeout; }
    
    // Derived connection string - implementation detail
    public String toConnectionString() {
        return String.format("jdbc:postgresql://%s:%d/%s", host, port, database);
    }
}