How to Inflate Your Java Codebase Without Sacrificing Quality

Introduction

If one day salaries were calculated by code lines, how could we write beautiful code that also increases line count without losing meaning? The article humorously explores ways to add code volume while maintaining quality, acknowledging that a skilled developer can pull it off.

Main Content

Implement More Interfaces

Give each method unnecessary interfaces such as Serializable, Cloneable, Comparable, AutoCloseable, etc., to increase code lines without affecting functionality.

public class ExampleClass implements Serializable, Comparable<ExampleClass>, Cloneable, AutoCloseable {
    @Override
    public int compareTo(ExampleClass other) {
        // comparison logic
        return 0;
    }

    // Serializable implementation
    private void writeObject(ObjectOutputStream out) throws IOException {
        // serialization logic
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // deserialization logic
    }

    // Cloneable implementation
    @Override
    public ExampleClass clone() throws CloneNotSupportedException {
        // copy logic
        return (ExampleClass) super.clone();
    }

    // AutoCloseable implementation
    @Override
    public void close() throws Exception {
        // resource cleanup
    }
}

Override equals and hashCode

Overriding equals and hashCode adds code and ensures objects behave correctly in collections.

public class ExampleClass {
    private String name;
    private int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        ExampleClass other = (ExampleClass) obj;
        return this.age == other.age && Objects.equals(this.name, other.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Add Configuration Items and Parameters

Introduce additional fields and getters/setters even if they are not used, to boost line count and perceived robustness.

public class AppConfig {
    private int maxConnections;
    private String serverUrl;
    private boolean enableFeatureX;

    // extra configuration
    private String emailTemplate;
    private int maxRetries;
    private boolean enableFeatureY;

    // constructors, getters, setters omitted for brevity
}

Add Event Listeners

Define simple event classes, listener interfaces, and a source that notifies listeners before, during, and after business execution.

public class Event {
    private String name;
    public Event(String name) { this.name = name; }
    public String getName() { return name; }
}

public interface EventListener {
    void onEventStart(Event event);
    void onEventInProgress(Event event);
    void onEventEnd(Event event);
}

public class EventSource {
    private List<EventListener> listeners = new ArrayList<>();
    public void addEventListener(EventListener listener) { listeners.add(listener); }
    public void removeEventListener(EventListener listener) { listeners.remove(listener); }
    public void businessMethod() {
        Event event = new Event("BusinessEvent");
        for (EventListener l : listeners) l.onEventStart(event);
        System.out.println("Executing business method...");
        for (EventListener l : listeners) l.onEventInProgress(event);
        System.out.println("Continuing business method...");
        for (EventListener l : listeners) l.onEventEnd(event);
    }
}

public class BusinessEventListener implements EventListener {
    @Override public void onEventStart(Event e) { System.out.println("Event Start: " + e.getName()); }
    @Override public void onEventInProgress(Event e) { System.out.println("Event In Progress: " + e.getName()); }
    @Override public void onEventEnd(Event e) { System.out.println("Event End: " + e.getName()); }
}

public class Main {
    public static void main(String[] args) {
        EventSource source = new EventSource();
        source.addEventListener(new BusinessEventListener());
        source.businessMethod();
        source.removeEventListener(new BusinessEventListener());
    }
}

Build General Utility Classes

Create a custom StringUtils with extra methods such as reverse and isInteger.

public class StringUtils {
    public static boolean isEmpty(String str) { return str == null || str.trim().isEmpty(); }
    public static boolean isBlank(String str) { return str == null || str.trim().isEmpty(); }
    public static String reverse(String str) {
        if (str == null) return null;
        return new StringBuilder(str).reverse().toString();
    }
    public static boolean isInteger(String str) {
        try { Integer.parseInt(str); return true; }
        catch (NumberFormatException e) { return false; }
    }
}

Add New Exception Types

Define a base CustomException and several specific subclasses to increase code volume.

public class CustomException extends RuntimeException {
    public CustomException(String message) { super(message); }
    public static class NotFoundException extends CustomException {
        public NotFoundException(String message) { super(message); }
    }
    public static class ValidationException extends CustomException {
        public ValidationException(String message) { super(message); }
    }
}

public class ExceptionHandling {
    public void process(int value) {
        try {
            if (value < 0) throw new IllegalArgumentException("Value cannot be negative");
            else if (value == 0) throw new ArithmeticException("Value cannot be zero");
            // normal logic
        } catch (IllegalArgumentException e) {
            // handle
        } catch (ArithmeticException e) {
            // handle
        }
    }
}

Implement More Design Patterns

Show classic patterns such as Singleton, Strategy, and a simple calculator using them.

// Singleton
public class SingletonPattern {
    private static SingletonPattern instance;
    private SingletonPattern() {}
    public static SingletonPattern getInstance() {
        if (instance == null) instance = new SingletonPattern();
        return instance;
    }
}

// Strategy
interface Strategy { void doOperation(int num1, int num2); }
class AdditionStrategy implements Strategy { @Override public void doOperation(int a, int b) { System.out.println("Addition result: " + (a+b)); } }
class SubtractionStrategy implements Strategy { @Override public void doOperation(int a, int b) { System.out.println("Subtraction result: " + (a-b)); } }
class Context { private Strategy strategy; public Context(Strategy s) { this.strategy = s; } public void executeStrategy(int a, int b) { strategy.doOperation(a, b); } }
public class StrategyPattern {
    public static void main(String[] args) {
        int num1 = 10, num2 = 5;
        Context ctx = new Context(new AdditionStrategy());
        ctx.executeStrategy(num1, num2);
        ctx = new Context(new SubtractionStrategy());
        ctx.executeStrategy(num1, num2);
    }
}

// Calculator with if‑else (contrast)
public class Calculator {
    public static void main(String[] args) {
        int num1 = 10, num2 = 5;
        String operation = "addition";
        if (operation.equals("addition")) System.out.println("Addition result: " + (num1+num2));
        else if (operation.equals("subtraction")) System.out.println("Subtraction result: " + (num1-num2));
        else if (operation.equals("multiplication")) System.out.println("Multiplication result: " + (num1*num2));
        else if (operation.equals("division")) System.out.println("Division result: " + (num1/num2));
        else System.out.println("Invalid operation");
    }
}

Expand Comments and Documentation

Add extensive Javadoc comments to a simple class to further increase line count.

/**
 * Example class demonstrating how to increase code size with comments.
 * Contains a field, constructor, getter and setter.
 */
public class ExampleClass {
    // example field
    private int value;
    /** Constructor */
    public ExampleClass(int value) { this.value = value; }
    /** Get the value */
    public int getValue() { return value; }
    /** Set the value */
    public void setValue(int newValue) { this.value = newValue; }
}

Conclusion

Even if salaries were measured by code lines, developers must still write high‑quality, maintainable code; inflating line count without purpose harms readability and ultimately the organization.