Java语言程序设计与数据结构 - 第06章方法 - 《编程笔记》

6.1 引言
6.2 定义方法
6.3 调用方法
6.4 void方法与返回值方法
6.5 按值传参
6.6 模块化代码
6.7 示例学习：将十六进制数转换为十进制数
6.8 重载方法
6.9 变量的作用域
6.10 示例学习：生成随机字符
6.11 方法抽象和逐步求精

6.1 引言

方法可以用于定义可重用的代码以及组织和简化代码

6.2 定义方法

方法的定义由方法名称、参数、返回值类型以及方法体组成

定义方法的语法如下所示：

修饰符    返回值类型    方法名(参数列表){
//方法体;
}

方法头（method header）是指方法的修饰符（modifier）、返回值类型（return value）、方法名（method name）和方法的参数（parameter）。
方法可以返回一个值。returnValueType是方法返回值的数据类型。有些方法只是完成某些要求的操作，而不返回值。在这种情况下，returnValueType为关键字void例如：在main方法中returnValueType就是void，在System.exit、System.out.println方法中返回值类型也是void。如果方法有返回值，则称为带返回值的方法（value-returning method），否则就称这个该方法为void方法（void method）
定义在方法头的变量称为形式参数（formal parameter）或者简称为形参（parameter）。参数就像占位符。当调用方法时，就给参数传递一个值，这个值称为实际参数（actual parameter）或实参（argument）。参数列表（parameter list）指明方法中参数的类型、顺序和个数。方法名和参数列表一起构成方法签名（method signature）。参数是可选的，也就是说，方法可以不包含参数。例如：Math.random()方法就没有参数。
方法体中包含一个实现该方法的语句集合。max方法的方法体使用一个if语句来判断哪个数较大，然后返回该数的值。为使带返回值的方法能返回一个结果，必须要使用带关键字return的返回语句。执行return语句时方法终止
- 在其他某些语言中，方法称为过程（procedure）或函数（function）。这些语言中，带返回值的方法称为函数，返回值类型为void的方法称为过程
- 在方法头中，需要对每一个参数进行单独的数据类型声明。例如：max(int num1, int num2)是正确的，而max(int num1,num2)是错误的。
- 我们经常会说“定义方法”和“声明变量”，这里我们谈谈两者的细微差别。定义是指被定义的项是声明，而声明通常是指为被声明的项分配内存来存储数据。

6.3 调用方法

方法的调用是指执行方法中的代码
在方法定义中，定义方法要用于做什么，为了使用方法，必须调用（call或invoke）它。根据方法是否有返回值，调用方法有两种途径
在Java中，带返回值的方法也可以当作语句调用。这种情况下，函数调用者只需忽略返回值即可。虽然很少这么做，但是如果调用者对返回值不感兴趣，这样也是允许的。
当程序调用一个方法时，程序控制就转移到被调用的方法。当执行完return语句或执行到表示方法结束的右括号时，被调用的方法将程序控制返回给调用者

程序清单 6-1 TestMax.java

public class TestMax {
    /**
     * Main method
     */
    public static void main(String[] args) {
        int i = 5;
        int j = 2;
        int k = max(i, j);
        System.out.println("The maximum of " + i
                + " and " + j + " is " + k);
    }
    /**
     * Return the max of two numbers
     */
    public static int max(int num1, int num2) {
        int result;
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }
}

对带返回值的方法而言，return语句是必需的。下面图a中显示的方法在逻辑上是正确的，但它会有编译错误，因为Java编译器认为该方法有可能不会返回任何值
为修正这个问题，删除图a中的if(n < 0)，这样，编译器将发现不管if语句如何执行，总可以执行到return语句
方法能够带来代码的共享和重用。除了可以在TestMax中调用max方法，还可以在其他类中调用它。如果创建了一个新类，可以通过使用”类名.方法名”（即TestMax.max）来调用max方法
每当调用一个方法时，系统会创建一个活动记录（也称为活动框架），用于保存方法中的参数和变量。活动记录置于一个内存区域中，称为调用栈（call stack）。调用栈也称为执行栈、运行时栈，或者一个机器栈，常简称为”栈”。当一个方法调用另一个方法时，调用者的活动记录保持不变，一个新的活动记录被创建用于被调用的新方法。一个方法结束运行返回到调用这时，其相应的活动记录也被释放。
调用栈以后进先出的方式来保存活动记录：最后调用的方法的活动记录最先从栈中移出。例如，假设方法m1调用了方法m2，而方法m2调用了方法m3.运行时将m1的活动记录压倒栈中，然后是m2的，再是m3的。当m3结束运行后，它的活动记录从栈中移出。当m2结束运行后，它的活动记录从栈中移出。当m1结束运行后，它的活动记录从栈中移出。
理解调用栈有助于理解方法是如何调用的。程序清单6-1中main方法定义了变量i、j和k；max方法中定义了变量num1、num2和result。定义在方法签名中的变量num1和num2都是方法max的参数。它们的值通过方法调用进行传递。图6-3展示了堆栈中用于方法调用的活动记录。

