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

public class Account {
    private String accountId;       // Instance field
    private BigDecimal balance;     // Instance field
    
    // Static method - cannot access ANY instance state
    public static void processTransfer(
            Account from, 
            Account to, 
            BigDecimal amount) {
        
        // Cannot do this - no 'this' exists:
        // this.balance = this.balance.subtract(amount);  // ERROR!
        
        // Must work through explicitly passed objects:
        from.withdraw(amount);  // Call instance method on parameter
        to.deposit(amount);     // Call instance method on parameter
    }
    
    // Instance method - has full access to THIS object
    public void withdraw(BigDecimal amount) {
        if (this.balance.compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        this.balance = this.balance.subtract(amount);
    }
    
    // Instance method - has full access to THIS object
    public void deposit(BigDecimal amount) {
        this.balance = this.balance.add(amount);
    }
    
    // Static method trying to behave like instance method - BAD DESIGN
    public static BigDecimal getBalanceStatic(Account account) {
        return account.balance;  // Need to pass account explicitly
    }
    
    // Instance method - the natural design
    public BigDecimal getBalance() {
        return this.balance;  // 'this' available implicitly
    }
}
 
// Static design requires verbose parameter passing:
Account.processTransfer(accountA, accountB, amount);
 
// Instance design is more natural when operating ON an object:
accountA.transferTo(accountB, amount);

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

class Animal {
    // Instance method - can be overridden
    public void speak() {
        System.out.println("Animal makes a sound");
    }
    
    // Static method - CANNOT be overridden, only hidden
    public static void describe() {
        System.out.println("This is an animal");
    }
}
 
class Dog extends Animal {
    // Override - polymorphically replaces parent's speak()
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
    
    // Hiding - does NOT polymorphically replace, just shadows
    // @Override  // This annotation would cause compile error!
    public static void describe() {
        System.out.println("This is a dog");
    }
}
 
public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dogAsAnimal = new Dog();  // Dog stored as Animal
        Dog dog = new Dog();
        
        // --- INSTANCE METHOD: Polymorphism works ---
        animal.speak();        // "Animal makes a sound"
        dogAsAnimal.speak();   // "Dog barks" ← Actual type (Dog) matters!
        dog.speak();           // "Dog barks"
        
        // --- STATIC METHOD: No polymorphism ---
        Animal.describe();     // "This is an animal"
        Dog.describe();        // "This is a dog"
        
        // Calling on instance references (bad practice, but illustrates point)
        animal.describe();      // "This is an animal"
        dogAsAnimal.describe(); // "This is an animal" ← Declared type matters!
        dog.describe();         // "This is a dog"
        
        // The compiler sees dogAsAnimal as type Animal,
        // so it calls Animal.describe(), ignoring that it's actually a Dog!
    }
}

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

// EXAMPLE: Why polymorphism is essential for Strategy Pattern
 
// With instance methods - Strategy works perfectly
interface PaymentProcessor {
    PaymentResult process(Payment payment);
}
 
class CreditCardProcessor implements PaymentProcessor {
    @Override
    public PaymentResult process(Payment payment) {
        // Credit card specific processing
        return chargeCreditCard(payment);
    }
}
 
class PayPalProcessor implements PaymentProcessor {
    @Override
    public PaymentResult process(Payment payment) {
        // PayPal specific processing
        return authorizePayPal(payment);
    }
}
 
class CheckoutService {
    private final PaymentProcessor processor;  // Could be any implementation
    
    public CheckoutService(PaymentProcessor processor) {
        this.processor = processor;
    }
    
    public void checkout(Cart cart) {
        Payment payment = createPayment(cart);
        // Polymorphism: calls the right implementation automatically
        PaymentResult result = processor.process(payment);
    }
}
 
// With static methods - Strategy is IMPOSSIBLE
// Because you cannot pass a "class with a static method" as a parameter
// and have it called polymorphically
 
// You'd have to do something ugly like:
class BrokenCheckoutService {
    public void checkout(Cart cart, String processorType) {
        Payment payment = createPayment(cart);
        
        // Forced to use switch/if-else - defeats the pattern
        if ("creditcard".equals(processorType)) {
            CreditCardProcessor.process(payment);  // Static call
        } else if ("paypal".equals(processorType)) {
            PayPalProcessor.process(payment);      // Static call
        }
        // Very bad: violates Open-Closed Principle
        // Must modify this code to add new payment types
    }
}

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

