一、什么是方法
1.简单来说方法就是一段可以被重复调用的代码块。对于一些复杂的代码，如果希望重复使用这些代码，做到随时都可以用，就把这些代码放在大括号({})中，自定义一个名字。需要使用这些代码时，使用这个名字调用就可以。
2.方法的语法格式
修饰符 返回值类型 方法名（[参数类型 参数名1，参数类型 参数名2，...]）{
执行语句
...
return 返回值;
}
- 1.
- 2.
- 3.
- 4.
- 5.
语法格式的具有说明：
修饰符：方法修饰符比较多,对访问权限进行限定的，现在阶段的有public static两个关键字。
返回值类型：方法最终的结果数据是什么类型。
方法名：自定义的名称，命名规则和变量一样。
参数类型：用在调用方法时传入的参数的数据类型。
参数名：是一个变量，用在接受调用方法传入的数据。
return关键字：结束方法的执行，并将这个返回值还给调用处。
返回值：方法最终的结果数据。
需要注意一点就是“参数类型 参数名1，参数类型 参数名2”这个是叫做参数列表，它的作用是方法被调用时需要接受的参数。如果方法不接受任何参数，参数列表就是空的。方法的返回值一定是方法声明的返回值类型，如果方法的返回值类型声明为void，说明方法没有返回值，这时return就可以省略掉。
3.定义一个求两个整数和方法：
代码如下所示：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
int add_num = sum(a,b);//调用sum方法
System.out.println(add_num);
}
//类的方法--定义一个求两个整数的和，接受两个参数n和m
public static int sum(int n, int m) {
int sum = n + m;
return sum;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
输出的结果是：
5
6
11
- 1.
- 2.
- 3.
从上面代码我们可以看出，接受用户输入的两个数a和b，定义一个方法求两个整数的和，分别用于接受调用方法的传入的n和m,把用户输入的a的值传给参数n，b的值传给参数m，定义一个int类型变量sum进行两个数的相加，通过return返回计算两个整数和相加。在main方法中，调用sum方法，获得两个整数的和的值，打印输出两个整数和的值。
二、方法的重载
1.同一个类中的两个或两个以上的方法可以有相同的名字，只要它们的参数声明不同即可，就是方法重载。
2.当一个重载方法被调用时，Java 根据参数的类型、参数的个数、参数的顺序来确定实际调用的是重载方法的哪一个版本，只有形式参数与调用参数相匹配的方法被执行。
3.通过一个小案例分析方法的重载：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
int add_num1 = sum1(a,b);//调用sum1方法
System.out.println("两个整数的和值"+add_num1);
int c = scan.nextInt();
int d = scan.nextInt();
int e = scan.nextInt();
int add_num2 = sum2(c,d,e);//调用sum2方法
System.out.println("三个整数的和值"+add_num2);
double x = scan.nextDouble();
double y = scan.nextDouble();
double z = scan.nextDouble();
double add_num3 = sum3(x,y,z);//调用sum3方法
System.out.println("三个小数的和值"+add_num3);
}
//sum1方法,求两个整数和的值接受两个参数,a和b
public static int sum1(int a, int b) {
int sum = a + b;
return sum;
}
//sum2方法,求三个整数和的值接受三个参数,c d e
public static int sum2(int c, int d,int e) {
int sum = c + d + e;
return sum;
}
//sum3方法,求三个小数和的值接受三个参数,x y z
public static double sum3(double x, double y, double z) {
double sum = x + y + z;
return sum;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
运行的结果是：
1
2
两个整数的和值3
1
2
3
三个整数的和值6
1.2
1.5
1.3
三个小数的和值4.0
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
从上面我们可以看出如果每个方法的名称都不相同，在调用方法就很难哪种情况去调用哪种方法，解决这个问题就用java的重载的方法。java允许定义多个名称相同的方法，但是它的参数类型和个数不同。把这个例子修改成java的方法重载:
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
int add_num1 = sum(a,b);//调用sum方法
System.out.println("两个整数的和值"+add_num1);
int c = scan.nextInt();
int d = scan.nextInt();
int e = scan.nextInt();
int add_num2 = sum(c,d,e);//调用sum方法
System.out.println("三个整数的和值"+add_num2);
double x = scan.nextDouble();
double y = scan.nextDouble();
double z = scan.nextDouble();
double add_num3 = sum(x,y,z);//调用sum方法
System.out.println("三个小数的和值"+add_num3);
}
//sum方法,求两个整数和的值接受两个参数,a和b
public static int sum(int a, int b) {
int sum = a + b;
return sum;
}
//sum方法,求三个整数和的值接受三个参数,c d e
public static int sum(int c, int d,int e) {
int sum = c + d + e;
return sum;
}
//sum方法,求三个小数和的值接受三个参数,x y z
public static double sum(double x, double y, double z) {
double sum = x + y + z;
return sum;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
我们可以发现方法重载它需要满足两个条件：
第一个是方法名一样;
第二个是参数类型或参数的个数不同。
三、方法递归
1.方法的递归简单而言一个方法内调用自己本身。
2.使用递归实现九九乘法表：
public static void main(String[] args) {
// TODO Auto-generated method stub
n(9);
}
public static void n(int i) {
if (i == 1) {
System.out.println("1*1=1 ");
} else {
n(i - 1);
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + j * i + " ");
}
System.out.println();
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
运行的结果如下所示：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
递归方法是怎么执行的呢?递归的方式调用如下所示：
n(9)
n(8)for(i=9)
n(7)for(i=8)
n(6)for(i=7)
n(5)for(i=6)
n(4)for(i=5)
n(3)for(i=4)
n(2)for(i=3)
n(1)for(i=2)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
四、总结
本文介绍了方法、方法的重载、方法的递归。介绍方法的格式，语法格式的具体说明通过一个求两个整数和的值案例来分析方法的用法。介绍方法重载是允许定义多个相同的方法名，但它的参数类型和参数个数需要不同。递归的方法是自己调用自己，通过一个九九乘法表了解递归方式的调用。希望大家通过本文的学习，能够帮助到你!
本文转载自微信公众号「 Java进阶学习交流 」，可以通过以下二维码关注。转载本文请联系 Java进阶学习交流 公众号。
