Revamping Your Code: Masterful Techniques for Effective Code Refactoring

Introduction

In the dynamic world of software development, change is the only constant. As projects evolve and requirements shift, it’s easy for codebases to become tangled, complex, and hard to maintain. That’s where the art of code refactoring comes into play.

Code refactoring is like giving your code a makeover — it’s about making it cleaner, simpler, more efficient, and easier to understand, all without altering its functionality. It’s not just a helpful skill. It’s a mindset that distinguishes exceptional developers.

In this blog, I’ll take you on a journey into the world of code refactoring. Whether you’re a seasoned developer looking to optimise your code or a novice eager to learn, this exploration of code refactoring will equip you with the knowledge and techniques to transform your code into a work of art. So, let’s embark on this exciting journey and discover the power of code refactoring.

Clean code

"In the world of software development, refactoring stands as a crucial practice, and at its core lies the pursuit of clean code."

But what exactly is 'clean code'? Let's dive into some of its defining characteristics:

• Clean code is easy to understand, with clear and descriptive variable and method names, consistent formatting, and a well-organized structure.
• Clean code is efficient and optimized, avoiding redundancy and resource waste.
• Clean code minimizes dependencies, reduces the risk of errors, and simplifies maintenance.
• Clean code typically has comprehensive test coverage to ensure its reliability and correctness.
• Clean code is designed with scalability in mind, allowing for growth and expansion without major overhauls.

In essence, clean code simplifies the development process, enhances collaboration among programmers, reduces the risk of errors, and ultimately saves time and resources during maintenance.

Code Smells

— What? How can code "smell"??

— When your code is so bad, even a nose can tell!

Code smells serve as warning signs of potential issues that can be resolved through refactoring. While code smells are readily identifiable and correctable, they might also signal underlying, more significant problems within the code.

1. Code Swellings: These are methods or classes that grow excessively over time, making them difficult to manage. Examples include long methods (typically more than 10 lines), large classes (with many variables and methods), and lengthy parameter lists (over four parameters).

2. Object-Oriented Misuse: These issues arise from improper application of object-oriented principles, such as complex and nested sequences of `if` statements or different classes performing the same functions with different method names.

3. Change Hindrances: These smells indicate that a change in one part of the code necessitates multiple modifications in other areas, complicating and increasing development costs. For instance, adding a new room type in hotel management system may require altering unrelated methods for finding, displaying, and booking rooms.

4. Unnecessary code: These are unnecessary code elements, like duplicate or dead code, whose removal improves code cleanliness and effectiveness.

5. Couplers: All the smells in this category either encourage excessive coupling between classes or demonstrate what happens when excessive delegation takes the place of coupling. Example: If a class only performs one action, assigning work to another class, why does it even exist at a first place? Additionally, when a method accesses another object's data more often than its own, it signifies excessive coupling.

Refactoring Techniques

Having examined code smells, let's now explore the world of refactoring techniques. Refactoring techniques are like the craftsman's toolkit for developers, enabling them to reshape and refine code.

1. Simplifying method calls

Extract Method: If a section of code within a method performs a specific task or calculation, you can extract it into a separate method with a meaningful name. This simplifies the main method by abstracting away the details of that specific task.

Before Refactoring:

public double calculateAverage(int a, int b, int c) {
    int sum = a + b + c;
    double result = sum / 3.0;
    return result;
public double calculateAverage(int a, int b, int c) {
    int sum = a + b + c;
    double result = sum / 3.0;
    return result;
}

After Refactoring:

public double calculateAverage(int a, int b, int c) {
    return sum(a, b, c) / 3.0;
}

public int sum(int a, int b, int c) {
    return a + b + c;
}public double calculateAverage(int a, int b, int c) {
    return sum(a, b, c) / 3.0;
}

public int sum(int a, int b, int c) {
    return a + b + c;
}

Inline Method: Conversely, if a method call doesn't add much clarity and is only used once, you can choose to inline it directly into the calling code. This is done to eliminate the need for an extra method.

Before Refactoring:

public int add(int a, int b) {
    return calculateSum(a, b);
}

private int calculateSum(int a, int b) {
    return a + b;
}

After Refactoring:

public int add(int a, int b) {
    return a + b;
}

2. Simplifying conditional expressions

This involves combining several conditionals that lead to the same result into a single expression and eliminating duplicate and overlapping code snippets by moving them outside of the conditions. This also involves replacing conditional logic with polymorphic behavior.

Before Refactoring:

class Employee {   
    double getPaymentAmount() {  
        if (isManager) {  
            return salary + bonus; 
        } else {    
            return salary;    
        }    
    }
} class Employee {   
    double getPaymentAmount() {  
        if (isManager) {  
            return salary + bonus; 
        } else {    
            return salary;    
        }    
    }
}     

After Refactoring:

interface Payment {
    double getPaymentAmount();
} 

class ManagerPayment implements Payment {
    double getPaymentAmount() {   
        return salary + bonus;
    }  
}    

class EmployeePayment implements Payment {
    double getPaymentAmount()   
        return salary;
    }   
}