6.4 void方法与返回值方法

void 方法不返回值

程序清单 6-2 TestVoidMethod.java

public class TestVoidMethod {
    public static void main(String[] args) {
        System.out.print("The grade is ");
        printGrade(78.5);
        System.out.println("The grade is ");
        printGrade(59.5);
    }
    public static void printGrade(double score){
        if (score >= 90){
            System.out.println('A');
        }
        else if (score >= 80){
            System.out.println('B');
        }
        else if (score >= 70){
            System.out.println('C');
        }
        else if (score >= 60){
            System.out.println('D');
        }
        else {
            System.out.println('F');
        }
    }
}

程序清单 6-3 TestReturnGradeMethod.java

public class TestReturnGradeMethod {
    public static void main(String[] args) {
        System.out.print("The grade is " + getGrade(78.5));
        System.out.print("\nThe grade is " + getGrade(59.5));
    }
    public static char getGrade(double score) {
        if (score >= 90) {
            return 'A';
        } else if (score >= 80) {
            return 'B';
        } else if (score >= 70) {
            return 'C';
        } else if (score >= 60) {
            return 'D';
        } else {
            return 'F';
        }
    }
}

return语句对于void方法不是必需的，但它能用于中止方法并返回到方法的调用者。它的语法是：
```
return;
```

这种用法很少，但是对于改变void方法中的正常流程控制是很有用的。例如：下列代码在分数是无效值时，用return语句结束方法

public static void printGrade(double score){
     if (score < 0 || score > 100){
         System.out.println("Invalid score");
         return;
     }
     if (score >= 90.0){
         System.out.println('A');
     }
     else if (score >= 80.0){
         System.out.println('B');
     }
     else if (score >= 70.0){
         System.out.println('C');
     }
     else if (score >= 60.0){
         System.out.println('D');
     }
     else {
         System.out.println('F');
     }
 }

6.5 按值传参

调用方法的时候是通过传值的方式将实参传给形参的
方法的强大之处在于它处理参数的能力。可以使用方法println打印任意字符串，用max方法求任意两个int值的最大值。调用方法时，需要提供实参，它们必须与方法签名中所对应的形参次序相同。这称作参数顺序匹配（parameter order associatiion）。例如，下面的方法打印message信息n次：

public static void nPrintln(String message, int n){
    for(int i = 0; i < n; i++)
        System.out.println(message);
}

实参必须与方法签名中定义的形参在次序和数量上匹配，在类型上兼容。类型兼容是指不需要经过显示的类型转换，实参的值就可以传递给形参，例如，将int型的实参值传递给double形参
当调用带参数的方法时，实参的值传递给形参，这个过程称为按值传递（pass - by - value）。如果实参是变量而不是字面值，则将该变量的值传递给形参。无论形参在方法中是否改变，该变量都不受影响。如程序清单6-4所示，x(1)的值传给参数n，用以调用方法increment（第5行）。在该方法中n自增1（第10行），而x的值则不论方法做了什么都保持不变。

程序清单 6-4 Increment.java

public class Increment {
    public static void main(String[] args) {
        int x = 1;
        System.out.println("Before the call, x is " + x);
        increment(x);
        System.out.println("After the call, x is " + x);
    }
    public static void increment(int n) {
        n++;
        System.out.println("n inside the method is " + n);
    }
}

程序清单 6-5 TestPassByValue.java

