方法的基本用法
方法定义
方法就是一个功能
方法就是一个代码片段，类似于 C 语言中的 “函数”
基本语法格式：
|
1
2
3
4
5
|
//方法定义
修饰符 返回值类型 方法名称([形式参数列表 ...]){
方法体;
[return 返回值];
}
|
注意事项：
在现阶段，方法的修饰暂时采用—> public static 固定搭配[ ]内部的表示可有可无方法必须定义在类中方法名要采用小驼峰的形式Java中的返回值可有可无，看业务需求，若有返回值，返回值类型需要和方法的返回值类型匹配行书参数列表：形参，是实参的一份拷贝方法体：具体功能的实现
为什么方法一般用public static修饰？
因为当前所有方法写完之后，若调用，都会在main方法中调用，而main方法是public static的
代码示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class DemoOne {
// 实现一个两个整数相加的方法
public static int add(int x,int y){
return x+y;
}
public static void main(String[] args) {
int a = 212;
int b = 454;
//方法调用
int ret = add(a,b);
System.out.println(ret);
}
}
|
注意事项：
- 方法定义时，参数可以没有，若有参数，每个参数要指定类型
- 方法定义时，返回值也可以没有，比如main方法，如果没有返回值，则返回值类型必须写成 void
- 方法定义不能嵌套
- Java 中没有 “函数声明” 这个概念
- 方法必须定义在类之中，方法定义的位置在调用位置的上方或者下方均可
方法调用的调试过程
一个程序猿最厉害的不在于能写出多牛X的代码，而是能够解决代码的问题！！
IDEA 的调试过程：
打断点
开始调试，点击"甲壳虫"
点击后，会出现下边这个框
注意事项：
- 参数传递完毕后，就会执行到方法代码体
- 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行
- 一个方法可以被多次调用
- (遇到 return ) 方法执行完毕后，回到方法调用位置继续执行
- 当方法被调用时，会将实参赋值给形参
- Java中只有按值传递
暂停调试
方法的重复调用：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
//求三个数的最大值
public static int maxThreeNum(int num1,int num2,int num3){
return maxNum(maxNum(num1,num2),num3); //方法的重复调用
}
//两个数的最大值
public static int maxNum(int x,int y){
return x>y ? x : y;
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num1 = scan.nextInt();
int num2 = scan.nextInt();
int num3 = scan.nextInt();
int max = maxThreeNum(num1,num2,num3);
System.out.println("max="+max);
}
|
实参和形参的关系
形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值
代码示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
交换两个整型变量
public static void swap(int x,int y){
int tmp = x;
x = y;
y = tmp;
}
public static void main(String[] args) {
//交换两个整数
int a = 10;
int b = 20;
swap(a,b);
System.out.println(a + " " + b);
}
|
运行后会发现，这个方法不能实现交换两个整型变量的功能
可用类和对象 / 数组 来实现，后边会讲到
原因分析：
方法里交换的是形参 x 和 y 的值，而main方法中打印的是实参 a 和 b 的值
实参a和b是main方法中的两个变量，其空间在main方法的栈(一块特殊的内存空间)中，而形参x和y是swap方法中的两个变量，x和y的空间在swap方法运行时的栈中，因此：实参a和b 与 形参x和y是两个没有任何关联性的变量，在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b产生任何影响。
解决方法：
这里不过多解释，之后写数组章节再作解释
|
1
2
3
4
5
6
7
8
9
10
|
public static void main(String[] args) {
int[] arr = {10, 20};
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;
}
|
结论：
- 在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体
- 对于基础类型来说，形参相当于实参的拷贝，即：传值调用
方法的重载 (Overload)
什么是方法重载？
举例：
在方法sumInt中，若要求两小数之和，就不能实现，必须再写一个sumDouble方法，这样使用很不灵活
|
1
2
3
4
5
6
7
8
|
两整数之和
public static int sumInt(int x,int y){
return x+y;
}
两小数之和
public static double sumDouble(double x,double y){
return x+y;
}
|
解决方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
方法1 两整数之和
public static int sum(int x,int y){
return x+y;
}
方法2 两小数之和
public static double sum(double x,double y){
return x+y;
}
public static void main(String[] args) {
double a = 19.9;
double b = 18.8;
double ret = sum(a,b); //直接使用 sum
System.out.println(ret);
}
|
上述方法1 和方法2 的关系就是重载
构成重载的 3 个条件：
- 方法名必须相同
- 返回值可以不同
- 参数列表必须不同(参数的个数不同 / 参数的类型不同)
- (注意事项) 同一个类当中
重载和重写的区别是什么？
方法的重载和重写都是实现多态的方式，区别：重载实现的是编译时的多态性，而重写实现的是运行时的多态性
①.重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同 / 参数个数不同）则视为重载
②.重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常。
重载对返回类型没有特殊的要求，不能根据返回类型进行区分。
方法的递归
什么是递归？
一个方法在执行过程中对自身的调用，称为"递归"
- 方法要调用自己本身
- 要有一个趋近于终止的条件
- 想办法推导出"递归"的公式
递归代码示例：
求n的阶乘:
|
1
2
3
4
5
6
|
public static int factor(int n){
if(n == 1){
return 1;
}
return n * factor(n-1);
}
|
代码过程分析：
递归的理解
"递" "归"理解：
栈的角度理解：
方法的调用是要在栈上开辟内存的，给这个方法开辟栈帧
思考递归，要横向思考，不要试图去走进递归的代码，代码执行，是纵向执行
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注服务器之家的更多内容!
原文链接：https://blog.csdn.net/m0_47988201/article/details/119645025