作者简介: 博主在读计科双非本科，目前大二，正在学习JAVA，数据库，操作系统，计算机网络，数据结构，JAVA Web等…
个人主页：熬夜磕代码丶
作品专栏: java se
我变秃了，也变强了
给大家介绍一款程序员必备刷题平台——牛客网
点击注册一起刷题收获大厂offer吧

一、什么是方法？

java方法是语句的集合，他们在一起执行一个功能。
1.方法是解决一切问题的步骤的有序组合
2.方法包含于类或对象中
3.方法在程序中被创建，在其他地方被引用

代码如下（示例）：

public static int max(int x,int y) {
        return x > y ? x : y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = max(a,b);
        System.out.println(ret);
    }
1
2
3
4
5
6
7
8
9

在这里我们简单的实现一下求两个数的最大值，将它封装成一个方法，需要的时候直接调用即可，因为这里是一个简单的求最大值显示不出来多大的优势，但当我们需要执行的一个方法是几千行代码，甚至更多，要是每次使用的时候都要写一遍，效率大大的低下，这里我们就可以封装成一个方法，一次写入，多次调用。

二、方法的调用

java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
修饰符 返回值类型 方法名（参数类型 参数名）{
…
方法体
…
return 返回值;
}

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

方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void

public static void print() {
        System.out.println("woyaojindachang");
    }
    public static void main(String[] args) {
        print();
    }
1
2
3
4
5
6

在这里我们不需要返回值，即返回值类型设置为void.

我们来探讨一下实参和形参的关系

在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体

public static void swap(int x,int y) {
        int h = x;
        x = y;
        y = h;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("交换前: a="+a+" b="+b);
        swap(a,b);
        System.out.println("交换后: a="+a+" b="+b);
    }
1
2
3
4
5
6
7
8
9
10
11
12

在执行完swap方法后，a,b的值仍未发生变化.

因此：实参a和b 与 形参x和y是两个没有任何关联性的变量，
在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b产生任何影响

三、方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法重载的规则：
1.方法名称必须相同
2.参数列表必须不同（个数不同，或类型不同，参数排列顺序不同）
3.方法的返回值类型可以相同也可以不相同
4.仅仅返回值类型不同不足以成为方法的重载

public static int max(int x,int y) {
        return x > y ? x : y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = max(a,b);
        System.out.println(ret);
    }
1
2
3
4
5
6
7
8
9

还是以求两个数的最大值为例，这里max方法是求两个整数最大值，那如果是两个double类型的数据呢？

public static double maxDouble(double x,double y) {
        return x > y ? x : y;
    }
1
2
3

这样可以实现double求最大值,但是每种不同的类型就要取不同的名字，这样十分的繁琐.
在java当中引入了一种新特性:方法的重载.

public static double max(double x,double y) {
        return x > y ? x : y;
    }
public static int max(int x,int y) {
        return x > y ? x : y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = max(a,b);
        System.out.println(ret);
        double m = max(1.0,2.0);
        System.out.println(m);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

为什么我们的类中可以存在相同方法名的方法呢？

我们查看下上述代码的反汇编代码，具体:

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

四、递归

递归就是：
1.A方法调用A方法，自己调用自己。
2.递归的能力在于用有限的语句来定义对象的无限集合。
3.递归结构包含两个部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体：什么时候需要调用自身方法。

代码如下（示例）：

//求4的阶乘
public static int factor(int n) {
        if(n == 1) {
            return 1;
        }
        return n * factor(n-1);
    }
    public static void main(String[] args) {
        int ret = factor(4);
        System.out.println(ret);
    }
1
2
3
4
5
6
7
8
9
10
11

这里可以得到4的阶乘，那背后的原理是什么呢?

递归练习1:

递归求解汉诺塔问题

public static void hanio(int n,char pos1,char pos2,char pos3) {
    if(n==1) {
        move(pos1,pos3);
        return ;
    }
    hanio(n-1,pos1,pos3,pos2);
    move(pos1,pos3);
    hanio(n-1,pos2,pos1,pos3);
}
public static void move(char pos1,char pos2) {
    System.out.print(pos1+"->"+pos2+" ");
}
public static void main(String[] args) {
    //汉诺塔问题
    hanio(3,'A','B','C');
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

递归练习2:

递归求斐波那契数列的第 N 项

public static int fib(int n) {
    if(n<=2){
        return 1;
    }
    return fib(n-1)+fib(n-2);
}
public static void main(String[] args) {
    //递归求斐波那契数列int ret = fib(5);
    System.out.println(ret);
}
1
2
3
4
5
6
7
8
9
10

递归练习3:

递归打印数字的每一位

public static void print(int n) {
    if(n<10) {
        System.out.println(n);
        return;
    }
    print(n/10);
    System.out.println(n%10);
}
public static void main(String[] args) {
    //打印每一位print(1234);
}
1
2
3
4
5
6
7
8
9
10
11

递归练习4:

递归求和

public static int sum(int n) {
    if(n == 1){
        return 1;
    }
    return n+sum(n-1);
}
public static void main(String[] args) {
    //递归求和int ret = sum(10);
    System.out.println(ret);
}
1
2
3
4
5
6
7
8
9
10

总结

今天方法的学习就到这里了，大家暑假一定要卷起来，“读书破万卷”.