【0 基础学 Java】（七）方法

作者: 不会编程的程序圆 | 来源:发表于2020-06-11 14:44 被阅读0次

码字不易，对你有帮助 点赞/转发/关注 支持一下作者

微信搜公众号：不会编程的程序圆

看更多干货，获取第一时间更新

看更多示例和代码： https://github.com/hairrrrr/EasyJava，欢迎 star

正文

一方法的基本使用

1.1 什么是方法

方法就是一个代码片段，类似 C 语言的“函数”。

1.2 方法定义语法

基本语法

// 方法定义
public static 方法返回值类型 方法名称（参数类型 形参 ...){
方法体代码;
return 返回值;
}
// 方法调用
返回值变量 = 方法名称(实参...);

例1：实现一个方法实现两个整数相加

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 方法的调用
        int ret = add(a, b);
        System.out.println("ret = " + ret);
}
// 方法的定义
    public static int add(int x, int y) {
        return x + y;
    }
}
// 执行结果
ret = 30

注意：

public 和 static 两个关键字在此处具有特定含义, 我们暂时不讨论, 后面会详细介绍
方法定义时, 参数可以没有. 每个参数要指定类型
方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
方法定义时的参数称为 "形参", 方法调用时的参数称为 "实参"。参数数量需要匹配。
方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可
Java 中没有 "函数声明" 这样的概念

例2：方法写在调用它的函数的上方或下方都是可以的

方法写在 main 函数上方

public class helloWorld{
            
    public static int addSum(int a, int b){
        
        return a + b;
    }
    
    public static void main(String[] args) {
        
        int a = 10, b = 20;
        int ret = addSum(a, b);
        System.out.println("sum = " + ret);
        
    }       
}

方法写在 main 函数下方

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

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

以上两种写法都是可以的。

练习：

写一个方法比较两个数的最大值
写一个方法比较三个数的最大值

参考答案：

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        int max = threeNumMax(a, b, c);
        System.out.printf("Max = %d", max);
    }
    
    public static int threeNumMax(int x, int y, int z) {
        
        int max = twoNumMax(twoNumMax(x, y), z);
        //twoNumMax(a,b)返回 a，b 中的较大值，然后再次调用twoNumMax比较 这个较大值 与 c
        return max;
    }
    
    public static int twoNumMax(int x, int y) {
        return (x > y ? x : y);
    }
}

1.3 方法调用的执行过程

基本规则

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

class Test {
    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;
}
}
// 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

例 3: 计算 1！ + 2！+ 3！+ 4！+ 5！

Class Test {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
        sum += factor(i);
        }
        System.out.println("sum = " + sum);
    }
    public static int factor(int n) {
        System.out.println("计算 n 的阶乘中! n = " + n);
        int result = 1;
        for (int i = 1; i <= n; i++) {
        result *= i;
        }
        return result;
    }
}
// 执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153

1.4 实参和形参的关系

例4：交换两个整型变量

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("a = " + a + " b = " + b);
    }
    public static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
    }
}
// 运行结果
a = 10 b = 20

分析

刚才的代码，没有完成数据的交换。

对于基础类型来说，形参相当于实参的拷贝，即 传值调用。

上面的代码相当于：

int a = 10;
int b = 20;

int x = a;
int y = b;
int tmp = x;
x = y;
y = tmp;

上面的方法实际上就是创建了 x，y 两个临时变量（形参），将 a，b（实参）的值传给 x，y。然后创建临时变量 tmp 交换的是 x，y 的值。

解决办法：传引用类型参数（后面会讲）

1.5 没有返回值的方法

方法的返回值是可选的，有些时候可以没有的。

代码示例

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //没有变量接收 print 方法的返回值，因为它没有返回值
        print(a, b);
    }
    public static void print(int x, int y) {
        System.out.println("x = " + x + " y = " + y);
    }
}

例5：没有返回值的方法可能是有“缺陷”的

没有返回值：

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        addSum(a, b);
    }
    public static void addSum1(int x, int y) {
        System.out.println("a + b = "+ (x + y));
    }
}
//输出
a + b = 30

有返回值：

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = addSum(a, b);
        System.out.printf("%d + %d = %d, 2 * (%d + %d) = %d", a, b, ret, a, b, 2*ret);
    }
    public static int addSum2(int x, int y) {
        return x + y;
    }
}
//输出：
10 + 20 = 30, 2 * (10 + 20) = 60

可以看到，对于没有返回值的方法来说，addSum1 仅仅是讲参数相加然后输出而已；而 addSum2 将计算结果返回， main 函数拿到了计算结果，可以做更多的操作（比如示例种的运算），当然也可以输出。

void 类型的函数可以 return 吗？

class Test {
    public static void main(String[] args) {
    testVoidReturn();
}
    public static void testVoidReturn(){
        return;
        System.out.println("return 是没有什么用的！");
    }
}
//编译报错：
Test.java:9: 错误: 无法访问的语句
                System.out.println("return 是没有什么用的！");
                ^
1 个错误

二方法的重载

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

2.1 方法重载要解决的问题

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
    public static int add(int x, int y) {
        return x + y;
    }
}
// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);
                    ^

