【JAVA】方法的使用

方法的使用

• 回顾复习
• 一、方法的提出
• 二、方法的概念以及应用
• • 1. 什么是方法
  • 2.方法定义
  • 3. 方法调用的执行过程
  • 4.形参和实参的关系（重要）
  • 5. 没有返回值的方法
• 三、 方法重载
• • 1. 为什么需要方法重载
  • 2. 方法重载概念
  • 3. 方法签名
• 四、递归
• • 1. 递归的概念
  • 2. 递归执行过程分析
  • 3. 递归练习
  • • 补充：经典汉诺塔问题
• THINK

---

回顾复习

向阳生长！

三种逻辑结构：顺序、选择、循环结构。

---

尽己所能

一、方法的提出

1. 编程时，某段功能的代码可能频繁使用到，则会出现以下不便：

1）使程序变得繁琐
2） 开发效率低下，做了大量重复性的工作
3） 不利于维护，需要改动时，所有用到该段代码的位置都需要修改
4）不利于复用

所以：将频繁使用的代码封装成"帖子"(方法)，需要时直接拿来链接(即方法名–方法的入口地址)使用即可

二、方法的概念以及应用 1. 什么是方法

1. 方法就类似于c语言的函数，封装了某一特定功能。
2. 方法的意义：

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

2.方法定义

1. 语法格式：

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

2. 注意事项

1） 修饰符：现阶段直接使用public static 固定搭配
2） 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
void
3） 方法名字：采用小驼峰命名
4） 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需 指定参数类型，多个参数之间使用逗号隔开
5） 方法体：方法内部要执行的语句
6） 在java当中，方法必须写在类当中
7）在java当中，方法不能嵌套定义
8） 在java当中，没有方法声明一说
（类中有方法，方法中定义变量）

3. 补充：

方法调用-函数传参时注意点：
1.参数个数匹配
2.参数类型
3.参数顺序

3. 方法调用的执行过程

1. 方法调用过程：
   调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下
   执行
2. 注意事项

【注意事项】

• 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
• 一个方法可以被多次调用.

3. 补充：
   1）任何方法的调用都是在栈上开辟内存的
   2）方法使用完后栈帧内存释放
   3）方法都可以递归

4. 实例-求阶乘fac + 求和sum
   如：1！+2！+…+k!

• 代码：

import java.util.Scanner;

/**
 * 求阶乘fac + 求和sum
 * 如：1！+2！+…+k!
 */

public class FacSum {
    //阶乘
    public static int fac(int n) {
        int fac =1;
        if(n > 0) {
            for (int i = 1; i <= n ; i++) {
                fac *= i;
            }
        }
        return fac;
    }
    //和
    public static int sum(int n) {
        int sum =0;
            for (int i = 1; i <= n ; i++) {
                sum += fac(i);
            }
        return sum;
    }

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数：");
        int n = reader.nextInt();
        if(n >= 0) {
            System.out.print(n+"阶乘和：");
            System.out.println(sum(n));
        } else {
            System.out.println("输入错误！");
        }
    }
}

• 结果：
  

4.形参和实参的关系（重要）

1. 形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
2. 在java中，数据在栈上的 地址是拿不到 的–没有所谓的获取局部变量的地址
3. 形参是实参的临时拷贝（相当于传值调用），是两个不同的实体
4. 实例-交换两个整型变量
   （需要传入数组进行实现）–此时先了解一下即可

• 代码：

/**
 * 交换两个数
 */

public class Swap {
        public static void main(String[] args) {
            int[] arr = {10, 20};
            System.out.println("交换前："+"arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
            swap(arr);
            System.out.println("交换后："+"arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
        }
        public static void swap(int[] arr) {
            int tmp = arr[0];
            arr[0] = arr[1];
            arr[1] = tmp;
        }
}

• 结果：
  

5. 没有返回值的方法

1. 方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void
2. 如：判断素数的方法用boolean类型返回–true or false

三、 方法重载 1. 为什么需要方法重载

• 方法同命不同参
• 编译器记住一个方法名就好

2. 方法重载概念

1. 概念：在Java中，如果多个方法的名字相同，参数列表不同，则称该方法被重载了
2. 注意：

• 方法重载：
  1.方法名相同
  2.形参列表不同
  3.返回值不做要求，可以一样也可以不一样（即：与返回值类型无关）

3. 形参不同–类型、个数、顺序
   试一下：两个形参字母不同、顺序不同

• 结果：若形参的类型相同，则字母以及顺序不构成方法重载
  

4. 面试题：重载和重写的区别？
   重载：overload
   重写：override–继承讲到

3. 方法签名

1. 概念：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。
2. 代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体 *** 作：
   1） 先对工程进行编译生成.class字节码文件
   2） 在控制台中进入到要查看的**.class所在的目录**
   3）按住shift打开PowerShell窗口输入
   4） 输入：javap -v 字节码文件名字即可
3. 如：add:(II)I （前面有路径名）
   方法名（形参列表：形参类型及个数）返回值类型
4. 方法签名中的一些特殊符号说明：
   

四、递归 1. 递归的概念

1. 概念：一个方法在执行过程中调用自身, 就称为 “递归”.
2. 递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
3. 递归条件：
   1） 一定要有一个趋近于终止的条件
   在方法内部，自己调用自己–可能会存在栈溢出-方法在栈上开辟内存
   （so：递归要能够结束，有结束条件–return or sout）
   2）将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
4. 递归求n的阶乘
   （递推公式：fac(n）= n * fac(n-1)😉
   -代码：

import java.util.Scanner;

/**
 * 如：求阶乘 n!=n*(n-1)!
 */
public class Fac {
    public static int fac(int n) {
        if(n > 0) {
            if(n == 1) {
                return 1;
            }
            return n*fac(n-1);
        } else if(0 == n) {
            return 1;
        } else {
            return -1;
        }
    }

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数n：");
        int n = reader.nextInt();
        int ret = fac(n);
        if(ret > 0) {
            System.out.println(n+"的阶乘："+ret);
        } else {
            System.out.println("输入错误！");
        }
    }
}

-结果：

2. 递归执行过程分析

1. 过程分析：
   递归–
   传递：从前往后
   归来：从后往前
2. 以上述求n的阶乘为例：
   
3. 关于 “调用栈”

• 方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系. 称为调用栈.
• 每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息.
  后面我们借助 IDEA 很容易看到调用栈的内容.

3. 递归练习

1. 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

• （注意：书写顺序会影响打印顺序）
• 代码：

import java.util.Scanner;

/**
 * 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)
 * 模10 除10
 * 小于10就打印
 */

public class PPrint {
    public static void print1(int n) {
        //注意顺序！！ 打印在后面才行！！！
        //先print（n/10）--报错
        if(n > 10) {
            print1(n/10);
        }
        System.out.print(n%10+" ");
    }

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

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数n：");
        int n = reader.nextInt();
        System.out.println("每一位如下打印（正向）");
        print1(n);
        System.out.println();
        System.out.println("每一位如下打印（反向）");
        print2(n);
    }
}

• 结果：
  

2. 递归求 1 + 2 + 3 + … + n

• 要求1~n的和相当于求：n+sum（n-1)
  -代码：