public class TestPassByValue {
    /**
     * Main method
     *
     * @param args
     */
    public static void main(String[] args) {
        //Declare and initialize variables
        int num1 = 1;
        int num2 = 2;
        System.out.println("Before invoking the swap method, num1 is " +
                num1 + " and num2 is " + num2);
        //Invoke the swap method to attempt to swap two variables
        swap(num1, num2);
        System.out.println("After invoking the swap method, num1 is " +
                num1 + " and num2 is " + num2);
    }
    /**
     * Swap two variables
     */
    public static void swap(int n1, int n2) {
        System.out.println("\tInside the swap method");
        System.out.println("\t\tBefore swapping, n1 is " + n1
                + " and n2 is " + n2);
        //Swap n1 with n2
        int temp = n1;
        n1 = n2;
        n2 = temp;
        System.out.println("\t\tAfter swapping, n1 is " + n1
                + " and n2 is " + n2);
    }
}

为了简便，Java程序员经常说将实参x传给形参y,实际含义是指将x的值传递给y

6.6 模块化代码

模块化使得代码易于维护和调试，并且使得代码可以被重用
使用反复噶可以减少冗余的代码，提高代码的复用性。方法也可以用来模块化代码，以提高程序的质量

程序清单 6-6 GreatestCommonDivisorMethod.java

import java.util.Scanner;
public class GreatestCommonDivisorMethod {
    /**
     * Main method
     * @param args
     */
    public static void main(String[] args) {
        //Create a Scanner
        Scanner input = new Scanner(System.in);
        //Prompt the user to enter two integers
        System.out.print("Enter first integer: ");
        int n1 = input.nextInt();
        System.out.print("Enter second integer: ");
        int n2 = input.nextInt();
        System.out.println("The Greatest common divisor for " + n1 +
                " and " + n2 + " is " + gcd(n1,n2));
    }
    /**
     * Return the gcd of two integers
     */
    public static int gcd(int n1,int n2){
        //Initial gcd is 1
        int gcd = 1;
        //Possible gcd
        int k = 2;
        while (k <= n1 && k<=n2){
            if (n1 % k == 0 && n2 % k == 0){
                //Update gcd
                gcd = k;
            }
            k++;
        }
        return gcd;
    }
}

通过将求最大公约数的代码封装在一个方法中，这个程序就具备了以下几个优点：

它将计算最大公约数的问题和main方法中的其他代码分隔开，这样做会使逻辑更加清晰而且程序的可读性更强
将计算最大公约数的错误限定在gcd方法中，这样就缩小了调试的范围
现在，其他程序可以重复使用gcd方法

程序清单 6-7 PrimeNumberMethod.java

public class PrimeNumberMethod {
    public static void main(String[] args) {
        System.out.println("The first 50 prime numbers are :\n");
        printPrimeNumbers(50);
    }
    public static void printPrimeNumbers(int numberOfPrimes) {
        //Display 10 per line
        final int NUMBER_OF_PRIMES_PER_LINE = 10;
        //Count the number of prime numbers
        int count = 0;
        //A number to be tested for primeness
        int number = 2;
        //Repeatedly find prime numbers
        while (count < numberOfPrimes) {
            //Print the prime number and increase the count
            if (isPrime(number)) {
                //Increase the count
                count++;
                if (count % NUMBER_OF_PRIMES_PER_LINE == 0) {
                    //Print the number and advance to the new line
                    System.out.printf("%-5d\n", number);
                } else {
                    System.out.printf("%-5d", number);
                }
            }
            //Check whether the next number is prime
            number++;
        }
    }
    public static boolean isPrime(int number) {
        for (int divisor = 2; divisor <= number / 2; divisor++) {
            if (number % divisor == 0) {
                //If true ,number is not prime
                //Number is not a prime
                return false;
            }
        }
        //Number is prime
        return true;
    }
}

我们将一个大问题分成两个子问题：确定一个数字是否是素数以及打印素数。这样，新的程序会更易读，也更易于调试。而且，其他程序也可以复用方法printPrimeNumbers和isPrime

6.7 示例学习：将十六进制数转换为十进制数

本节给出一个程序，将十六进制数转换位十进制数
一种基于穷举的方法是将每个十六进制的字符转换为一个十进制数，即第 i 个位置的十六进制数乘以16i ，然后将所有这些项相加，就得到和该十六进制数等价的十进制数
注意到：
hn × 16n + hn-1 × 16n-1 + hn-2 × 16n-2 + …… + h1 × 161 + h0 × 160