3. Extract Method Object 

This technique is used to improve code organization, readability, and maintainability by grouping related functionality together and adhering to the Single Responsibility Principle. 

Before Refactoring:

@AllArgsConstructor
public class Order {
    private List<LineItem> lineItems;

    public double calculateTotalPrice() {
        double total = 0;
        for (LineItem item : lineItems) {
            total += item.getPrice(); 
        }
        return total; 
    }
}
    
@Getter
@AllArgsConstructor
public class LineItem {  
	private String name;   
    private double price;  
}
    
public class Main {
    public static void main(String[] args) {
    	LineItem item1 = new LineItem("Item 1", 10);
    	LineItem item2 = new LineItem("Item 2", 20)
        List<LineItem> items = Arrays.asList(item1, item2);
        Order order = new Order("John Doe", items);
        order.calculateTotalPrice();   
    }
}@AllArgsConstructor
public class Order {
    private List<LineItem> lineItems;

    public double calculateTotalPrice() {
        double total = 0;
        for (LineItem item : lineItems) {
            total += item.getPrice(); 
        }
        return total; 
    }
}
    
@Getter
@AllArgsConstructor
public class LineItem {  
	private String name;   
    private double price;  
}
    
public class Main {
    public static void main(String[] args) {
    	LineItem item1 = new LineItem("Item 1", 10);
    	LineItem item2 = new LineItem("Item 2", 20)
        List<LineItem> items = Arrays.asList(item1, item2);
        Order order = new Order("John Doe", items);
        order.calculateTotalPrice();   
    }
}

After Refactoring:

@Getter
@AllArgsConstructor
public class Order {
    private List<LineItem> lineItems;

    public double calculateTotalPrice() {
        return new OrderCalculator(lineItems).calculateTotalPrice();
    }
}

@AllArgsConstructor
public class OrderCalculator {
    private Order order;

    public double calculateTotalPrice() {
        double total = 0;
        for (LineItem item : order.getLineItems()) {
            total += item.getPrice();
        }
        return total;
    }
}
    
@Getter
@AllArgsConstructor
public class LineItem {  
	private String name;   
    private double price;  
}
    
public class Main {
    public static void main(String[] args) {
    	LineItem item1 = new LineItem("Item 1", 10);
    	LineItem item2 = new LineItem("Item 2", 20)
        List<LineItem> items = Arrays.asList(item1, item2);
        Order order = new Order("John Doe", items);
        order.calculateTotalPrice();   
    }
}@Getter
@AllArgsConstructor
public class Order {
    private List<LineItem> lineItems;

    public double calculateTotalPrice() {
        return new OrderCalculator(lineItems).calculateTotalPrice();
    }
}

@AllArgsConstructor
public class OrderCalculator {
    private Order order;

    public double calculateTotalPrice() {
        double total = 0;
        for (LineItem item : order.getLineItems()) {
            total += item.getPrice();
        }
        return total;
    }
}
    
@Getter
@AllArgsConstructor
public class LineItem {  
	private String name;   
    private double price;  
}
    
public class Main {
    public static void main(String[] args) {
    	LineItem item1 = new LineItem("Item 1", 10);
    	LineItem item2 = new LineItem("Item 2", 20)
        List<LineItem> items = Arrays.asList(item1, item2);
        Order order = new Order("John Doe", items);
        order.calculateTotalPrice();   
    }
}

In this refactoring, the `OrderCalculator` class is introduced to encapsulate the logic for calculating the total price of an order. This separation of concerns enhances code organization and adheres to the principle of single responsibility, making the code more maintainable and extensible. The `Order` class delegated the total price calculation to the `OrderCalculator`.

4. Organizing Data

This involves restructuring and optimizing the way data is stored, accessed, and managed within a codebase.

Before Refactoring:

class Order {
   private String customerName;
   private String customerAddress;
   private String customerCity;
   private String customerState;
   private String customerZip;

