How Can I Avoid Code Duplication Resulting from Using Primitive Types in Programming?

What are strategies to avoid code duplication due to the use of primitive types in programming?

// Example in Java
int value1 = 10;
int value2 = 20;
int sum = value1 + value2;  // Direct usage of primitive types without abstraction

Code duplication often arises from using primitive types directly in programming. When multiple pieces of code handle primitive types repetitively, it leads to maintenance challenges and errors. To address this, developers can utilize encapsulation and object-oriented principles, creating custom types that reduce direct manipulation of primitives.

// Example of a wrapper class in Java
public class Money {
    private final int amount;
    public Money(int amount) {
        this.amount = amount;
    }
    public Money add(Money other) {
        return new Money(this.amount + other.amount);
    }
} // Usage: Money m1 = new Money(10); Money m2 = new Money(20); Money total = m1.add(m2);

Causes

• Direct use of primitive types in multiple places
• Lack of abstraction for complex data types
• Inconsistent handling of similar data across the codebase

Solutions

• Create wrapper classes for primitive types that encapsulate behavior and data.
• Implement data transfer objects (DTOs) to handle grouped data instead of individual primitives.
• Utilize collections and generics to manage similar data points more abstractly.

Mistake: Not using custom types and continuing to manipulate primitives directly.

Solution: Wrap primitives in classes to enforce better practices and reduce code repetition.

Mistake: Ignoring encapsulation, leading to widespread changes during updates.

Solution: Encapsulate logic related to primitive data types to reduce the number of locations that must be modified.