在软件开发的过程中，我们为了实现某个功能，往往都要去编译无数的函数，然后把函数组合起来完成功能，但有时候，为了图方便，在一个函数中，写了很长的业务逻辑，导致一个函数的长度超过了我们的显示器，这个时候，就要学会去分析和重构它。

一、什么是过长函数

定义

一个函数包含了过多的逻辑或者过分体现了逻辑功能的实现细节，导致函数产生过长的代码块，简单来说，过长函数就是很长的函数。（听君一席话，如听一席话）

影响

• 功能不单一：一般一个函数，最好做到功能单一，也就是一个函数只做一件事，功能单一的函数往往长度都不会太长，如果一个函数长度太长，很有可能这个函数功能不单一；
• 可读性差：函数过长，往往都会造成可读性差，如果一个函数超过了显示屏的显示范围，一般这个函数读起来往往会令人头疼；
• 难以维护： 在一段很长的函数中去该某段代码，维护成本非常的高；

重构过长函数的目的

增强代码的可读性，提高维护性，使函数功能单一。

重构手段

过长的函数，一般都是采用提炼函数的方法，并用函数做什么来进行重新命名；重构过长函数的难点在于，对一个函数的功能进行分析和拆分。

二、案例

2.1 案例一

2.1.1 代码功能

下面是一个打印发票的的函数，发票内容主要包括：

• 发票头，包含买方和卖方信息。
• 商品详细列表，包含商品的编号、名称、数目和价格
• 发票汇总，包含所有商品的总价。

public class Invoice {
    private final String buyer;

    private final String seller;

    private final List<InvoiceLine> lines;

    public Invoice(String buyer, String seller, List<InvoiceLine> lines) {
        this.buyer = buyer;
        this.seller = seller;
        this.lines = new ArrayList<>(lines);
    }

    public String getBuyer() {
        return buyer;
    }

    public String getSeller() {
        return seller;
    }

    public List<InvoiceLine> getLines() {
        return Collections.unmodifiableList(lines);
    }

}

public class InvoiceLine {
    private final String product;
    private final float quantity;
    private final float price;

    public InvoiceLine(String product, int quantity, int price) {
        this.product = product;
        this.quantity = quantity;
        this.price = price;
    }

    public String getProduct() {
        return product;
    }

    public float getQuantity() {
        return quantity;
    }

    public float getPrice() {
        return price;
    }
}


public class InvoicePrinter {
    public static void print(Invoice invoice, PrintStream printStream) {
        printStream.println("====== INVOICE ======");
        printStream.println("Buyer: " + invoice.getBuyer());
        printStream.println("Seller: " + invoice.getSeller());

        printStream.println("------ Detail ------");
        printStream.println("ln\tProduct\tPrice\tQt\tAmount");
        float total = 0;
        for (int lineId = 0; lineId < invoice.getLines().size(); ++lineId) {
            final InvoiceLine line = invoice.getLines().get(lineId);
            String product = line.getProduct();
            float price = line.getPrice();
            float quantity = line.getQuantity();
            float amount = price * quantity;
            if (product == null || "".equals(product.trim())
                    || price <= 0 || quantity <= 0) {
                printStream.println(lineId + "\tInvalid");
            } else {
                printStream.println(lineId + "\t" + product + "\t" + price
                        + "\t" + quantity + "\t" + amount);
            }
            total += amount;
        }
        printStream.println("------ Total ------");
        printStream.println(total);
    }
}

运行效果如下：

2.1.2 问题分析

1. 代码过长，所有逻辑都在一个print方法中，这个方法过分体现细节。
2. for循环功能复杂，它既要获取数据，然后打印，同时还要计算商品总价
3. if语句判断商品是否有效，表达式比较复杂。
4. for循环中关于商品的临时变量太多。
5. 类功能不够内聚，这个类的方法是print，应该专注于打印，计算总价不应该是打印机的职责。

