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

// File: com/vehicles/Vehicle.java
package com.vehicles;
 
public abstract class Vehicle {
    // Private: only Vehicle can access
    private String vin;
    
    // Protected: Vehicle and all subclasses can access
    protected String manufacturer;
    protected int yearManufactured;
    protected double fuelCapacity;
    
    // Protected method: customization hook for subclasses
    protected abstract double calculateFuelEfficiency();
    
    // Protected helper method
    protected void logDiagnostic(String message) {
        System.out.println("[" + getClass().getSimpleName() + "] " + message);
    }
    
    public Vehicle(String vin, String manufacturer, int year) {
        this.vin = vin;
        this.manufacturer = manufacturer;
        this.yearManufactured = year;
    }
    
    // Public API uses protected internals
    public double estimateRange(double currentFuel) {
        double efficiency = calculateFuelEfficiency();  // Calls protected abstract
        logDiagnostic("Calculating range with efficiency: " + efficiency);
        return currentFuel * efficiency;
    }
}
 
// File: com/cars/SportsCar.java — DIFFERENT PACKAGE
package com.cars;
 
import com.vehicles.Vehicle;
 
public class SportsCar extends Vehicle {
    private double horsePower;
    
    public SportsCar(String vin, String maker, int year, double hp) {
        super(vin, maker, year);
        this.horsePower = hp;
    }
    
    @Override
    protected double calculateFuelEfficiency() {
        // ✅ Can access protected fields from parent
        logDiagnostic("Computing for " + manufacturer + " " + yearManufactured);
        
        // Sports cars less efficient with more power
        double baseMPG = 30.0;
        double powerPenalty = horsePower / 100;
        return baseMPG - powerPenalty;
    }
    
    public void showSpecs() {
        // ✅ Can access protected fields inherited from Vehicle
        System.out.println("Manufacturer: " + manufacturer);
        System.out.println("Year: " + yearManufactured);
        System.out.println("Fuel Capacity: " + fuelCapacity);
        
        // ❌ COMPILE ERROR: Cannot access private from parent
        // System.out.println("VIN: " + vin);  // Error!
    }
}
 
// File: com/app/Application.java — EXTERNAL CODE
package com.app;
 
import com.cars.SportsCar;
 
public class Application {
    public static void main(String[] args) {
        SportsCar car = new SportsCar("ABC123", "Ferrari", 2024, 700);
        
        // ✅ Can call public methods
        double range = car.estimateRange(15.0);
        car.showSpecs();
        
        // ❌ COMPILE ERROR: Cannot access protected from non-subclass
        // car.manufacturer = "Fake";           // Error!
        // car.logDiagnostic("Hacked");         // Error!
        // double eff = car.calculateFuelEfficiency();  // Error!
    }
}

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

public abstract class AbstractHttpClient {
    // PRIVATE: Internal implementation - no one else should touch
    private final ConnectionPool connectionPool;
    private final RetryPolicy retryPolicy;
    private int requestCount;
    
    // PROTECTED: Subclasses may need to customize these behaviors
    protected int connectionTimeout = 5000;
    protected int readTimeout = 30000;
    protected String userAgent = "AbstractHttpClient/1.0";
    
    // PROTECTED METHOD: Hook for subclasses to customize authentication
    protected abstract void addAuthenticationHeaders(HttpRequest request);
    
    // PROTECTED METHOD: Hook for subclasses to process response
    protected HttpResponse processResponse(HttpResponse response) {
        // Default: just return as-is
        return response;
    }
    
    // PROTECTED HELPER: Subclasses might need to log
    protected void logRequest(HttpRequest request) {
        System.out.println("Request: " + request.getMethod() + " " + request.getUrl());
    }
    
    // PUBLIC: The API that clients use
    public final HttpResponse execute(HttpRequest request) {
        // Use protected timeout settings
        request.setConnectionTimeout(connectionTimeout);
        request.setReadTimeout(readTimeout);
        request.setHeader("User-Agent", userAgent);
        
        // Call protected hook
        addAuthenticationHeaders(request);
        
        // Use private members for core logic
        logRequest(request);
        requestCount++;
        
        Connection conn = connectionPool.acquire();
        try {
            HttpResponse response = executeWithRetry(conn, request);
            return processResponse(response);  // Protected hook
        } finally {
            connectionPool.release(conn);
        }
    }
    
    // PRIVATE: Internal implementation detail
    private HttpResponse executeWithRetry(Connection conn, HttpRequest request) {
        return retryPolicy.execute(() -> conn.send(request));
    }
    