= (……(( hn × 16n + hn-1 ) × 16 + hn-2) × 16 + …… + h1) × 16 + h0

这个发现，称为霍纳算法，可以导出下面这个将十六进制字符串转换为十进制数的高效算法：

int decimalValue = 0;
for(int i = 0; i <hex.length(); i++){
    char hexChar = hex.charAt(i);
    decimalValue = decimalValue * 16 + hexCharToDecimal(hexChar);
}

下面是将算法应用于十六进制数AB8C时对程序的跟踪： | | i | 十六进制数 | 十六进制数转换为十进制数 | 十进制数 | | —- | —- | —- | —- | —- | | 循环开始之前 | | | | 0 | | 第一次迭代之后 | 0 | A | 10 | 10 | | 第二次迭代之后 | 1 | B | 11 | 10 16 +11 | | 第三次迭代之后 | 2 | 8 | 8 | （10 16 + 11） 16 + 8 | | 第四次迭代之后 | 2 | C | 12 | （（10 _ 16 + 11）_16 +8) 16 + 12 |

程序清单 6-8 Hex2Dec.java

import java.util.Scanner;
public class Hex2Dec {
    /**
     * Main method
     *
     * @param args
     */
    public static void main(String[] args) {
        //Create a Scanner
        Scanner input = new Scanner(System.in);
        //Prompt the user to enter a string
        System.out.print("Enter a hex number: ");
        String hex = input.nextLine();
        System.out.println("The decimal value for hex number " + hex +
                " is " + hexToDecimal(hex.toUpperCase()));
    }
    public static int hexToDecimal(String hex) {
        int decimalValue = 0;
        for (int i = 0; i < hex.length(); i++) {
            char hexChar = hex.charAt(i);
            decimalValue = decimalValue * 16 + hexCharToDecimal(hexChar);
        }
        return decimalValue;
    }
    public static int hexCharToDecimal(char ch) {
        if (ch >= 'A' && ch <= 'F') {
            return 10 + ch - 'A';
        } else {
            //ch is '0','1',...,or '9
            return ch - '0';
        }
    }
}

6.8 重载方法

重载方法使得你可以使用同样的名字来定义不同方法，只要它们的参数列表是不同的

程序清单 6-9 TestMethodOverloading.java

public class TestMethodOverloading {
    /**
     * Main method
     *
     * @param args
     */
    public static void main(String[] args) {
        //Invoke the max method with int parameters
        System.out.println("The maximum of 3 and 4 is "
                + max(3, 4));
        //Invoke the max method with double parameters
        System.out.println("The maximum of 3.0 and 5.4 is "
                + max(3.0, 5.4));
        //Invoke the max method with three double parameters
        System.out.println("The maximum of 3.0 and 5.4 , and 10.14 is "
                + max(3.0, 5.4, 10.14));
    }
    /**
     * Return the max of two int values
     */
    public static int max(int num1, int num2) {
        if (num1 > num2) {
            return num1;
        } else {
            return num2;
        }
    }
    /**
     * Find the max of two double values
     */
    public static double max(double num1, double num2) {
        if (num1 > num2) {
            return num1;
        } else {
            return num2;
        }
    }
    /**
     * Return the max of three double values
     */
    public static double max(double num1, double num2, double num3) {
        return max(max(num1, num2), num3);
    }
}

重载方法可以使得程序更加清楚，以及更加具有可读性。执行同样功能但是具有不同参数类型的方法应该使用同样的名字
被重载的方法必须具有不同的参数列表。不能基于不同的修饰符或返回值类型来重载方法。
有时调用一个方法时，会有两个或更多可能的匹配，但是，编译器无法判断哪个是最精确的匹配。这称为歧义调用（ambiguous invocation）。歧义调用会产生一个编译错误。考虑如下代码：

public class AmbiguousOverloading {
    public static void main(String[] args) {
        System.out.println(max(1,2));
    }
    public static double max(int num1, double num2){
        if (num1 > num2) {
            return num1;
        } else {
            return num2;
        }
    }
    public static double max(double num1, int num2){
        if (num1 > num2){
            return num1;
        }
        else {
            return num2;
        }
    }
}

