Java（七）方法重载

方法的返回值问题

当方法有返回值时，我们可以选择是否接收，不接受不影响程序的执行，当返回值对我们有用是就需要我们去接收这个返回值。
例如：

public static void main(String[] args)
	{
		//赋值运算符，先算等号右边的，将其赋值给等号左边
		int i = asd(12,5);
		System.out.println(i);
	}
	public static int asd(int x,int y)
	{
		int s;//返回值s的类型要与方法的返回类型相同
		s = x * y;
		return s;
		//注意在有返回值的方法中的return语句后面
		//在同一个作用域中，return后面不要编写任何代码，
		//这个语句永远无法执行到，编译报错
	}

也可以简单的编写 return 语句：

return 10 > 3 ? 1 : 0;
//前件为真返回1，否则返回0

• 返回值类型是 void 的方法当中也可以使用 return 语句
• return 语句出现在 void 的方法当中主要是为了终止方法的执行（例如终止循环的进行）。
• 注意 return 后面不能有值，否则会报错。

方法重载的作用

方法重载可以将功能相似的方法整合在一起，可以方便程序员调用方法，达到调用一个方法，使用多个方法功能的效果。
体验一下方法的好处：

public class Test01 
{
    public static void main(String[] args)
    {
        System.out.println(sum(1, 2));
        System.out.println(sum(1.0, 2.0));
        System.out.println(sum(1L, 2L));
    }

    public static int sum(int a, int b)
    {
        System.out.println("sum(int)")
        return a + b;
    }

    public static double sum(double a, double b)
    {
        System.out.println("sum(double)")
        return a + b;
    }

    public static long sum(long a, long b)
    {
        System.out.println("sum(long)")
        return a + b;
    }
}

可以看到，使用方法重载，此时区分方法不再依靠方法名，依靠参数的参数数据类型

参数的类型不同，对应调用的方法不同

使用方法重载，注意区分功能的相似度，功能有明显区别应该以不同名称命名，避免触发方法重载

方法重载的使用

• 方法重载：

• 方法重载又被称作：overload

• 功能相似时，尽可能使用

• 什么条件构成方法重载？
  在同一个类当中
  方法名相同
  ---- 参数列表不同：
  数量不同
  顺序不同
  类型不同

• 方法重载和什么有关系，和什么没关系？
  方法重载 和 方法名+参数列表有关系
  方法重载 和 返回值类型无关
  方法重载 和 修饰符列表无关

public class Test02
{
    public static void main(String[] args)
    {
        U.p(10);
        U.p(false);
        U.p('a');
        U.p("hello World");
        U.p(3.0);
    }
}

class U
{
    public static void p(byte b)
    {
        System.out.println(b);
    }
        public static void p(short b)
        {
        System.out.println(b);
    }
        public static void p(int b)
        {
        System.out.println(b);
    }
        public static void p(long b)
        {
        System.out.println(b);
    }
        public static void p(float b)
        {
        System.out.println(b);
    }
        public static void p(double b)
        {
        System.out.println(b);
    }
        public static void p(boolean b)
        {
        System.out.println(b);
    }
        public static void p(char b)
        {
        System.out.println(b);
    }
        public static void p(String b)
        {
        System.out.println(b);
    }
}

方法递归的调用

public class Test03
{

    public static void main(String[] args){

        System.out.println("main begin");

        // 调用doSome方法
        doSome();

        System.out.println("main over");
    }

    public static void doSome(){
        System.out.println("main begin");
        doSome(); // 调用方法自身
        System.out.println("main over");
    }
}

• 在上面的代码中 doSome 的代码片段只有一份

        public static void doSome(){
        System.out.println("main begin");
        doSome(); // 这块代码不结束，下一行代码不执行
        System.out.println("main over");
    }

• 只要调用 doSome 方法就会在栈内存中新分配一块所属内存空间
• 上述程序会产生一个错误【不是异常，是错误 Error 】
  – java.lang.StackOverflowError
  – 栈内存溢出错误
  – 错误发生无法挽回，只有一个结果，就是 JVM-停止工作

方法递归的使用

1.方法自身调用自身

 a(){
     a();
 }

2.递归是很耗费栈内存的，递归算法能不用就尽量不用
3.递归必须有结束条件，不然必定会发生栈内存溢出错误
4.递归即使有结束条件，但也可能发生栈内存溢出错误，因为递归的太深了

public class Test04{

    public static void main(String[] args){

        int num = 4;

        System.out.println("sum: " + sum(num));

        System.out.println("rexursionSum: " + rexursionSum(num));
        
    }

    // 求 1~N 的和
    public static int sum(int num){

        int result = 0;
        for(int i = 1; i <= num; i++){
            result += i;
        }

        return result;
    }

    // 使用递归，求 1~N 的和
    public static int rexursionSum(int num){

        if (num == 1){
            return 1;
        }
        return num + rexursionSum(num - 1);
    }
}

/*
运行结果：
sum: 10
rexursionSum: 10
*/

举个栗子

public class Test04{

    public static void main(String[] args){

        int num = 4;

        System.out.println("------------\nsum: " + sum(num));
        
    }

    // 使用递归，求 1~N 的和
    public static int sum(int num){

        System.out.println("sum " + num + " 执行开始");


        int result;

        System.out.println("num: " + num);

        if (num == 1){
            System.out.println("sum " + num + " 执行结束");
            return 1;
        }
        result = sum(num - 1);

        System.out.println("result: " + result);
        result += num;
        System.out.println("result += num: " + result);


        System.out.println("sum " + num + " 执行结束");

        return result;
    }
}

执行结果：

sum 4 执行开始
num: 4
sum 3 执行开始
num: 3
sum 2 执行开始
num: 2
sum 1 执行开始
num: 1
sum 1 执行结束
result: 1
result += num: 3
sum 2 执行结束
result: 3
result += num: 6
sum 3 执行结束
result: 6
result += num: 10
sum 4 执行结束
------------
sum: 10