import java.util.Scanner;

/**
 * 递归求 1 + 2 + 3 + ... + n
 * n+sum(n-1)
 */
public class Sum {
    public static int sum(int n) {
        if(n == 1) {
            return 1;
        }
        return (n + sum(n-1));
    }

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数n：");
        int n = reader.nextInt();
        int sum = sum(n);
        System.out.print("1~"+n+"的和："+sum);
    }
}

-结果：

3. 写一个递归方法，输入一个非负整数，返回组成它的数字之和.
例如，输入 1729, 则应该返回1+7+2+9，它的和是19

• key: 确定每一位数字 (模10 除10)
  只有一位数字时结束
• 求和：n%10 + fun(n/10);
• 代码：

import java.util.Scanner;

/**
 * 写一个递归方法，输入一个非负整数，返回组成它的数字之和.
 * 例如，输入 1729, 则应该返回1+7+2+9，它的和是19
 */
public class NoSum {
    public static int sum(int n) {
        if(n >= 0) {
            if(n < 10) {
                return (n%10);
            }
            return ((n%10) + sum(n/10));
        } else {
            return -1;
        }
    }

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数n：");
        int n = reader.nextInt();
        int sum = sum(n);
        if(sum >= 0) {
            System.out.print("1~"+n+"的和："+sum);
        } else {
            System.out.println("输入非法！");
        }
    }
}

• 结果：
  

4. 求斐波那契数列的第 n 项

• 除第一二个数字外：fib(n) = fib(n-1) + fib(n-2)
• 递归方法
  -代码：

import java.util.Scanner;

/**
 * 求斐波那契数列的第 n 项
 * 递归： 1 1 fib(n) = fib(n-1)+fib(n-2);
 */

public class DFib {
    public static int count =0; //静态成员变量
    public static int dFib(int n) {
        if(n > 0 ) {
            if((1 == n) || (2 == n)) {
                return 1;
            }

            if(n == 3) { //fib(3)运算次数
                count ++;
            }
            
            return (dFib(n-1) + dFib(n-2));
        } else {
            return -1;
        }
    }

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数n：");
        int n = reader.nextInt();
        int dFib = dFib(n);
        if(dFib >= 0) {
            System.out.printf("fib(%d) = %d\n",n,dFib);

            //静态成员变量调用--类名.静态成员变量
            System.out.println("fib(3)运算次数："+DFib.count);
        } else {
            System.out.println("输入非法！");
        }
    }
}

-结果：

BUT：斐波那契数列不适合用递归–重复计算次数过多，运算效率太低
（类似二叉树的递归方式 先左边计算完成再计算右边）

• 循环完成（迭代）
  -代码：

import java.util.Scanner;

/**
 * 迭代求斐波那契数列--循环
 */
public class Fib {
    public static int fib(int n) {
        if(n > 0) {
            if((1==n)||(2==n)) {
                return 1;
            }

            int fib1 = 1;
            int fib2 = 1;
            int fib3 = 0;

            for (int i = 3; i <= n; i++) {
                fib3 = fib1 + fib2;
                fib1 = fib2;
                fib2 = fib3;
            }
            return fib3;
        } else {
            return -1;
        }
    }

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("请输入任意整数n：");
        int n = reader.nextInt();
        int fib = fib(n);
        if(fib >= 0) {
            System.out.printf("fib(%d) = %d\n",n,fib);
        } else {
            System.out.println("输入非法！");
        }
    }
}

-结果：

补充：经典汉诺塔问题

（C语言类型的可参考【汉诺塔】）

---

THINK

回顾复习：
1.方法由几部分组成:
public static（修饰符）返回值方法名（参数列表-形参）{
方法体； //对某个功能的抽象
}
2.方法的调用–参数匹配：类型、个数、顺序
3.所有的方法调用是在栈上开辟内存–先为main方法开辟内存，然后再依次为出现的方法开辟内存，方法调用结束后该内存被回收销毁
4.局部变量在方法内部，作用域只在当前方法里面{}；生命周期：方法调用开始创建到调用结束销毁