// Interface defines the contract
interface Serializer {
    String serialize(Object obj);
    Object deserialize(String data);
}
 
// CORRECT: Instance methods implement the interface
class JsonSerializer implements Serializer {
    @Override
    public String serialize(Object obj) {
        // Instance method - satisfies interface contract
        return convertToJson(obj);
    }
    
    @Override
    public Object deserialize(String data) {
        return parseJson(data);
    }
}
 
// WRONG: You cannot satisfy interface with static methods
class BrokenSerializer implements Serializer {
    // This does NOT implement the interface!
    public static String serialize(Object obj) {  // static!
        return obj.toString();
    }
    
    // Compile error: BrokenSerializer is not abstract and does not
    // override abstract method serialize(Object) in Serializer
}
 
// Why this matters: Programming to interfaces
class DataProcessor {
    private final Serializer serializer;  // Interface type
    
    public DataProcessor(Serializer serializer) {
        this.serializer = serializer;  // Any implementation
    }
    
    public void process(Object data) {
        // Works with ANY serializer - JSON, XML, Protobuf...
        String serialized = serializer.serialize(data);
        store(serialized);
    }
}
 
// Usage - can swap implementations freely
DataProcessor jsonProcessor = new DataProcessor(new JsonSerializer());
DataProcessor xmlProcessor = new DataProcessor(new XmlSerializer());
 
// The serializer field stores an OBJECT - something you can invoke 
// instance methods on. You cannot store "a class with static methods"
// in a variable like this.

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

// Functional interface
@FunctionalInterface
interface StringTransformer {
    String transform(String input);
}
 
// Static methods can be referenced as functional interface implementations
class StringUtils {
    public static String toUpperCase(String s) {
        return s.toUpperCase();
    }
    
    public static String reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }
}
 
// Using static methods as functional interface implementations
StringTransformer upper = StringUtils::toUpperCase;  // Method reference
StringTransformer rev = StringUtils::reverse;
 
System.out.println(upper.transform("hello"));  // "HELLO"
System.out.println(rev.transform("hello"));    // "olleh"
 
// This works because:
// 1. StringTransformer has exactly one abstract method (functional interface)
// 2. StringUtils.toUpperCase has compatible signature (String) -> String
// 3. The compiler wraps the static method in an anonymous class implementing the interface
 
// It's equivalent to:
StringTransformer upperVerbose = new StringTransformer() {
    @Override
    public String transform(String input) {
        return StringUtils.toUpperCase(input);
    }
};

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

// STATIC version: All context must be passed explicitly
public class OrderValidatorStatic {
    public static ValidationResult validate(
            Order order,
            Customer customer,
            InventoryService inventory,
            PricingService pricing,
            TaxService taxes,
            ShippingService shipping,
            FraudDetector fraud,
            List<ValidationRule> rules) {
        
        // Every dependency is a parameter
        // Method signature becomes overwhelming
        
        for (ValidationRule rule : rules) {
            // Can't change rules based on validator configuration
            rule.apply(order, customer);
        }
        
        // Every operation needs explicit context
        if (!inventory.isAvailable(order.getItems())) {
            return ValidationResult.failed("Out of stock");
        }
        
        if (fraud.isSuspicious(customer, order)) {
            return ValidationResult.flagged("Fraud check");
        }
        
        // ... many more dependencies
    }
}
 
// INSTANCE version: Context is held in the object
public class OrderValidator {
    private final InventoryService inventory;
    private final PricingService pricing;
    private final TaxService taxes;
    private final ShippingService shipping;
    private final FraudDetector fraud;
    private final List<ValidationRule> rules;
    
    // All context injected once at construction
    public OrderValidator(
            InventoryService inventory,
            PricingService pricing,
            TaxService taxes,
            ShippingService shipping,
            FraudDetector fraud,
            List<ValidationRule> rules) {
        this.inventory = inventory;
        this.pricing = pricing;
        this.taxes = taxes;
        this.shipping = shipping;
        this.fraud = fraud;
        this.rules = rules;
    }
    
