互联学术方法的基本用法
方法定义
,方法就是一个功能
,
方法就是一个代码片段，类似于 C 语言中的 “函数”
基本语法格式：
//方法定义
修饰符 返回值类型 方法名称([形式参数列表 ...]){
方法体;
[return 返回值];
}
注意事项：
在现阶段，方法的修饰暂时采用—> public static 固定搭配[ ]内部的表示可有可无,方法必须定义在类中,方法名要采用小驼峰的形式,Java中的返回值可有可无，看业务需求，若有返回值，返回值类型需要和方法的返回值类型匹配行书参数列表：形参，是实参的一份拷贝方法体：具体功能的实现
为什么方法一般用public static修饰？
因为当前所有方法写完之后，若调用，都会在main方法中调用，而main方法是public static的
代码示例：
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中只有按值传递
暂停调试
方法的重复调用：
//求三个数的最大值
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);
}
🔺实参和形参的关系
形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值
代码示例：
交换两个整型变量
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产生任何影响。
解决方法：
这里不过多解释，之后写数组章节再作解释
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方法，这样使用很不灵活
两整数之和
public static int sumInt(int x,int y){
return x+y;
}
两小数之和
public static double sumDouble(double x,double y){
return x+y;
}
解决方法：
方法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的阶乘:
public static int factor(int n){
if(n == 1){
return 1;
}
return n * factor(n-1);
}
代码过程分析：
递归的理解
“递” “归”理解：
栈的角度理解：
方法的调用是要在栈上开辟内存的，给这个方法开辟栈帧
思考递归，要横向思考，不要试图去走进递归的代码，代码执行，是纵向执行