功能模块分析

1、for循环打印和计算抽离

2、发票分为打印头，打印细节、打印价格，可以考虑根据三处不同的打印，拆分为三个函数，重构时选中对应的代码段，使用Ctrl+Shift+M,快捷重构

3、接下来依次重构子方法，printHeader已经很简单了，没有重构的必要，主要重构printDetail方法，这个方法比较长，很多一部分原因是因为for循环的临时变量过多，所以想办法删除临时变量，这里删除临时变量的方法是：通过查询取代临时变量和通过功能内聚取消临时变量，如图：

4、代码中的if判断此商品是否有效，可以把判断的语句内聚到line的方法中


5、for循环中，根据打印每行line对象的代码，也可以提炼到一个函数中专门负责每行的打印

6、最后重构printFooter方法，printFoot方法用于打印总价，这里使用功能内聚的方法，把计算总价的方法定义到Invoice对象中，printFooter方法直接取值就可以了。


重构后的代码如下：

public class Invoice {
    private final String buyer;

    private final String seller;

    private final List<InvoiceLine> lines;

    public Invoice(String buyer, String seller, List<InvoiceLine> lines) {
        this.buyer = buyer;
        this.seller = seller;
        this.lines = new ArrayList<>(lines);
    }

    public float calcAmount() {
        float total = 0;
        for (int lineId = 0; lineId < getLines().size(); ++lineId) {
            final InvoiceLine line = getLines().get(lineId);
            total += line.getAmount();
        }
        return total;
    }
    public String getBuyer() {
        return buyer;
    }

    public String getSeller() {
        return seller;
    }

    public List<InvoiceLine> getLines() {
        return Collections.unmodifiableList(lines);
    }

}


public class InvoiceLine {
    private final String product;
    private final float quantity;
    private final float price;

    public InvoiceLine(String product, int quantity, int price) {
        this.product = product;
        this.quantity = quantity;
        this.price = price;
    }
    boolean isValid() {
        return product == null || "".equals(product.trim())
                || price <= 0 || quantity <= 0;
    }

    public String getProduct() {
        return product;
    }

    public float getQuantity() {
        return quantity;
    }

    public float getPrice() {
        return price;
    }

    public float getAmount() {
        return price * quantity;
    }
}
public class InvoicePrinter {
    public static void print(Invoice invoice, PrintStream printStream) {
        printHeader(invoice, printStream);
        printDetail(invoice, printStream);
        printFooter(invoice, printStream);
    }

    public static void printFooter(Invoice invoice, PrintStream printStream) {
        printStream.println("------ Total ------");
        printStream.println(invoice.calcAmount());
    }

    public static void printDetail(Invoice invoice, PrintStream printStream) {
        printStream.println("------ Detail ------");
        printStream.println("ln\tProduct\tPrice\tQt\tAmount");
        for (int lineId = 0; lineId < invoice.getLines().size(); ++lineId) {
            final InvoiceLine line = invoice.getLines().get(lineId);
            printInvoiceLine(printStream, lineId, line);
        }
    }

    public static void printInvoiceLine(PrintStream printStream, int lineId, InvoiceLine line) {
        if (line.isValid()) {
            printStream.println(lineId + "\tInvalid");
        } else {
            printStream.println(lineId + "\t" + line.getProduct() + "\t" + line.getPrice()
                    + "\t" + line.getQuantity() + "\t" + line.getAmount());
        }
    }

    public static void printHeader(Invoice invoice, PrintStream printStream) {
        printStream.println("====== INVOICE ======");
        printStream.println("Buyer: " + invoice.getBuyer());
        printStream.println("Seller: " + invoice.getSeller());
    }
}

2.2 案例2

这是一个保持数据的方法，不同的数据类型，选中不同的保存方式。

问题：switch语句太长，而且随着数据类型增大，switch也需要不停的扩展。
解决方法：将每个switch，抽取为一个方法。