Stepping into Refactoring Code in Java

Stepping into Refactoring Code

Welcome to our captivating session on refactoring, a powerful tool for tidying up code, much like you would organize a messy toy box or find a faster route to school. As each line of code is as essential as a brick in a building, clumsy code may result in an unstable structure. Today, we'll focus on enhancing the readability, maintainability, and performance of our code through refactoring.

Recapping Crucial Concepts

Let's briefly revisit a few key concepts: Code Smells : Indicators that our code needs refactoring, akin to clutter calling for cleanup. Refactoring Techniques : We've familiarized ourselves with Extract Method, Rename Method, and Substitute Algorithm techniques in earlier lessons. OOP in Refactoring : We've learned how to leverage Object-Oriented Programming principles to enhance our code's structure. Code Decoupling and Modularization : Methods to make code easier to manage by minimizing dependencies. We'll use these concepts as guiding stars as we traverse the cosmos of refactoring.

Practice Problem 1: Taming a Complex Function

We'll start by rewriting a complex game score computation function. Let's look at it: Java public class Game {public static int computeScore(Player player, List<Integer> monsters) {int score = 0; for (int monster : monsters) {if (player.getPower() > monster) {score += player.getPower() - monster;} else {score -= player.getPower() - monster;}} return score;}} This code uses some algorithm to adjust the score based on the player's and monster's power. The parts player.getPower() > monster and player.getPower() - monster recur in this function, indicating room for refactoring. We'll apply the Extract Method and Rename Method to untangle this: We'll extract the scoring logic into a separate function, scoreChange . We'll rename the original function to computeGameScore . With these adjustments, our improved code might look something like this: Java // New function to calculate score changes. public class Game {private static int scoreChange(int power, int monster) {if (power > monster) {return power - monster;} else {return monster - power;}} // Refactored function to calculate the game score. public static int computeGameScore(Player player, List<Integer> monsters) {int score = 0; for (int monster : monsters) {score += scoreChange(player.getPower(), monster);} return score;}} This refactoring has simplified the function and made it easier to modify in the future.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Practice Problem 2: Refactoring with OOP and Code Decoupling

Let's consider another example where the game has multiple types of monsters. Each monster type behaves differently when encountered by a player.

Java

public class Game {
    public static void monsterReaction(String monsterType, Player player) {
        if (monsterType.equals("ghost")) {
            if (player.getPower() > 5) {
                System.out.println("The ghost flees in terror!");
            } else {
                System.out.println("The ghost grumbles and attacks!");
            }
        } else if (monsterType.equals("goblin")) {
            if (player.getPower() > 3) {
                System.out.println("The goblin groans and retreats!");
            } else {
                System.out.println("The goblin hacks with its sword!");
            }
        }
        // more monster types...
    }
}

public class Game {
    public static void monsterReaction(String monsterType, Player player) {
        if (monsterType.equals("ghost")) {
            if (player.getPower() > 5) {
                System.out.println("The ghost flees in terror!");
            } else {
                System.out.println("The ghost grumbles and attacks!");
            }
        } else if (monsterType.equals("goblin")) {
            if (player.getPower() > 3) {
                System.out.println("The goblin groans and retreats!");
            } else {
                System.out.println("The goblin hacks with its sword!");
            }
        }
        // more monster types...
    }
}

This scenario could also benefit from refactoring using OOP and Code Decoupling:

First, we'll introduce a class Monster with a method reaction that could be overridden by each type of monster.
Then, we'll create child classes Ghost and Goblin that inherit from Monster and implement their own reaction methods.

Under the revised structure, our game code would look like this:

Java

public abstract class Monster {
    public abstract void reaction(Player player);
}

public class Ghost extends Monster {
    @Override
    public void reaction(Player player) {
        if (player.getPower() > 5) {
            System.out.println("The ghost flees in terror!");
        } else {
            System.out.println("The ghost grumbles and attacks!");
        }
    }
}

public class Goblin extends Monster {
    @Override
    public void reaction(Player player) {
        if (player.getPower() > 3) {
            System.out.println("The goblin groans and retreats!");
        } else {
            System.out.println("The goblin hacks with its sword!");
        }
    }
}

// Game class where List of Monsters is managed
public class Game {
    public static void main(String[] args) {
        Player player = new Player(4); // This is just an example instantiation.
        List<Monster> monsters = Arrays.asList(new Ghost(), new Goblin(), new Ghost(), new Goblin());
        for (Monster monster : monsters) {
            monster.reaction(player);
        }
    }
}

public abstract class Monster {
    public abstract void reaction(Player player);
}

public class Ghost extends Monster {
    @Override
    public void reaction(Player player) {
        if (player.getPower() > 5) {
            System.out.println("The ghost flees in terror!");
        } else {
            System.out.println("The ghost grumbles and attacks!");
        }
    }
}

public class Goblin extends Monster {
    @Override
    public void reaction(Player player) {
        if (player.getPower() > 3) {
            System.out.println("The goblin groans and retreats!");
        } else {
            System.out.println("The goblin hacks with its sword!");
        }
    }
}

// Game class where List of Monsters is managed
public class Game {
    public static void main(String[] args) {
        Player player = new Player(4); // This is just an example instantiation.
        List<Monster> monsters = Arrays.asList(new Ghost(), new Goblin(), new Ghost(), new Goblin());
        for (Monster monster : monsters) {
            monster.reaction(player);
        }
    }
}

Now, our code dealing with multiple monsters is easier to manage and can be extended to accommodate more types of monsters.

Stepping into Refactoring Code in Java