(头哥）Java程序设计----重载方法

第1关：找出最大值

任务描述

本关任务：掌握是什么是方法的重载，并利用方法重载实现一个使用一个方法调用接收不同类型的参数，找出最大值。

相关知识

为了完成本关任务，你需要掌握以下内容：

1. 什么是方法重载；
2. 方法重载提示。

什么是方法重载

Java 方法重载允许我们使用相同的方法名，对不同类型的参数输入进行不同的处理。简言之，就是一定程度上允许方法名重复。

例如，比较大小的方法：

1. /** 代码清单 1 */
2. public static boolean compare(int x, int y) {
3. if(x>y)
4. return true;
5. else
6. return false;
7. }

以上方法只能接收 int 类型的参数比较大小，对于 double 类型的参数则不能使用。通过方法重载，我们可以用同样的方法名 compare 来定义对 double 类型处理的方法：

1. /** 代码清单 2 */
2. public class Test {
3. public static void main(String[] args){
4. System.out.println(compare(4,3));
5. System.out.println(compare(3.4, 3.0));
6. }
8. public static boolean compare(int x, int y) {
9. if(x>y)
10. return true;
11. else
12. return false;
13. }
15. public static boolean compare(double x, double y) {
16. if(x>y)
17. return true;
18. else
19. return false;
20. }
21. }

输出：

1. true
2. true

可以看出，通过方法重载，在调用方法时，同样的方法名具有了更多的功能，实际上是通过重载，定义了多个方法。而在实际调用时，Java 编译器不只是根据方法名来匹配，同时还会匹配参数类型，从而找到最匹配的方法进行执行。

方法重载提示

重载方法可以使得程序更加清楚，以及更加具有可读性。执行同样功能但是具有不同参数类型的方法应该使用同样的名字。

被重载的方法必须具有不同的参数列表。不能基于不同修饰符或返回值类型来重载方法。例如以下方法重载是错误的：

1. /** 代码清单 3 */
2. public static boolean compare(int x, int y) {
3. if(x>y)
4. return true;
5. else
6. return false;
7. }
9. public static int compare(int x, int y) {
10. if(x>y)
11. return 1;
12. else
13. return 0;
14. }

很显然，按照 代码清单 3 中的方式进行方法重载时，对于调用 compare 方法的语句来说，不知道应该执行哪一个方法体，也无从得知应该用什么类型的变量来接收方法返回值。

编程要求

根据提示，在右侧编辑器 Begin-End 区域补充代码，进行方法重载，具体要求如下：

• 重载方法名为 max；

• 重载的方法实现找出最大值的功能，并返回最大值；

• 使得主方法中对 max 方法的调用均能够正常执行。

测试说明

平台会对你编写的代码进行测试：

测试输入：本关任务测试定义在主方法中，无测试输入。

部分测试代码段如下所示：

1. System.out.println(max(3,4,5));
2. System.out.println(max(100,200));

预期输出：

1. 5
2. 200

代码如下：

package step1;

class Main {
    
    public static void main(String[] args) {
        System.out.println(max(3,4,5));
        System.out.println(max(100,200));
        System.out.println(max(4.5,5.6,3.1,10.62));
        System.out.println(max(1.0,2.0));
    }


    //请在指定位置填写代码。
    /********* Begin *********/
    // 第一个重载方法：接收三个int类型参数，返回最大值
    public static int max(int a, int b, int c) {
        return Math.max(a, Math.max(b, c));
    }

    // 第二个重载方法：接收两个int类型参数，返回最大值
    public static int max(int a, int b) {
        return Math.max(a, b);
    }

    // 第三个重载方法：接收两个double类型参数，返回最大值
    public static double max(double a, double b) {
        return Math.max(a, b);
    }
    // 四 double 
    public static double max(double a, double b,double c, double d) {
        return Math.max(Math.max(a,b), Math.max(c,d));
    }
 
    /********* End *********/
}

第2关：求对数

任务描述

本关任务：掌握使用方法的重载来实现默认参数值的定义，并编写程序针对一个具体的场景（例如求对数）来设计默认参数值。

相关知识

为了完成本关任务，你需要掌握以下内容：

1. 默认参数值；
2. 使用方法重载实现默认参数。

默认参数值

默认参数值是软件工程中经常会用到的一个策略。当我们提供一个方法供用户来调用时，往往有的参数并不一定要求用户进行给定，而是使用大多数人会使用的值，这个值便是参数的默认值。

如果用户对参数值有自己特殊的要求，才会进行专门的参数赋予。

默认参数值一方面可以方便用户的调用，另一方面也能增加方法的健壮性，不会因为用户没有指定参数而报错。这里给出一个实际应用的例子：

假设有一家奶茶店，我们可以将制作奶茶视为一个方法，这个方法可以接收这样几个参数：

• 奶茶味道；
• 甜度；
• 冰热；
• 打包方式；

通过给定以上四个参数，用户可以让奶茶店制作出自己想要的奶茶。

但是呢，一般情况下，用户不一定全部具体的给出这四个参数。用户可能只对奶茶味道有自己特殊的要求，因此这个参数通常需要用户指定，而奶茶的甜度、冰热、打包方式影响着奶茶更细节的品性，一般用户可能不会进行个性化的定制。这时，就需要奶茶店帮助用户进行指定较为常规的属性值，例如甜度为少糖、冰热为常温、打包方式为即食。

以上，少糖、常温、即食便是制作奶茶这个方法中甜度、冰热、打包方式这三个参数的默认参数值。这时，用户只需要告诉奶茶店，自己需要什么味道的奶茶，就能获得一杯奶茶而不会被问一些令其伤脑经的问题。

使用方法重载实现默认参数

通过以上对默认参数值的介绍，相信你已经体会到了默认参数值在实际场景中的应用价值了，明明需要四个参数的方法，用户仅仅指定一个方法便能使用了。那么，在 Java 中，如何给方法赋予默认的参数值呢？

有且仅有的途径就是利用上一关介绍的方法重载。就前面提到的奶茶制作的例子来说，就是先定义一个有着完整参数列表（4 个参数）的方法。然后，重载出一个参数列表只有一个参数（即味道）的方法，并在这个重载方法中进行默认的参数的指定。伪代码如下所示：

1. public static void 制作奶茶(味道, 甜度, 冰热, 打包方式) {
2. return 按要求制作出的奶茶;
3. }
5. public static void 制作奶茶(味道) {
6. return 制作奶茶(味道, '少糖', '常温', '即食');
7. }

编程要求

根据提示，在右侧编辑器 Begin-End 区域补充代码，定义一个可以进行求对数运算的方法，具体要求如下：

• 重载方法名为 log，返回值 double 类型；

• log 方法的功能是求参数的对数值；

• 第一个参数可以是 int 也可以是 double 类型表示准备求对数的值，第二个参数是 int 也可以是 double 类型表示对数的底数；

• 第二个参数底数作为默认参数，默认为自然底数 e，编程时可以使用 Math.E 来获取自然底数的近似值。

测试说明

平台会对你编写的代码进行测试：

测试输入：本关任务测试定义在主方法中，无测试输入。

部分测试代码段如下所示：

1. System.out.println(log(10,10));
2. System.out.println(log(10.0,10));
3. System.out.println(log(10));

预期输出：

1. 1.0
2. 1.0
3. 2.302585092994046

代码如下：

package step2;

public class Main {
    public static void main(String[] args) {
        System.out.println(log(10,10));
        System.out.println(log(10.0,10));
        System.out.println(log(10,10.0));
        System.out.println(log(10.0,10.0));
        System.out.println(log(10));
        System.out.println(log(10.0));
    }



    // 在下面完成 log 方法的定义
    public static double log(int x, int base) {
        return Math.log(x) / Math.log(base);
    }
    public static double log(double x, double base) {
        return Math.log(x) / Math.log(base);
    }
    public static double log(int x) {
        return Math.log(x);
    }
    public static double log(double x) {
        return Math.log(x);
    }

   

}

第3关：多种进制加法器

任务描述

本关任务：进一步灵活掌握如何使用方法重载，并编写一个支持多种进制的加法部件，默认使用十进制。

相关知识

为了完成本关任务，你需要掌握以下知识：

1. 多进制加法；
2. 设计要求。

多进制加法

相信在课程之前的任务中，你已经尝试写过一个简单的十进制按位加法的部件了，而实际上 CPU 的加法器是二进制的。

并且，通过课程之前的实训，相信你应该也知道如何进行进制之间的转化了。那么，实现多进制的加法应该也不是什么困难的事情了。

设计要求

在本任务中，需要你实现这样一个加法部件，实际上就是定义一个方法，能够指定部件的加法运算进制。

为了方便处理，这个方法的所有加数的值输入都以十进制的 int 类型来表示。输出的值也以十进制来表示。

例如输入的加数 7 和 8, 进行 10进制加法，输出的值为 5、并且有进位；进行 16 进制加法，输出的值为 15 并且无进位。

编程要求

根据提示，在右侧编辑器 Begin-End 区域补充代码，定义一个简单的多进制加法部件，具体要求如下：

• 加法部件方法名 add，无返回值；

• add 方法可以接受至多 4 个参数，前两个参数类型均为 int，分别表示两个加数，紧接着一个参数类型 boolean，表示是否有进位输入，最后一个参数类型 int 代表进制，可缺省，默认为十进制；

• add 方法仅仅进行个位加法运算，仅仅取加数的个位进行加法运算；

• 输入前三个 int 类型的数分别表示两个加数，以及是否有进位输入（0 对应不进位、1对应进位），对你定义的方法进行测试；

• 输入第四个 int 类型的参数表示进制，如果输入值小于 2 则在调用 add 方法时缺省。

• 在 add 方法中使用 System.out.println 分别输出运算结果（即对进制取模运算后的个位），以及进位结果，具体例子请见测试说明。

测试说明

平台会对你编写的代码进行测试：

测试输入

1. 5 5 1 10

预期输出：

1. 1
2. true

输出中 1 代表加法结果（即(5+5+1)%10=1），true表示需要进位。

测试输入

1. 5 5 1 0

预期输出：

1. 1
2. true

代码如下：

package step3;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int a = input.nextInt();
        int b = input.nextInt();
        int c = input.nextInt();
        int d = input.nextInt();

        if (d < 2) {
            MultiRadixAdder.add(a, b, c == 1);
        } else {
            MultiRadixAdder.add(a, b, c == 1, d);
        }

        input.close();
    }
}

class MultiRadixAdder {
    public static void add(int a, int b, boolean carryIn, int radix) {
        if (radix < 2) {
            radix = 10; // 默认十进制
        }
        int sum = a % radix + b % radix + (carryIn ? 1 : 0);
        boolean carryOut = sum >= radix;
        System.out.println(sum % radix);
        System.out.println(carryOut);
    }

    public static void add(int a, int b, boolean carryIn) {
        add(a, b, carryIn, 10); // 默认十进制
    }
}