   public Order(String customerName, String customerAddress, String customerCity, String customerState, String customerZip) {
       this.customerName = customerName;
       this.customerAddress = customerAddress;
       this.customerCity = customerCity;
       this.customerState = customerState;
       this.customerZip = customerZip;
   }

   // Other methods related to the Order...
}

After Refactoring:

class Customer {
    private String name;
    private Address address;

    public Customer(String name, String street, String city, String state, String zip) {
        this.name = name;
        this.address = new Address(street, city, state, zip);
    }

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }
}

class Address {
    private String street;
    private String city;
    private String state;
    private String zip;

    public Address(String street, String city, String state, String zip) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zip = zip;
    }

    public String getStreet() {
        return street;
    }

    public String getCity() {
        return city;
    }

    public String getState() {
        return state;
    }

    public String getZip() {
        return zip;
    }
}

class Order {
    private Customer customer;

    public Order(Customer customer) {
        this.customer = customer;
    }

    public Customer getCustomer() {
        return customer;
    }

    // Other methods related to the Order...
}

In this refactoring example, the code is improved by replacing the separate data fields for customer information in the Order class with a more organized and encapsulated Customer class and an Address class. This not only enhances code readability but also adheres to the principles of encapsulation and data organization. It makes it easier to manage customer data and reduces code duplication if customer information needs to be accessed or modified in multiple places.

5. Dealing with Generalization

This refactoring technique involves optimizing the inheritance hierarchy in object-oriented code. It includes actions such as “Pull Up Method,” “Push Down Method,” and “Extract Interface/Abstract Class.”

Pull-Up Method or Field: This involves moving a method or field up the inheritance hierarchy from subclasses to a common superclass to promote code reusability.

Push Down Method/Field: This is the opposite of “Pull Up.” It involves moving a method or field down from a superclass to one or more of its subclasses when the method or field is specific to certain subclasses.

Extract Interface/Abstract Class: This technique involves creating an interface or abstract class to define a common set of methods and fields that multiple classes can implement or extend, respectively.

Before Refactoring:

interface Payable {
    double calculateSalary();
}

@AllArgsConstructor
class Employee implements Payable {
    protected String name;
    protected double salary;
    protected String department;

    pubic double calculateSalary() {
        return salary;
    }
}

class Manager extends Employee {

    public Manager(String name, double salary, String department) {
        super(name, salary, department);
    }

    @Override
    public double calculateSalary() {
        return super.calculateSalary() * 1.2; // Example: 20% bonus for managers
    }
}@AllArgsConstructor
class Employee {
    protected String name;
    protected double salary;
    protected String department;

    double calculateSalary() {
        return salary;
    }
}

class Manager extends Employee {

    public Manager(String name, double salary, String department) {
        super(name, salary, department);
    }

    // Specific salary calculation for Manager
    double calculateManagerSalary() {
        return salary * 1.2; // Example: 20% bonus for managers
    }
}

After Refactoring:

interface Payable {
    double calculateSalary();
}

@AllArgsConstructor
class Employee implements Payable {
    protected String name;
    protected double salary;
    protected String department;

    pubic double calculateSalary() {
        return salary;
    }
}

class Manager extends Employee {

    public Manager(String name, double salary, String department) {
        super(name, salary, department);
    }

    @Override
    public double calculateSalary() {
        return super.calculateSalary() * 1.2; // Example: 20% bonus for managers
    }
}interface Payable {
    double calculateSalary();
}

@AllArgsConstructor
class Employee implements Payable {
    protected String name;
    protected double salary;
    protected String department;

    pubic double calculateSalary() {
        return salary;
    }
}

class Manager extends Employee {

    public Manager(String name, double salary, String department) {
        super(name, salary, department);
    }

    @Override
    public double calculateSalary() {
        return super.calculateSalary() * 1.2; // Example: 20% bonus for managers
    }
}

Conclusion

By implementing the above code refactoring techniques, you'll elevate your code quality, reduce technical debt, and become a more proficient software engineer. By making code refactoring a continuous process, you can ensure long-term project success and increased team satisfaction. So, embark on this journey of code improvement, and watch your codebase evolve into a masterpiece of clean, maintainable software. Happy coding!

"Thank you for reading this blog post. I hope you found it insightful and informative. If you have any questions, or feedback, or would like to discuss the topic further, please don’t hesitate to reach out. Connect with me on LinkedIn. If you’re interested in mentorship or guidance related to your career in general, do reach out to me at this on a free 1:1 call here.