Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Method Length and Extract 'Til You Drop

DZone's Guide to

Method Length and Extract 'Til You Drop

If your methods are longer than five lines of code, it's a sign that you should start to extract. And once you start, extract till you drop!

· Java Zone ·
Free Resource

Verify, standardize, and correct the Big 4 + more– name, email, phone and global addresses – try our Data Quality APIs now at Melissa Developer Portal!

As a typical nerd (and a DZone Zone Leader), I tend to read a lot of blog posts and comments about programming. One thing that keeps amazing me is how long people’s functions tend to be and how many people are convinced this is the right way to code. In reality, a readable function should rarely exceed five lines of code.

Take a short look at this function:

public void show() {
    Week week = visitCalendar.getCurrentWeek();
    System.out.println(week.getStart() + " - " + week.getEnd());

    for (DayOfWeek day : VisitCalendar.OPEN_DAYS) {
        System.out.println(day + ":");
        List<Visit> visitsOnDay = visitCalendar.visitsOn(day);
        if (visitsOnDay.isEmpty()) {
            System.out.println("No visits!");
        } else {
            for (Visit visit : visitsOnDay) {
                System.out.println(visit.getTime() + ": " + visit.getOwnerName());
                System.out.println("Pets: " + visit.getPetNames());
            }
        }
    }

    try (Scanner scanner = new Scanner(System.in)) {
        String command;
        do {
            command = scanner.nextLine();
        } while (!controller.execute(command));
    }
}


How readable is that piece of code? Are you able to tell what it does just by taking a quick look at it? Two little extractions should make things clearer:

public void show() {
    Week week = visitCalendar.getCurrentWeek();
    System.out.println(week.getStart() + " - " + week.getEnd());

    for (DayOfWeek day : VisitCalendar.OPEN_DAYS) {
        System.out.println(day + ":");
        show(visitCalendar.visitsOn(day));
    }

    askForCommand();
}

private void show(List<Visit> visitsOnDay) {
    if (visitsOnDay.isEmpty()) {
        System.out.println("No visits!");
    } else {
        for (Visit visit : visitsOnDay) {
            System.out.println(visit.getTime() + ": " + visit.getOwnerName());
            System.out.println("Pets: " + visit.getPetNames());
        }
    }
}

private void askForCommand() {
    try (Scanner scanner = new Scanner(System.in)) {
        String command;
        do {
            command = scanner.nextLine();
        } while (!controller.execute(command));
    }
}


Much better. Now, the three functions are fairly readable and it should be easier to reason about what’s happening in there. But that’s still not good enough. Our show() method has mixed levels of abstraction and there’s still a loop inside an if statement. To deal with the first problem, we can simply extract two methods:

public void show() {
    show(visitCalendar.getCurrentWeek());

    for (DayOfWeek day : VisitCalendar.OPEN_DAYS) {
        show(day);
        show(visitCalendar.visitsOn(day));
    }

    askForCommand();
}

private void show(Week week) {
    System.out.println(week.getStart() + " - " + week.getEnd());
}

private void show(DayOfWeek day) {
    System.out.println(day + ":");
}


Now, how readable is that? It’s trivial, but that’s a good thing. We want our code to be trivial. Now to the second problem. Guess what we’ll do. That’s right, extract again!

private void show(List<Visit> visitsOnDay) {
    if (visitsOnDay.isEmpty()) {
        showNoVisits();
    } else {
        visitsOnDay.forEach(this::show);
    }
}

private void showNoVisits() {
    System.out.println("No visits!");
}

private void show(Visit visit) {
    System.out.println(visit.getTime() + ": " + visit.getOwnerName());
    System.out.println("Pets: " + visit.getPetNames());
}


Do you see how much clearer the code becomes? That’s exactly the point. When you extract, things become more digestible and it’s easier to preserve proper levels of abstraction. The fun part of it? You can extract all the time! Extract till you drop!

And in the meantime, your functions will become smaller and smaller. Usually less than six lines of code long. This is approximately the size at which code becomes pleasantly trivial. Therefore, beware of functions longer than that and continuously seek possibilities to extract further. The readers of your code will thank you.

Developers! Quickly and easily gain access to the tools and information you need! Explore, test and combine our data quality APIs at Melissa Developer Portal – home to tools that save time and boost revenue. Our APIs verify, standardize, and correct the Big 4 + more – name, email, phone and global addresses – to ensure accurate delivery, prevent blacklisting and identify risks in real-time.

Topics:
clean code ,method length ,java ,extract ,tutorial

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}