    // PUBLIC: Useful for monitoring
    public int getRequestCount() {
        return requestCount;
    }
}

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

/**
 * Abstract base class for data export operations.
 * Subclasses customize format-specific behavior via protected methods.
 */
public abstract class DataExporter {
    // Private state: internal bookkeeping
    private int recordsExported;
    private Instant exportStartTime;
    
    // Protected state: subclasses may need this
    protected final Logger logger;
    protected final MetricsCollector metrics;
    
    public DataExporter(Logger logger, MetricsCollector metrics) {
        this.logger = logger;
        this.metrics = metrics;
    }
    
    // PUBLIC: The template method - fixed algorithm structure
    public final ExportResult export(List<Record> records, OutputStream output) {
        logger.info("Starting export of {} records", records.size());
        exportStartTime = Instant.now();
        recordsExported = 0;
        
        try {
            // Step 1: Write header (customizable)
            writeHeader(output);
            
            // Step 2: Write each record (customizable)
            for (Record record : records) {
                writeRecord(record, output);
                recordsExported++;
            }
            
            // Step 3: Write footer (customizable)
            writeFooter(output);
            
            // Step 4: Post-processing (optional hook)
            afterExport(records.size());
            
            Duration elapsed = Duration.between(exportStartTime, Instant.now());
            metrics.recordExport(recordsExported, elapsed);
            
            return ExportResult.success(recordsExported, elapsed);
            
        } catch (Exception e) {
            logger.error("Export failed after {} records", recordsExported, e);
            return ExportResult.failure(e.getMessage(), recordsExported);
        }
    }
    
    // PROTECTED ABSTRACT: Must be implemented by subclasses
    protected abstract void writeHeader(OutputStream output) throws IOException;
    protected abstract void writeRecord(Record record, OutputStream output) throws IOException;
    protected abstract void writeFooter(OutputStream output) throws IOException;
    
    // PROTECTED HOOK: Optional customization point
    protected void afterExport(int totalRecords) {
        // Default: do nothing. Subclasses can override for cleanup, notifications, etc.
    }
    
    // PROTECTED HELPER: Subclasses can use for common formatting
    protected String formatTimestamp(Instant timestamp) {
        return DateTimeFormatter.ISO_INSTANT.format(timestamp);
    }
    
    protected String escapeSpecialCharacters(String input) {
        // Common escaping logic subclasses can reuse
        if (input == null) return "";
        return input.replace("\\", "\\\\")
                    .replace("\n", "\\n")
                    .replace("\r", "\\r");
    }
}
 
// Subclass for CSV export
public class CsvExporter extends DataExporter {
    private static final String DELIMITER = ",";
    
    public CsvExporter(Logger logger, MetricsCollector metrics) {
        super(logger, metrics);
    }
    
    @Override
    protected void writeHeader(OutputStream output) throws IOException {
        // Use protected helper for formatting
        String header = "id" + DELIMITER + "name" + DELIMITER + "timestamp\n";
        output.write(header.getBytes());
        logger.debug("Wrote CSV header");  // Use protected logger
    }
    
    @Override
    protected void writeRecord(Record record, OutputStream output) throws IOException {
        String line = record.getId() + DELIMITER +
                      escapeSpecialCharacters(record.getName()) + DELIMITER +  // Protected helper
                      formatTimestamp(record.getTimestamp()) + "\n";           // Protected helper
        output.write(line.getBytes());
    }
    
    @Override
    protected void writeFooter(OutputStream output) throws IOException {
        // CSV has no footer
    }
}
 
// Subclass for JSON export
public class JsonExporter extends DataExporter {
    private final ObjectMapper mapper = new ObjectMapper();
    private boolean firstRecord = true;
    
    public JsonExporter(Logger logger, MetricsCollector metrics) {
        super(logger, metrics);
    }
    
    @Override
    protected void writeHeader(OutputStream output) throws IOException {
        output.write("[\n".getBytes());
        firstRecord = true;
    }
    
    @Override
    protected void writeRecord(Record record, OutputStream output) throws IOException {
        if (!firstRecord) {
            output.write(",\n".getBytes());
        }
        firstRecord = false;
        output.write(mapper.writeValueAsBytes(record));
    }
    
    @Override
    protected void writeFooter(OutputStream output) throws IOException {
        output.write("\n]".getBytes());
    }
    
