Java学习笔记--方法

Java SE--方法

• 一、方法的使用
• • 1、方法的概念
  • 2、方法存在的意义
  • 3、方法的调用于执行过程
  • 4、形参与实参的关系
  • 5、没有返回值的方法
• 二、方法的重载(overload)
• • 1、使用重载
  • 2、重载的规则
• 三、方法递归
• • 1、递归的概念
  • 2、递归执行过程分析
  • 3、递归小练习
  • • （1）正序输出多位整数的每一位
    • （2）斐波那契数列
    • （3）汉诺塔
• 总结

---

一、方法的使用 1、方法的概念

Java中所谓方法,就是用来解决一类问题的代码的有序组合，是一个功能模块，也就类似于C语言中的函数。

代码如下（示例1）：

public static 返回值  方法名(形式参数列表) {
    方法体；
}

2、方法存在的意义

1、是能够模块化的组织代码(当代码规模比较复杂的时候)。
2、做到代码被重复使用，一份代码可以在多个位置使用。
3、让代码更好理解更简单。
4、直接调用现有方法开发，不必重复造轮子。

3、方法的调用于执行过程

1、定义方法的时候,不会执行方法的代码，只有调用的时候才会执行。
2、当方法被调用的时候,会将实参赋值给形参。
3、参数传递完毕后,就会执行到方法体代码。
4、当方法执行完毕之后(遇到return语句),就执行完毕,回到方法调用位置继续往下执行。
5、一个方法可以被多次调用。

代码如下（示例2）：

public class Text1 {
   public static void main(String[] args) {
       int a = 10;
       int b = 20;
       System.out.println("第一次调用方法之前");
       int ret = add(a,b);
       System.out.println("第一次调用方法之后");
       System.out.println("ret = " + ret);

       System.out.println("第二次调用方法之前");
       ret =add(30,50);
       System.out.println("第二次调用方法之后");
       System.out.println("ret = " + ret);
   }

   public static int add(int x, int y){
       System.out.println("调用方法中 x =" + x + "y = "+ y);
       return x + y;
   }
}

练习示例1 ：求1！+2！+3！+4！+5！

public class Text2 {
  public static int factor(int n) {
  //方法二
      int sum3 = 0;
      for (int i = 1;i <= n; i++) {//每一个数字1-5
          fac(i);
          sum3 += fac(i);
      }
  //方法一
     
      return sum3;
  }

  
  public static int fac(int b) {
      int ret3 = 1;
      for (int i = 1;i <= b; i++) {
          ret3 *= i;
      }
      return ret3;
  }

  public static void main(String[] args) {
      System.out.println(factor(5));
  }

4、形参与实参的关系

形参其实就是实参的一份拷贝。

练习示例2 ：

public class Swap {
    public static void change(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        change(a, b);
        System.out.println(a + " " + b);
    }
}

运行结果显示并没有实现a与b数值的转换，错误的原因就是对于基础类型来说，形参相当于实参的拷贝，即传值调用。从代码中也能发现对x和y的修改并不影响到a和b的值。

解决办法 ：

public class Swap1 {
        public static void main(String[] args) {
              int[] arr = {10,20};
              change(arr);
              System.out.println("a = " + arr[0] + "b = " + arr[1]);
        }

        public static void change(int[] arr) {
                int tmp = arr[0];
                arr[0] = arr[1];
                arr[1] = tmp;
        }
}

利用数组就可以解决这样的问题。

5、没有返回值的方法

返回值可有可无，具体看业务需求，返回值的类型需要和方法的返回值匹配。
上面练习示例2就是一种无返回值类型的。

二、方法的重载(overload)

有些时候我们需要用一个函数同时兼容多种参数的情况，我们就可以使用到方法重载。

1、使用重载

练习示例3 ：

public class Text {

    
    public static void main(String[] args) {
        int d1 = 10;
        int d2 = 20;
        System.out.println(sun(d1,d2));

        double a1 = 19.5;
        double a2 = 10.3;
        System.out.println(sun(a1,a2));

        int q1 = 1;
        int q2 = 1;
        int q3 = 1;
        System.out.println(sun(q1,q2,q3));

        double w1 = 1.1;
        double w2 = 1.1;
        double w3 = 1.1;
        double w4 = 1.1;
        System.out.println(sun(w1,w2,w3,w4));

    }

    public static int sun(int a,int b) {
        return a+b;
    }

    public static double sun(double a,double b) {
        return a+b;
    }
    public static int sun(int a,int b,int c) {
        return a+b+c;
    }
    public static double sun(double a,double b,double c,double d) {
        return  a+b+c+d;
    }
}

2、重载的规则

针对同一个类:
1、方法名相同。
2、方法的参数不同(参数个数或者参数类型)。
3、方法的返回值类型不影响重载。

三、方法递归 1、递归的概念

一个方法在执行过程中调用自身，就称为"递归"；
递归相当于数学上的"数学归纳法"，有一个起始条件，然后有一个递推公式。

1、要调用自己本身；
2、要有一个趋近于终止的条件；
3、推导出递归公式。

例如：求N！
起始条件是N = 1，这个起始条件就相当于递归的终止条件；
递归公式：N！—> N*(N-1)

练习示例4 ：求5的阶乘

public class Text2 {
    public  static int fac(int n) {
        if(n == 1) {
            return 1;
        }
        int tmp = n * fac(n-1);
        return tmp;
    }

    public static void main(String[] args) {
        System.out.println(fac(5));
    }
}

2、递归执行过程分析

递归的程序的执行过程不太容易理解，要想理解清楚递归，必须先理解清楚方法的执行过程"，尤其是"方法执行结束之后，回到调用位置继续往下执行"。
以上述求5！为例分析过程

3、递归小练习 （1）正序输出多位整数的每一位

public class Recursion {
   

    public static void func1(int n) {
        if(n > 9) {
            func1(n/10);
        }
        System.out.print(n%10 + " ");
    }

    public static void main(String[] args) {
        func1(123);
    }
}

（2）斐波那契数列

public class Text5 {
    
    public static int feibonaqi(int n) {
        if(n == 1 || n ==  2) {
            return 1;
        }
        return feibonaqi(n-1) + feibonaqi(n-2);
    }

    
    public static long feibonaqi2(long bL) {
        //注意如果b输入是大于3的数
        long f1 = 1;
        long f2 = 1;
        long f3 = 0;
        for (int i = 3; i <= bL; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;

    }
    public static void main(String[] args) {
        System.out.println(feibonaqi(40));
    }
}

（3）汉诺塔

public class Text6 {
    public static void move(char pos1,char pos2) {
        System.out.print(pos1+"->"+pos2+" ");
    }
    
    public static void hanoi(int n,char pos1, char pos2, char pos3) {
        if(n == 1) {
            move(pos1,pos3);
        }else {
            hanoi(n-1,pos1,pos3,pos2);
            move(pos1,pos3);
            hanoi(n-1,pos2,pos1,pos3);
        }
    }

    public static void main(String[] args) {
        hanoi(1,'A','B','C');
        System.out.println();
        hanoi(2,'A','B','C');
        System.out.println();
        hanoi(3,'A','B','C');
    }
}

总结

重要的就是理解下面几个方面：
1、方法的概念；
2、形参与实参的关系；
3、重载的规则；
4、递归公式的推导，思维灵活转换。