    // Clean method signature - only what varies per call
    public ValidationResult validate(Order order, Customer customer) {
        for (ValidationRule rule : rules) {
            rule.apply(order, customer);
        }
        
        if (!inventory.isAvailable(order.getItems())) {
            return ValidationResult.failed("Out of stock");
        }
        
        if (fraud.isSuspicious(customer, order)) {
            return ValidationResult.flagged("Fraud check");
        }
        
        // Context available from instance fields
    }
}
 
// Different validators with different configurations
OrderValidator strictValidator = new OrderValidator(
    inventory, pricing, taxes, shipping, 
    strictFraudDetector, 
    strictRules
);
 
OrderValidator lenientValidator = new OrderValidator(
    inventory, pricing, taxes, shipping,
    lenientFraudDetector,
    lenientRules
);

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

// Class under test uses static method
public class PaymentController {
    public Response processPayment(Request request) {
        // How do we test this without hitting the real payment gateway?
        PaymentResult result = PaymentGateway.process(request);  // Static!
        
        if (result.isSuccess()) {
            return Response.ok();
        } else {
            return Response.error(result.getMessage());
        }
    }
}
 
// TEST: Cannot mock with standard Mockito
@Test
public void testPaymentSuccess() {
    PaymentController controller = new PaymentController();
    Request request = new Request(100.00, "card-token");
    
    // This WON'T work - Mockito can't mock static methods
    // when(PaymentGateway.process(any())).thenReturn(successResult);
    
    // Test will hit the REAL payment gateway!
    Response response = controller.processPayment(request);
}
 
// WORKAROUND 1: PowerMock or Mockito-inline (bytecode manipulation)
// Works but slow, fragile, and considered a code smell
@Test
@PrepareForTest(PaymentGateway.class)  // PowerMock annotation
public void testWithPowerMock() {
    PowerMockito.mockStatic(PaymentGateway.class);
    PowerMockito.when(PaymentGateway.process(any()))
        .thenReturn(successResult);
    
    // Now it works, but your test is slower and more complex
}
 
// WORKAROUND 2: Wrapper interface (cleaner but requires refactoring)
public interface PaymentProcessor {
    PaymentResult process(Request request);
}
 
public class DefaultPaymentProcessor implements PaymentProcessor {
    @Override
    public PaymentResult process(Request request) {
        return PaymentGateway.process(request);  // Delegates to static
    }
}
 
public class TestablePaymentController {
    private final PaymentProcessor processor;  // Injected
    
    public TestablePaymentController(PaymentProcessor processor) {
        this.processor = processor;
    }
    
    public Response processPayment(Request request) {
        PaymentResult result = processor.process(request);  // Instance call
        return result.isSuccess() ? Response.ok() : Response.error(result.getMessage());
    }
}
 
// Now standard mocking works
@Test
public void testPaymentSuccess() {
    PaymentProcessor mockProcessor = mock(PaymentProcessor.class);
    when(mockProcessor.process(any())).thenReturn(successResult);
    
    TestablePaymentController controller = new TestablePaymentController(mockProcessor);
    Response response = controller.processPayment(request);
    
    assertEquals(Response.ok(), response);
}

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

public class Counter {
    private static int globalCount = 0;  // Mutable static!
    
    public static void increment() {
        globalCount++;
    }
    
    public static int getCount() {
        return globalCount;
    }
    
    public static void reset() {  // Must add this for testing
        globalCount = 0;
    }
}
 
// Without reset() between tests, order matters!
@Test
public void test1() {
    Counter.increment();
    assertEquals(1, Counter.getCount());  // Passes
}
 
@Test
public void test2() {
    Counter.increment();
    assertEquals(1, Counter.getCount());  // FAILS! Count is 2 if test1 ran first
}
 
// The fix: Reset state in @BeforeEach
@BeforeEach
public void setUp() {
    Counter.reset();  // Must remember to do this everywhere
}
 
// Problem: If ANY test anywhere forgets to reset, tests become flaky
// depending on execution order

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

// SPRING EXAMPLE: How DI works
 
// Dependencies are declared as instance fields
@Service
public class OrderService {
    private final OrderRepository orderRepository;     // Injected
    private final PaymentService paymentService;       // Injected
    private final NotificationService notifications;  // Injected
    