    @Override
    protected void afterExport(int totalRecords) {
        // Custom cleanup: log summary
        logger.info("JSON export complete: {} records", totalRecords);
        metrics.recordCustomMetric("json.export.count", totalRecords);
    }
}

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

// PROBLEMATIC: Protected field exposed directly
public abstract class ConfigurableService {
    // Every subclass can freely modify this!
    protected int maxRetries = 3;
    protected Duration timeout = Duration.ofSeconds(30);
    
    public void execute() {
        for (int i = 0; i <= maxRetries; i++) {
            try {
                doExecute();
                return;
            } catch (Exception e) {
                if (i == maxRetries) throw e;
            }
        }
    }
}
 
// Subclass does something unintended
public class BrokenService extends ConfigurableService {
    public BrokenService() {
        maxRetries = -1;  // Negative retries - logic breaks!
        timeout = Duration.ofNanos(1);  // Impossible timeout
    }
}
 
// ============================================
 
// BETTER: Protected accessors with validation
public abstract class ConfigurableService {
    private int maxRetries = 3;
    private Duration timeout = Duration.ofSeconds(30);
    
    // Protected getter: subclasses can read
    protected int getMaxRetries() {
        return maxRetries;
    }
    
    // Protected setter: subclasses can modify, but with validation
    protected void setMaxRetries(int retries) {
        if (retries < 0) {
            throw new IllegalArgumentException("Retries cannot be negative");
        }
        if (retries > 10) {
            throw new IllegalArgumentException("Max retries is 10");
        }
        this.maxRetries = retries;
    }
    
    protected Duration getTimeout() {
        return timeout;
    }
    
    protected void setTimeout(Duration timeout) {
        if (timeout.isNegative() || timeout.isZero()) {
            throw new IllegalArgumentException("Timeout must be positive");
        }
        if (timeout.compareTo(Duration.ofMinutes(5)) > 0) {
            throw new IllegalArgumentException("Timeout cannot exceed 5 minutes");
        }
        this.timeout = timeout;
    }
    
    public void execute() {
        for (int i = 0; i <= getMaxRetries(); i++) {
            // ... (uses protected getter)
        }
    }
}
 
// Subclass using protected accessors
public class ResilientService extends ConfigurableService {
    public ResilientService() {
        setMaxRetries(5);  // Valid
        setTimeout(Duration.ofMinutes(2));  // Valid
        
        // These would throw immediately:
        // setMaxRetries(-1);  // IllegalArgumentException
        // setTimeout(Duration.ZERO);  // IllegalArgumentException
    }
}

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

/**
 * Simplified version of how HttpServlet uses protected methods
 */
public abstract class HttpServlet {
    
    // PUBLIC entry point - framework calls this
    public final void service(HttpRequest request, HttpResponse response) {
        String method = request.getMethod();
        
        switch (method) {
            case "GET":
                doGet(request, response);
                break;
            case "POST":
                doPost(request, response);
                break;
            case "PUT":
                doPut(request, response);
                break;
            case "DELETE":
                doDelete(request, response);
                break;
            default:
                response.sendError(405, "Method Not Allowed");
        }
    }
    
    // PROTECTED: Subclasses override to handle specific methods
    protected void doGet(HttpRequest req, HttpResponse resp) {
        resp.sendError(405, "GET not supported");
    }
    
    protected void doPost(HttpRequest req, HttpResponse resp) {
        resp.sendError(405, "POST not supported");
    }
    
    protected void doPut(HttpRequest req, HttpResponse resp) {
        resp.sendError(405, "PUT not supported");
    }
    
    protected void doDelete(HttpRequest req, HttpResponse resp) {
        resp.sendError(405, "DELETE not supported");
    }
    
    // PROTECTED HELPER: Subclasses can use for common tasks
    protected String getInitParameter(String name) {
        // ... load from configuration
        return "";
    }
    
    protected void log(String message) {
        // ... framework logging
    }
}
 
// Application subclass
public class UserServlet extends HttpServlet {
    
    @Override
    protected void doGet(HttpRequest req, HttpResponse resp) {
        String userId = req.getParameter("id");
        log("Fetching user: " + userId);  // Using protected helper
        
        User user = userService.findById(userId);
        resp.writeJson(user);
    }
    
    @Override
    protected void doPost(HttpRequest req, HttpResponse resp) {
        User user = req.readJson(User.class);
        userService.save(user);
        resp.setStatus(201);
    }
    
    // doPut and doDelete are NOT overridden
    // They return 405 Method Not Allowed (default behavior)
}

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