由于参数类型不匹配, 所以不能直接使用现有的 add 方法。

2.2 使用重载

对于上面的问题，下面这种方法是否可行？

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = addInt(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = addDouble(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
    public static int addInt(int x, int y) {
        return x + y;
    }
    public static double addDouble(double x, double y) {
        return x + y;
    }
}

重新命名一个新的方法来实现对不同类型的变量的相加。但是 Java 是支持方法重载的。我们一般使用下面的方式：

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
        double a3 = 10.5;
        double b3 = 10.5;
        double c3 = 20.5;
        double ret3 = add(a3, b3, c3);
        System.out.println("ret3 = " + ret3);
}
    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;
    }
    
}

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数字相加.
同一个方法名字, 提供不同版本的实现, 称为 方法重载

2.3 方法重载的规则

针对同一个类:

方法名相同

方法的参数不同(参数个数或者参数类型)

方法的返回值类型不影响重载(与 C++ 不同)

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(int x, int y) {
        return x + y;
    }
}
// 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
                            ^
1 个错误

当两个方法的名字相同，参数也相同，但是返回值不同的时候，不构成重载。

三方法递归

3.1 递归的概念

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

public static void main(String[] args) {
    int n = 5;
    int ret = factor(n);
    System.out.println("ret = " + ret);
}
    public static int factor(int n) {
        if (n == 1) {
            return 1;
        }
        return n * factor(n - 1); // factor 调用函数自身
}
// 执行结果
ret = 120

3.2 递归执行过程

public static void main(String[] args) {
    int n = 5;
    int ret = factor(n);
    System.out.println("ret = " + ret);
}
public static int factor(int n) {
    System.out.println("函数开始, n = " + n);
    if (n == 1) {
        System.out.println("函数结束, n = 1 ret = 1");
    return 1;
}
    int ret = n * factor(n - 1);
    System.out.println("函数结束, n = " + n + " ret = " + ret);
    return ret;
}
// 执行结果
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

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

3.3 递归练习

1. 按顺序打印一个数字的每一位

(例如 1234 打印出 1 2 3 4)

方法1：

    public static void printEveryDigit(int num){
        
        if(num / 10 == 0){
            System.out.print(num);
        }
        else{
            printEveryDigit(num / 10);
            System.out.print(" " + num % 10);
        }
    }
}

方法2：

public static void print(int num) {
        if (num > 9) {
            print(num / 10);
        }
        System.out.println(num % 10);
    }

2.递归求 1 + 2 + 3 + ... + 10

class Test {
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        int sum = printSum(num);
        System.out.println(sum);
}
    public static int printSum(int num) {
        if(num == 1){
            return 1;
        }
        return num + printSum(num - 1); 
    }
}

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

class Test {
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int num = scan.nextInt();
    int sum = printSumOfDigit(num);
    System.out.println(sum);
}
    public static int printSumOfDigit(int num) {
        if(num > 9){
            return (num % 10) + printSumOfDigit(num / 10);
        }
        return num; 
    }
}

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

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

3.4 递归小结

递归是一种重要的编程解决问题的方式.

有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易.

有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效.

【0 基础学 Java】（七）方法

目录

正文

一方法的基本使用

1.1 什么是方法

1.2 方法定义语法

基本语法

例1：实现一个方法实现两个整数相加

注意：

例2：方法写在调用它的函数的上方或下方都是可以的

练习：

1.3 方法调用的执行过程

基本规则

例 3: 计算 1！ + 2！+ 3！+ 4！+ 5！

1.4 实参和形参的关系

例4：交换两个整型变量

分析

1.5 没有返回值的方法

例5：没有返回值的方法可能是有“缺陷”的

void 类型的函数可以 return 吗？

二方法的重载

2.1 方法重载要解决的问题

2.2 使用重载

2.3 方法重载的规则

三方法递归

3.1 递归的概念

3.2 递归执行过程

3.3 递归练习

1. 按顺序打印一个数字的每一位

2.递归求 1 + 2 + 3 + ... + 10

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

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

3.4 递归小结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

【0 基础学 Java】（七）方法

目录

正文

一 方法的基本使用

1.1 什么是方法

1.2 方法定义语法

基本语法

例1：实现一个方法实现两个整数相加

注意：

例2：方法写在调用它的函数的上方或下方都是可以的

练习：

1.3 方法调用的执行过程

基本规则

例 3: 计算 1！ + 2！+ 3！+ 4！+ 5！

1.4 实参和形参的关系

例4：交换两个整型变量

分析

1.5 没有返回值的方法

例5：没有返回值的方法可能是有“缺陷”的

void 类型的函数可以 return 吗？

二 方法的重载

2.1 方法重载要解决的问题

2.2 使用重载

2.3 方法重载的规则

三 方法递归

3.1 递归的概念

3.2 递归执行过程

3.3 递归练习

1. 按顺序打印一个数字的每一位

2.递归求 1 + 2 + 3 + ... + 10

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

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

3.4 递归小结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

一方法的基本使用

二方法的重载

三方法递归