max(int ,double)和max(double, int)都有可能与max(1,2)匹配。由于两个方法谁也不比谁更精确，所以这个调用是有歧义的，它会导致一个编译错误。

6.9 变量的作用域

变量的作用域（scope of a variable）是指变量可以在程序中被引用的范围。
在方法中定义的变量称为局部变量（local variable）。
局部变量的作用域是从变量声明的地方开始，直到包含该变量的块结束为止，局部变量都必须在使用之前进行声明和赋值
参数实际上就是一个局部变量。一个方法的参数的作用域覆盖整个方法。在for循环头中初始操作部分声明的变量，其作用域只限于循环体内，从它的声明处开始，到包含该变量的块结束为止。
可以在一个方法中的不同块里声明同名的局部变量，但是，不能在嵌套块中或同一块中两次声明同一个局部变量
一种常见的错误是在for循环中声明一个变量，然后试图在循环外使用它。如下面代码所示，i在for循环中声明，但是在for循环外进行访问，这将导致语法错误。

for(int i= 0; i < 10;i++){
}
//Causes a syntax error on i
System.out.println(i);

6.10 示例学习：生成随机字符

字符使用整数来编码。产生一个随机字符就是产生一个随机整数
每个字符都有一个唯一的Unicode,其值在十六进制数0到FFFF（即十进制的655 35）之间。生成一个随机字符就是使用下面的表达式，生成从0到65 535 之间的一个随机整数（注意：因为0 <= Math.random( ) < 1.0，必须给65 535 上加1）：

(int)(Math.random() * (65535 + 1))

现在让我们来考虑如何生成一个随机小写字母。小写字母的Unicode是一串连续的整数，从小写字母’a’的Unicode开始，然后是’b’、’c’、…和’z’的Unicode。’a’的Unicode是：
```
(int)'a'
```
所以，(int)’a’到(int)’z’之间的随机整数是：
正如4.3.3节中所讨论的，所有的数字操作符都可以应用到char操作数上。如果另一个操作数是数字或字符，那么char型操作数就会被转换成数字。这样，前面的表达式就可以简化为如下所示：
这样，随机的小写字母是：
由此，可以生成任意两个字符ch1和ch2之间的随机字符，其中ch1 < ch2,如下所示：
这是一个简单但却很有用的发现。在程序清单6-10中创建一个名为RandomCharacter的类，它有五个重载的方法，随机获取某种特定类型的字符。可以在以后的项目中使用这些方法。

程序清单 6-10 RandomCharacter.java

public class RandomCharacter {
    /**
     * Generate a random character between ch1 and ch2
     */
    public static char getRandomCharacter(char ch1, char ch2){
        return (char)(ch1 + Math.random() * (ch2 - ch1 + 1));
    }
    /**
     * Generate a random lowercase letter
     */
    public static char getRandomLowerCaseLetter(){
        return getRandomCharacter('a','z');
    }
    /**
     * Generate a random uppercase letter
     */
    public static char getRandomUpperCaseLetter(){
        return getRandomCharacter('A','Z');
    }
    /**
     * Generate a random digit character
     */
    public static char getRandomDigitCharacter(){
        return getRandomCharacter('0','9');
    }
    /**
     * Generate a random character
     */
    public static char getRandomCharacter(){
        return getRandomCharacter('\u0000','\uFFFF');
    }
}

程序清单6-11 给出一个测试程序，显示175个随机的小写字母。

程序清单 6-11 TestRandomCharacter.java

public class TestRandomCharacter {
    /**
     * Main method
     *
     * @param args
     */
    public static void main(String[] args) {
        final int NUMBER_OF_CHARS = 175;
        final int CHARS_PER_LINE = 25;
        //Print random characters between 'a' and 'z' , 25 chars per line
        for (int i = 0; i < NUMBER_OF_CHARS; i++) {
            char ch = RandomCharacter.getRandomLowerCaseLetter();
            if ((i + 1) % CHARS_PER_LINE == 0) {
                System.out.println(ch);
            } else {
                System.out.print(ch);
            }
        }
    }
}