// JAVA: Protected includes package access
/*
public class Parent {
    protected void method() {}
}
 
// Same package, NOT a subclass - CAN access (Java quirk)
class SamePackageHelper {
    void test(Parent p) {
        p.method();  // ✅ Works in Java!
    }
}
*/
 
// C#: protected vs protected internal
/*
public class Parent {
    protected void OnlySubclasses() {}          // Only subclasses
    protected internal void SubclassOrAssembly() {} // Subclass OR same assembly
    private protected void OnlySubclassInAssembly() {} // Subclass AND same assembly
}
*/
 
// TypeScript: protected for subclass access
class Animal {
    protected name: string;
    
    constructor(name: string) {
        this.name = name;
    }
    
    protected makeSound(): string {
        return "Some sound";
    }
}
 
class Dog extends Animal {
    constructor(name: string) {
        super(name);
    }
    
    bark(): string {
        // ✅ Can access protected members
        console.log(`${this.name} is barking`);
        return this.makeSound();  // Protected method accessible
    }
}
 
const dog = new Dog("Rex");
dog.bark();  // ✅ Works
// dog.name;  // ❌ Error: Property 'name' is protected
 
// Python: Convention-based (underscore prefix)
/*
class Parent:
    def __init__(self):
        self._protected_field = "for subclasses"
        self.__private_field = "truly private (name mangled)"
    
    def _protected_method(self):
        return "subclasses should use this"
 
class Child(Parent):
    def use_protected(self):
        # Convention says this is OK
        print(self._protected_field)
        self._protected_method()
 
# Python doesn't ENFORCE it - just convention
p = Parent()
print(p._protected_field)  # Works, but discouraged
*/

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

// ANTI-PATTERN: Using protected for code sharing
public class ReportGenerator {
    // Protected to share with subclasses
    protected String formatCurrency(double amount) {
        return String.format("$%.2f", amount);
    }
    
    protected String formatDate(LocalDate date) {
        return date.format(DateTimeFormatter.ISO_LOCAL_DATE);
    }
    
    public String generateSalesReport(List<Sale> sales) {
        StringBuilder sb = new StringBuilder();
        for (Sale sale : sales) {
            sb.append(formatDate(sale.getDate()))
              .append(": ")
              .append(formatCurrency(sale.getAmount()))
              .append("\n");
        }
        return sb.toString();
    }
}
 
// Subclass just to use the formatters
public class InvoiceGenerator extends ReportGenerator {
    public String generateInvoice(Invoice invoice) {
        // Using protected helpers from parent
        return "Invoice #" + invoice.getId() + 
               "\nDate: " + formatDate(invoice.getDate()) +
               "\nTotal: " + formatCurrency(invoice.getTotal());
    }
}
// PROBLEM: InvoiceGenerator IS-NOT-A ReportGenerator!
// We're abusing inheritance just for code reuse.
 
// ============================================
 
// BETTER: Composition with shared utility
public class CurrencyFormatter {
    public String format(double amount) {
        return String.format("$%.2f", amount);
    }
}
 
public class DateFormatter {
    public String format(LocalDate date) {
        return date.format(DateTimeFormatter.ISO_LOCAL_DATE);
    }
}
 
// Both classes USE formatters - no inheritance!
public class ReportGenerator {
    private final CurrencyFormatter currencyFormatter;
    private final DateFormatter dateFormatter;
    
    public ReportGenerator(CurrencyFormatter cf, DateFormatter df) {
        this.currencyFormatter = cf;
        this.dateFormatter = df;
    }
    
    public String generateSalesReport(List<Sale> sales) {
        StringBuilder sb = new StringBuilder();
        for (Sale sale : sales) {
            sb.append(dateFormatter.format(sale.getDate()))
              .append(": ")
              .append(currencyFormatter.format(sale.getAmount()))
              .append("\n");
        }
        return sb.toString();
    }
}
 
public class InvoiceGenerator {
    private final CurrencyFormatter currencyFormatter;
    private final DateFormatter dateFormatter;
    
    public InvoiceGenerator(CurrencyFormatter cf, DateFormatter df) {
        this.currencyFormatter = cf;
        this.dateFormatter = df;
    }
    
    public String generateInvoice(Invoice invoice) {
        return "Invoice #" + invoice.getId() + 
               "\nDate: " + dateFormatter.format(invoice.getDate()) +
               "\nTotal: " + currencyFormatter.format(invoice.getTotal());
    }
}
// BETTER: No inappropriate inheritance. Clear dependencies. Testable.