    // Constructor injection - Spring creates instances, wires dependencies
    public OrderService(
            OrderRepository orderRepository,
            PaymentService paymentService,
            NotificationService notifications) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.notifications = notifications;
    }
    
    // Instance method uses injected dependencies
    public Order createOrder(Customer customer, List<Product> products) {
        Order order = new Order(customer, products);
        orderRepository.save(order);
        paymentService.authorize(order);
        notifications.sendOrderConfirmation(order);
        return order;
    }
}
 
// PROBLEM: How would you do this with static methods?
public class StaticOrderService {
    // Cannot inject into static fields with standard DI!
    // private static OrderRepository orderRepository;  // Not injectable
    
    public static Order createOrder(Customer customer, List<Product> products) {
        // How does this method get the repository?
        
        // Option 1: Global static reference (Service Locator anti-pattern)
        OrderRepository repo = ServiceLocator.get(OrderRepository.class);
        
        // Option 2: New up dependencies (defeats DI purpose)
        OrderRepository repo = new JpaOrderRepository(entityManagerFactory);
        
        // Both options are problematic!
    }
}
 
// SERVICE LOCATOR is considered an anti-pattern because:
// 1. Hidden dependencies - not visible in class API
// 2. Tight coupling to the locator itself
// 3. Harder to test - must configure global locator
// 4. No compile-time checking of dependencies
 
// The whole point of DI is constructor injection with explicit dependencies

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

// VERSION 1: Simple static logger (seems fine at first)
public class Logger {
    public static void info(String message) {
        System.out.println("[INFO] " + message);
    }
    
    public static void error(String message) {
        System.out.println("[ERROR] " + message);
    }
}
 
// Usage throughout codebase
public class OrderService {
    public void createOrder(Order order) {
        Logger.info("Creating order: " + order.getId());
        // ...
        Logger.info("Order created");
    }
}
 
// VERSION 2: Need to add log levels - no problem, still static
public class Logger {
    private static LogLevel minimumLevel = LogLevel.INFO;
    
    public static void setLevel(LogLevel level) {
        minimumLevel = level;
    }
    
    public static void debug(String message) {
        if (minimumLevel.compareTo(LogLevel.DEBUG) <= 0) {
            System.out.println("[DEBUG] " + message);
        }
    }
    // ... but now we have mutable static state (minimumLevel)
}
 
// VERSION 3: Requirements change - different log levels per module
// PROBLEM: Static can't handle this! There's only ONE minimumLevel
 
// Desired behavior:
// - OrderService logs at DEBUG level (verbose for troubleshooting)
// - PaymentService logs at ERROR only (too noisy otherwise)
// - Each service needs its own logger configuration
 
// Static approach - UGLY AND ERROR-PRONE
public class Logger {
    private static Map<String, LogLevel> levelsBySource = new HashMap<>();
    
    public static void info(String source, String message) {
        LogLevel level = levelsBySource.getOrDefault(source, LogLevel.INFO);
        if (level.compareTo(LogLevel.INFO) <= 0) {
            System.out.println("[" + source + "] [INFO] " + message);
        }
    }
    
    // Now EVERY log call needs a source string - invasive change to all callers!
}
 
// VERSION 4: Need to support multiple outputs
// - Some logs go to file
// - Some logs go to monitoring service
// - Some logs go to console
 
// Static approach is now completely unwieldy...
 
// PROPER SOLUTION: Instance-based from the start
public interface Logger {
    void debug(String message);
    void info(String message);
    void error(String message);
}
 
public class ConfigurableLogger implements Logger {
    private final String name;
    private final LogLevel minimumLevel;
    private final List<LogOutput> outputs;
    
    // Each service gets its own configured logger instance
    public ConfigurableLogger(String name, LogLevel level, List<LogOutput> outputs) {
        this.name = name;
        this.minimumLevel = level;
        this.outputs = outputs;
    }
    
    @Override
    public void info(String message) {
        if (minimumLevel.compareTo(LogLevel.INFO) <= 0) {
            outputs.forEach(out -> out.write(name, "INFO", message));
        }
    }
}
 
// Usage - injected per service with proper configuration
public class OrderService {
    private final Logger logger;  // Injected with OrderService-specific config
    
    public OrderService(Logger logger) {
        this.logger = logger;
    }
    
    public void createOrder(Order order) {
        logger.info("Creating order: " + order.getId());
        // Uses THIS service's logger configuration
    }
}