第9行调用定义子啊RandomCharacter类中的方法getRandomLowerCaseLetter( )。注意，虽然方法getRandomLowerCaseLetter( )没有任何参数，但是在定义和调用这类方法时仍然需要使用括号。

6.11 方法抽象和逐步求精

开发软件的关键在于应用抽象的概念
方法抽象（method abstraction）是通过将方法的使用和它的实现分离来实现的。用户在不知道方法是如何实现的情况下，就可以使用方法。方法的实现细节封装在方法内，对使用该方法的用户来说是隐藏的。这就称为信息隐藏（information hiding）或封装（encapsulation）。如果决定改变方法的实现，只要不改变方法签名，用户的程序就不受影响。方法的实现对用户隐藏在"Black Box"中。
前面已经使用过方法System.out.print来显示一个字符串，用max方法求最大数。也知道了怎样在程序中编写代码来调用这些方法。但是作为这些方法的使用者，你并不需要知道它们是怎样实现的。
方法抽象的概念可以应用于程序的开发过程中。当编写一个大型程序时，可以使用"分治"（divid-and-conquer）策略，也称为逐步求精（stepwise-refinement），将大问题分解成子问题。子问题又分解成更小、更容易处理的问题

6.11.1 自顶向下的设计

如何开始编写这样一个程序呢？你会立即开始编写代码吗？编程初学者常常想一开始就解决每一个细节。尽管细节对最终程序很重要，但在前期过多关注细节会阻碍解决问题的进程。为使解决问题的流程尽可能地流畅，本例先用方法抽象把细节与设计分离，到后面才实现这些细节
对本例来说，先把问题拆分成两个子问题：读取用户输入和打印该月的日历。在这一阶段，应该考虑还能分解成声明子问题，而不是用什么方法来读取输入和打印整个日历。可以画一个结构图，这有助于看清楚问题的分解过程。（图6-8 结构图显示将打印日历printCalendar问题分解成两个子问题 —- 读取输入readInput 和打印日历printMonth，如图a；而将printMonth分解成两个更小的问题 —- 打印日历头printMonthTitle和打印日历头printMonthTitle和打印日历体printMonthBody，如图b）往后学会怎么在md文档中画图在来画图
你可以使用Scanner来读取年和月份的输入。打印给定月份的日历问题可以分解成两个子问题：打印日历的标题和日历的主体，如图6-8b所示。月历的标题由三行组成：年月、虚线、每周七天的星期名称。需要通过表示月份的数字（例如：1）来确定该月的全程（例如：January）。这个步骤是由getMonthName来完成的（参见图6-9a）
为了打印日历的主体，需要知道这个月的第一天是星期几（getStartDay）,以及该月有多少天（getNumberOfDaysInMonth）,如图6-9b所示。例如：2013年12月有31天，2013年12月1号是星期天。
怎样才能知道一个月的第一天是星期几呢？有几种方法可以求得。这里，我们采用下面的方法。假设知道1800年1月1日是星期三（START_DAY_FOR_JAN_1_1800=3）,然后计算1800年1月1日和日历月份的第一天之间相差的总天数(totalNumberOfDays)。因为每个星期有7天，所以日历上每月第一天的星期值就是（totalNumberOfDays + START_DAY_FOR_JAN_1_1800） % 7。这样getStartDay问题就可以进一步细化为getTotalNumberOfDays,如图6-10a所示。
要计算总天数，需要知道该年是否是闰年以及每个月的天数。所以getTotalNumberOfDays可以进一步细化成两个子问题：isLeapYear 和 getNumberOfDaysInMonth,如图6-10b所示。完整的结构图如图6-11 所示。

6.11.2 自顶向下和自底向上的实现

现在我们把注意力转移到实现上。通常，一个子问题对应于实现中的一个方法，即使某些子问题太简单，以至于都不需要方法来实现。需要决定哪些模块要用方法实现，而哪些模块要与其他方法结合完成。这种决策应该基于所做的选择是否使整个程序更易读。在本例中，子问题readInput只要在main方法中实现即可。
可以采用“自顶向下” 或“自底向上”的方法。“自顶向下” 方法是自上而下，每次实现结构图中的一个方法。待实现的方法可以用存根方法（stub）代替，存根方法是方法的一个简单但不完整的版本。使用存根方法可以快速地构建程序的框架。首先实现main方法，然后使用printMonth方法的存根方法。例如，让printMonth的存根方法显示年份和月份，程序以下面的形式开始：

