方法（递归--汉诺塔）

62 阅读4分钟

1.方法的定义

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
    方法体代码;
    return 返回值;
}

//实现一个两个整数相加的方法
public class Method{
// 方法的定义
    public static int add(int x, int y) {
    return x + y;
    }
}
  1. 修饰符：现阶段直接使用public static 固定搭配
  2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成

void

  1. 方法名字：采用小驼峰命名
  2. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
  3. 方法体：方法内部要执行的语句
  4. 在 java 当中，方法必须写在类当中
  5. 在 java 当中，方法不能嵌套定义
  6. 在 java 当中，没有方法声明一说

1.1 方法的调用

调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到主调方法继续往下 执行

//两数相加
public class Main {
    public static int add(int a,int b){
        return a+b;
    }
    public static void main(String[] args) {
        int x = 6;
        int y = 8;
        int z = add(x,y);
        System.out.println(z);
    }
}

//计算 1! + 2! + 3! + 4! + 5!
 public static int fac(int a){
        int result = 1;
        for (int j = a; j >= 1; j--) {
            result *= j;
        }
        return result;
    }
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5 ; i++) {
            sum += fac(i);
        }
        System.out.println(sum);
    }

1.2 实参和形参的关系

1.3 没有返回值的方法

没有返回值就要写 void

并且 return 也是一个结束标志，若为 void 则代表没有返回值

2.方法的重载

  1. 方法名必须相同
  2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
  3. 与返回值类型是否相同无关
public class TestMethod {
    public static void main(String[] args) {
        add(1, 2); // 调用add(int, int)
        add(1.5, 2.5); // 调用add(double, double)
        add(1.5, 2.5, 3.5); // 调用add(double, double, double)
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(double x, double y, double z) {
        return x + y + z;
    }
}

2.2 方法签名

方法签名：经过编译器编译修改过之后方法最终的名字。

具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

public class TestMethod {
    public static int add(int x, int y){
        return x + y;
    }
    public static double add(double x, double y){
        return x + y;
    }
    public static void main(String[] args) {
        add(1,2);
        add(1.5, 2.5);
    }
}

具体操作：

  1. 先对工程进行编译生成.class字节码文件
  2. 在控制台中进入到要查看的.class所在的目录
  3. 输入：javap -v 字节码文件名字即可

image.png

3.递归

一个方法在执行过程中调用自身, 就称为 "递归"

递归的必要条件：

  1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
  2. 递归出口
//递归求N的阶乘
public class Main {
    public static int fac(int n){
        if(n == 1){
            return 1;
        }
        return n * fac(n-1);
    }
    public static void main(String[] args) {
        int n = 5;
        int ret = fac(n);
        System.out.println(ret);
    }
}

image.png

//按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)
public class Main {
    public static void print(int n){
        if(n > 9){
            print(n/10);
        }
        System.out.println(n%10);
    }
    public static void main(String[] args) {
        int n = 1234;
        print(n);
    }
}	

//递归求 1 + 2 + 3 + ... + 10
public class Main {
    public static int sum(int n){
        if(n == 1){
            return 1;
        }
        return n + sum(n-1);
    }
    public static void main(String[] args) {
        int n = 10;
        int ret = sum(n);
        System.out.println(ret);
    }
}


 // 斐波那契额数列 ：0、1、1、2、3、5、8、13、21、34
import java.util.Scanner;

public class Main {
    /*public static int fib(int n){
        if(n == 1){
            return 0;
        } else if (n == 2) {
            return 1;
        }else {
            return fib(n-1)+fib(n-2);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fib(n);
        System.out.println(ret);
    }*/
    public static int fib(int n){
        int p = 0;
        int q = 1;
        int s = 0;
        if(n ==1)
        {
            return 0;
        } else if (n == 2) {
            return 1;
        }
        for (int i = 3; i <= n ; i++) {
            s = p + q;
            p = q;
            q = s;
        }
        return s;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fib(n);
        System.out.println(ret);
    }
}

4.汉诺塔

有三根相邻的柱子，标号为A(pos1),B(pos2),C(pos3)，A柱子上从下到上按金字塔状叠放着n个不同大小的圆盘，要把所有盘子一个一个移动到柱子B上，并且每次移动同一根柱子上都不能出现大盘子在小盘子上方。

image.png

  import java.util.Scanner;
  
  public class Main {
      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);//将 n-1 个从 pos1 --> pos2 ,借助pos3(归到上方的move来打印每一步)
              move(pos1,pos3);             //将pos1 --> pos3
              hanOi(n-1,pos2,pos1,pos3);//将 n-1 个从 pos2 --> pos3 ,借助pos1
          }
      }
      public static void move(char pos1,char pos2){
          System.out.println(pos1+"-->"+pos2);
      }
      public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
          int n = scanner.nextInt();
          hanOi(n,'A','B','C');
      }
  }
/*A-->C
A-->B
C-->B
A-->C
B-->A
B-->C
A-->C
avatar
文章
阅读
粉丝