方法

1.方法的概念

(1).什么是方法

方法类似于C语言中的函数，我们重在体会与理解，不必去强硬地去背
1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子.

(2).方法的定义

我们最早见过的是main方法，我们可以把它作为C语言中的函数去理解
例如： 定义个main方法：

    public static void main(Sting[] args){}//public static（这两个东西不能省略掉） //void是指的是无类型的返回值， main是方法名，其后的括号中是形式参数列表所以我们应定义一个：public static 返回值 方法名(参数类型 形参){方法体代码return(返回值)}

在这里：我要先就关于大驼峰与小驼峰的命名方式先说一下
大驼峰：每个单词的首字母大写： 例如 DemoTest,MyClass
小驼峰：只有第一个单词的首字母大写，后续每个单词的首字母都大写，其余小写 例如：myFunction,userProfile等

示例：判断某年是不是闰年

public static boolean isLeapYear1(int year){if(0 == year % 4 && 0 != year % 100 || 0 == year %400){System.out.println(year + "是闰年");return true;//由于boolean类型，所以需要返回两个值}else{System.out.println(year + "不是闰年");return false;}
}public static void main(String[] args) {Scanner sc = new Scanner (System.in);int year = sc.nextInt();isLeapYear1(year);sc.close();}

注意事项：
1. 修饰符：现阶段直接使用public static 固定搭配
2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
void
3. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
4. 方法体：方法内部要执行的语句
5. 在java当中，方法必须写在类当中，不能嵌套定义
6. 在java当中，没有方法声明一说，声明必须要在主函数之前，所以我们可以不用在意
7. 一个方法可以多次去调用
示例：

public static void main9(String[] args) {boolean flg1 = isLeapYear3(2025);//2025是实际参数System.out.println(flg1);boolean flg2 = isLeapYear3(2024);//2025是实际参数System.out.println(flg2);
}public static boolean isLeapYear3(int year) {//int year是形式参数if (0 == year % 4 && 0 != year % 100 || 0 == year % 400) {return true;//由于boolean类型，所以需要返回两个值} else {return false;}}  

(3).实参与形参的关系

import  java.util.Scanner;
public static int func1(int x) {int ret = 1;for (int j = 1; j <= x; j++) {ret *= j;}return ret;
}public static void main1(String[] args) {Scanner sc = new Scanner(System.in);int a = sc.nextInt();int ret = func1(a);System.out.ptrintln(ret);
}        

在Java中，实参的值永远都是拷贝到形参之中，形参和实参本质是两个实体。
但是两者的栈帧并不一样，都是在一个栈空间（虚拟机栈）中，但是所处的区域不同

//老生常谈的例子
//交换变量
//正常版：public static void main2(String[] args){int a = 10;int b = 20;int temp = 0;temp = a;a = b;b =temp;System.out.println(a + " " + b);}//方法版public static void swap4(int x ,int y) {int temp = 0;temp = x;x = y;y =temp;}//当这个方法走完，那么也就是把x和y的变量的值进行交换完成。//但是也只是把它们被赋予的值进行交换完成//对于a和b的本身没有任何影响public static void main3(String[] args){int a = 10;int b = 20;//a和b的局部变量//作用域：在方法中//生命周期：调用方法的创建，方法调用结束的时候来销毁//内存：储存在栈上//Java中由于其安全性，不会让你拿到局部变量的地址System.out.println("交换前"+ a + " " + b);//swap(a,b);System.out.println("交换后"+ a + " " + b);}

就目前来看，学完类和对象才能知道怎么交换,Java中没有指针这一个概念；
但是有引用这一个概念，“引用”叫做引用变量；引用变量中存入的是地址。
数组就是一个引用变量
当一个方法没有返回值，所以我们就要用void类型来接收

2.方法重载

(1).方法重载的概念

在Java中如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

//    public static int addInt(int x,int y){
//        return x + y;
//    }
//
//    public static double addDouble (double x,double y){
//        return x + y;
//    }//这时候方法里的名字不一样，所以我们可以创建新的方法名从而计算。//当然这不是方法重载public static void main(String[] args) {Scanner sc = new Scanner(System.in);int a = sc.nextInt();int b = sc.nextInt();
//        System.out.println(addInt(a, b));//System.out.println(add(a, b));double c1 = sc.nextDouble();double c2 = sc.nextDouble();
//        System.out.println(addDouble(c1,c2));//System.out.println(add(c1,c2));sc.close();}public static int add(int x,int y){return x + y;}public static double add(double x,double y){return (int)(x + y);//这么做强制转化，如果仅仅是返回值不同，这种仅有返回值改变，那么这就不叫做方法重载}//这部分方法的操作叫做重载，只有一个名字都是add

方法重载：
1.方法名相同
2.参数列表不同【数据类型，变量个数，顺序】
3.返回值不影响重载

3.递归（C语言详细讲过）

必要条件：
1.将原问题转为多个子问题，（子问题必须要与原问题解法相同）
2.递归出口

public static int func(int n){if(n == 1 || n == 0){return 1;}int ret = n * func(n-1);return ret;}public static void main5(String[] args) {Scanner in = new Scanner(System.in);int n = in.nextInt();System.out.println(func(5));}    

调用栈：
方法调用的时候，会有一个“栈”这样的内存空间描述当前的调用关系，称为调用栈.
每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息.

按顺序打印1 2 3 4

public static void print (int n){if(n > 9){print(n / 10);}//当n为一个数时，那么可以直接打印System.out.print(n % 10 + " ");}public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();print(n);}

求斐波那契数列第N项数

public static int funca(int n) {/*if(n <= 2)*/if(n == 1 || n == 2){return 1;//这两种写法均可以}else {return  funca(n - 1) + funca(n - 2);}
}public static void main8(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();System.out.println(funca(n));}

这个代码不适合用递归去写，程序执行速度极慢. 原因是进行了大量的重复运算.

//迭代写法
public static long funcaA(long n){long a = 1;long b = 1;long c = 1;while(n > 2){c = a + b;a = b;b = c;n--;}return c;}public static void main(String[] args) {Scanner sc = new Scanner(System.in);long n = sc.nextInt();System.out.println(funcaA(n));}//后续：在二叉树我们经常需要使用递归去解决问题```
好了，今天我们就分享到这里了，如果有什么不足，劳烦大家帮忙在评论区指出，谢谢大家了！让我们下一次见！