import java.util.Scanner;
public class PrintCalendar {
    /**
     * Main method
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //Prompt the user to enter year
        System.out.println("Enter full year (e.g.,2012): ");
        int year = input.nextInt();
        //Prompt the user to enter month
        System.out.println("Enter month as a number between 1 and 12: ");
        int month = input.nextInt();
        //Print calendar for the month of the year
        printMonth(year, month);
    }
    /**
     * A stub for printMonth may look like this
     */
    private static void printMonth(int year, int month) {
        System.out.println(month + " " + year);
    }
    /**
     * A stub for printMonthTitle may look like this
     */
    public static void printMonthTitle(int year, int month) {
    }
    /**
     * A stub for printMonthBody may look like this
     */
    public static void printMonthBody(int year, int month) {
    }
    /**
     * A stub for getMonthName may look like this
     */
    public static String getMonthName(int month) {
        //A dummy value
        return "January";
    }
    /**
     * A stub for getStartDay may look like this
     */
    public static int getStartDay(int year, int month) {
        //A dummy value
        return 1;
    }
    /**
     * A stub for getTotalNumberOfDays may look like this
     */
    public static int getTotalNumberOfDays(int year,int month) {
        //A dummy value
        return 10000;
    }
    /**
     * A stub for getNumberOfDaysInMonth may look like this
     */
    public static int getNumberOfDaysInMonth(int year,int month) {
        //A dummy value
        return 31;
    }
    /**
     * A stub for isLeapYear may look like this
     */
    public static Boolean isLeapYear(int year) {
        //A dummy value
        return true;
    }
}

编译和测试这个程序，然后修改所有的错误。现在，可以实现printMonth方法。对printMonth中调用的方法，可以继续使用存根方法。
自底向上方法是从下向上每次实现结构图中的一个方法，对每个实现的方法都写一个测试程序（称为驱动器（driver））进行测试。自顶向下和自底向上都是不错的方法：它们都是渐近地实现方法，这有助于分离程序设计错误，使调试变得容易。这两种方法可以一起使用。

6.11.3 实现细节

从3.11 节我们知道，方法isLeapYear(int year)可以使用下列代码实现：

return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);

使用下面的事实实现getNumberOfDaysInMonth(int year, int month)方法：
- 一三五七八十腊，三十一天永不差，四六九冬三十天，平年二月二十八
要实现getTotalNumberOfDays(int year,int month)方法，需要计算1800年1月1日和该日历所属月份的第一天之间的总天数（totalNumberOfDays）。可以求出1800年到该日历所在年的总天数，然后求出在该年中日历所属月份之前的总天数。这两个总天数相加就是totalNumberOfDays。
要打印日历体，首先在第一天之前填充一些空格，然后为每个星期打印一行。
完整的程序见程序清单6-12

程序清单 6-12 PrintCalendar.java

