需要将我的主要方法分解为较小的方法

Question

我已经为实验室作业编写了以下代码，但是，我的教授希望我将我的主方法分解为其他方法，并在主方法中调用这些方法。我尝试创建用于创建输入和输出流的方法，并尝试创建用于实际编写反向文件的方法，但我没有找到任何位置。有人能给我指正确的方向吗？我需要创建另一个类来实例化并调用这些方法吗？我是java的新手，所以任何帮助都将不胜感激！

import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
/**
 * Reads lines of text from a file named testclass.txt and writes them to a file
 * named output.txt in reverse order.
 */
public class ReverseFile {
   public static void main(String[] args) {
      Scanner fileRead;     // input stream for reading text file.
      PrintWriter fileWrite;  // output stream for writing text file.
      ArrayList<String> fileLines;  // An ArrayList for holding the lines of the text file.
      fileLines = new ArrayList<String>();
      try {  // Create the input stream.
         fileRead = new Scanner(new File("testclass.txt"));
      }
      catch (FileNotFoundException e) {
         System.out.println("Can't find text file");
         return;  // End the program by returning from main().
      }
      try {  // Create the output stream.
         fileWrite = new PrintWriter(new FileWriter("output.txt"));
      }
      catch (IOException e) {
         System.out.println("Can't open file output.txt");
         System.out.println("Error: " + e);
         fileRead.close();  // Close the input file.
         return;        // End the program.
      }
      while ( fileRead.hasNextLine() ) {  // Read until end-of-file.
         String textLine = fileRead.nextLine();
         System.out.println(textLine);
         fileLines.add(textLine);
      }
      // Output the text in reverse order.
      for (int i = fileLines.size()-1; i >= 0; i--)
         fileWrite.println(fileLines.get(i));
         //System.out.println(reverseLines);

      System.out.println("Done, check output.txt");
      fileRead.close();
      fileWrite.close();
   }  // end of main()
}

Answer 1

理想情况下，每个方法应该只做一件事，并有一个名称来明确这件事是什么。

我的建议是，你的主要方法应该看起来像：

public static void main(String[] args) {
    List<String> lines = createAndReadInputStream();
    reverse(lines);
    createAndWriteOutputStream(lines);
}

这让读者非常清楚该方法的确切作用以及其他方法中的所有实现细节。

然后对下一种方法执行相同操作：

private List<String> createAndReadInputStream() {
    Scanner inputScanner = createInputStream();
    return scanToLines(inputScanner);
}

等等。如果结构正确，您的类变量都将成为本地范围的变量，并且您的代码简单易读。你还会发现你需要更少的注释来解释发生了什么：方法的名称本身就足够了。

如果你有兴趣了解教授为什么要求这样做，以及如何做到这一点，我强烈推荐罗伯特·马丁的《清洁代码》一书。我所在的软件开发团队（11个敏捷团队中的80人）几年前就采用了它，我们代码的质量、可读性和可维护性都得到了改善。虽然需要一些时间来适应，但付出这些努力是值得的。在我看来，"代码越多就意味着bug越多"这句老话是完全错误的——只要额外的代码是为了可读性、可测试性和可维护性，那么它就意味着更少的bug，而不是更多。

Answer 2

下面是一个例子。移动这段代码：

  try {  // Create the input stream.
     fileRead = new Scanner(new File("testclass.txt"));
  }
  catch (FileNotFoundException e) {
     System.out.println("Can't find text file");
     return;  // End the program by returning from main().
  }

转换为ReverseFile类中名为createInputStream的新私有方法。从代码中删除部分的位置调用新成员。不要忘记从该方法返回"fileRead"。

Answer 3

这个怎么样：

import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
/** * Reads lines of text from a file named testclass.txt and writes them to a file * named output.txt in reverse order. */
public class ReverseFile {
    public static ArrayList<String> readFile(String fileName) {
        Scanner fileRead; // Scanner for reading text file.
        // Try to open file for reading
        try {
            fileRead = new Scanner(new File(fileName));
        // On failure -> print message & return null
        } catch (FileNotFoundException e) {       
            System.out.println("Can't find text file");
            return null;
        }
        // Create ArrayList for readed lines
        ArrayList<String> fileLines = new ArrayList<String>();    
        // Read file line-by-line until end-of-file.
        while ( fileRead.hasNextLine() ) {
            String textLine = fileRead.nextLine(); // Read next line
            System.out.println(textLine); // Print line to terminal
            fileLines.add(textLine); // Add line to ArrayList
        }
        // Close scanner -> will close allso opened file
        fileRead.close();
        // Return loaded lines
        return fileLines;
    }
    public static void createReversedFile(String filename, ArrayList<String> fileLines) {
        PrintWriter fileWrite;  // PrintWriter for writing text file.
        // Try to open file for writing
        try {  
            fileWrite = new PrintWriter(new FileWriter(filename));
        // On failure -> print message & return
        } catch (IOException e) {
            System.out.println("Can't open file output.txt");
            System.out.println("Error: " + e);
            fileRead.close();  // Close the input file.
            return;
        }
        // Output the text in reverse order
        for (int i = fileLines.size()-1; i >= 0; i--) {
            fileWrite.println(fileLines.get(i));
            //System.out.println(reverseLines);
        }

        System.out.println("Done, check " + filename);
        // Close PrintWriter -> will close allso opened file
        fileWrite.close();
    } 
    public static void main(String[] args) {
        // Read file & store it's lines into ArrayList
        ArrayList<String> fileLines = readFile("testclass.txt");
        // If file was not loaded due to FileNotFoundException exception -> exit
        if (fileLines == null) {
            return;
        }
        // Create reversed output.txt file
        createReversedFile("output.txt", fileLines);
    }
}