package Based_On_Article.The_Textbook_Source_Code.Chapter06;
import java.util.Scanner;
public class PrintCalendar {
    /**
     * Main method
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //Prompt the user to enter year
        System.out.println("Enter full year (e.g.,2012): ");
        int year = input.nextInt();
        //Prompt the user to enter month
        System.out.println("Enter month as a number between 1 and 12: ");
        int month = input.nextInt();
        //Print calendar for the month of the year
        printMonth(year, month);
    }
    /**
     * Print the calendar for a month in a year
     */
    public static void printMonth(int year, int month) {
        //Print the headings of the calendar
        printMonthTitle(year, month);
        //Print the body of the calendar
        printMonthBody(year, month);
    }
    /**
     * Print the month title,e.g.,March 2012
     */
    public static void printMonthTitle(int year, int month) {
        System.out.println("        " + getMonthName(month) +
                " " + year);
        System.out.println("--------------------------");
        System.out.println(" Sun Mon Tue Wed Thu Fri Sat ");
    }
    /**
     * Get the English name for the month
     */
    public static String getMonthName(int month) {
        String monthName = "";
        switch (month) {
            case 1: monthName = "January";break;
            case 2: monthName = "February";break;
            case 3: monthName = "March";break;
            case 4: monthName = "April";break;
            case 5: monthName = "May";break;
            case 6: monthName = "June";break;
            case 7: monthName = "July";break;
            case 8: monthName = "August";break;
            case 9: monthName = "September";break;
            case 10: monthName = "October";break;
            case 11: monthName = "November";break;
            case 12: monthName = "December";break;
            default:
                System.out.println("error");;
        }
        return monthName;
    }
    /**
     * Print month body
     */
    public static void printMonthBody(int year, int month) {
        //Get start day of the week for the first date in the month
        int startDay = getStartDay(year, month);
        //Get number of day in the month
        int numberOfDaysInMonth = getNumberOfDaysInMonth(year, month);
        //Pad space before the first day of the month
        int i = 0;
        for (i = 0; i < startDay; i++) {
            System.out.print("    ");
        }
        for (i = 1; i <= numberOfDaysInMonth; i++) {
            System.out.printf("%4d", i);
            if ((i + startDay) % 7 == 0) {
                System.out.println();
            }
        }
        System.out.println();
    }
    /**
     * Get the start day of month/1/year
     */
    public static int getStartDay(int year, int month) {
        final int START_DAY_FOR_JAN_1_1800 = 3;
        //Get total number of days from 1/1/1800 to month/1/year
        int totalNumberOfDays = getTotalNumberOfDays(year, month);
        //Return the start day for month/1/year
        return (totalNumberOfDays + START_DAY_FOR_JAN_1_1800) % 7;
    }
    /**
     * Get the total number of days since January 1, 1800
     */
    public static int getTotalNumberOfDays(int year, int month) {
        int total = 0;
        //Get the total days from 1800 to 1/1/year
        for (int i = 1800; i < year; i++) {
            if (isLeapYear(i)) {
                total = total + 366;
            } else {
                total = total + 365;
            }
        }
        //Add days from Jan to the month prior to the calendar month
        for (int i = 1; i < month; i++) {
            total = total + getNumberOfDaysInMonth(year, i);
        }
        return total;
    }
    /**
     * Get the number of days in a month
     */
    public static int getNumberOfDaysInMonth(int year, int month) {
        if (month == 1 || month == 3 || month == 5 || month == 7 ||
                month == 8 || month == 10 || month == 12) {
            return 31;
        }
        if (month == 4 || month == 6 || month == 9 || month == 11) {
            return 30;
        }
        if (month == 2) {
            return isLeapYear(year) ? 29 : 28;
        }
        //If month is incorrect
        return 0;
    }
    /**
     * Determine if it is a leap year
     */
    public static boolean isLeapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

该程序没有检测用户输入的有效性。例如：如果用户输入的月份不在1到12之间，或者年份在1800年之前，那么程序就会显示出错误的日历。为避免出现这样的错误，可以添加一个if语句在打印日历前检测输入。
该程序可以打印一个月的日历，还可以很容易地修改为打印整年的日历。尽管它现在只能处理1800年1月以后的月份，但是可以稍作修改，便能够打印1800年之前的月份。

6.11.4 逐步求精的优势

逐步求精将一个大问题分解为小的易于处理的子问题。每个子问题可以使用一个方法来实现。这种方法使得问题更加易于编写、重用、调试、修改和维护
优势：
- 更简单的程序
  - 打印日历的程序比较长。逐步求精方法见将其分解为较小的方法，而不是在一个方法中写很长的语句序列。这样简化了程序，使得整个程序易于阅读和理解
- 重用方法
  - 逐步求精提高了一个程序中的方法重用。isLeapYear方法只定义了一次，从getTotalNumberOfDays和getNumberOfDaysInMonth方法中都进行了调用。这减少了冗余的代码。
- 易于开发、调试和测试
  - 因为每个子问题在一个方法中解决，而一个方法可以分别的开发、调试和测试。这隔离了错误，使得开发、调试和测试更加容易
  - 编写大型程序时，可以使用自顶向下或自底向上的方法。不要一次性地编写整个程序。使用这些方法似乎浪费了更多的开发时间（因为要反复编译和运行程序），但实际上，它会更节省时间并使调试更容易
- 更方便团队合作
  - 当一个大问题分解为许多子问题，各个子问题可以分配给不同的编程人员。这更加易于编程人员进行团队工作

第06章 方法