一、方法
1、方法的概念
将一个功能抽取出来，放在类中的大括号中，形参一个独立的功能，当需要使用它时，直接调用它，这样可以增强代码的复用性（重复利用），并解决代码冗余现象。
Java方法是语句的集合，它们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
2、设计方法的原则
方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展
3、方法的语法
【访问修饰符】返回值类型 方法名（【参数类型 参数名1，参数类型 参数名2.....】）{
方法体
}
详解：
访问修饰符：用于修饰这个方法的调用范文 目前默认public static
返回值类型：无返回值就写void 或者 方法执行后返回的结果的数据类型，方法执行完之后会将结果返回
方法名：给方法起名，遵循标识符的规则
参数类型、参数名：它们是同时定义，方法在执行时未知的数据，需要在调用方法时进行传递值，参数类型表示这个参数的数据类型，参数名就是这个参数的名称，这个参数名称可以在方法体中使用
方法体：这个方法具有的功能（代码块）
定义一个方法
public static int add（int num1，int num2）{
return num1+num2；
}
4、方法的分类
根据方法的参数不同，返回值不同，可以将方法分为四类：
1、无参无返回值方法
语法
public static void 方法名（）{
方法体
}
2、无参有返回值方法
语法
public static void 返回值类型 方法名（）{
方法体
}
/**
* 定义无参有返回值，需要先指定 这个返回值的数据类型
* 生成一个100以内的随机整数
*/
public static int getRandomNum(){
System.out.println("生成随机数");
int num = (int)(Math.random()*100);
return num; //注意 返回值类型 必须与定义的数据类型一致
}
public static void main(String[] args) {
//调用有返回值类型
//（返回值可以接受，也可以不接受，一般建议接受）
int n=getRandomNum();
System.out.println(n);
}
// 结果在n中
3、有参无返回值方法
语法：
public static void 方法名（参数列表）{
方法体
}
情况一：当参数中是基本数据类型，将实参的值赋值给形参
public static void add(itn num){
num++;
System.out.println("方法中num的值："+num);
}
调用方法：num的改变不会改变n的值，因为是两个独立的内存
int n = 10;
System.out.println(n);
add(n);
System.out.println("方法外面 实参的值："+n)；
结果输出：
方法中num的值：11
方法外面实参的值：10
情况二：当参数的数据类型是引用数据类型
例如：数组
//方法的比对 参数的数组
public static void add(int [] arr){
arr[0]++;
System.out.println("方法中aar[0]="+aar[0]);
}
调用：
int [] array = {10,20};
add(array);//会调用 参数是数组的add方法
System.out.println("方法外面的arr【0】"+array[0]);
结果：
方法中arr[0]=11
方法外面的arr[0]=11
例如：类的调用
public static void addAge(Stdent studen){
//将学生的年龄 获取 自加
int age = student.age;
age++;
// 在重新赋值
student.age=age;
}
调用：
Student student = new Student(); //age默认为 18
System.out.println("方法调用之前："+student.age);//18
addAge(student);// 传送的地址
System.out.println("方法外面 学生的年龄："+student.age);
结果输出： 方法调用之前： 18
方法外面 学生的年龄：19
/**
* 以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，
* 也就是说 参数再传递时，将引用类型的地址赋值给 方法的形参
* 对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变
* 不会影响实参的值
* 原因： 引用数据类型在参数传递时 是地址 （JVM对于堆内存的大小不可控）
* 基本数据类型在参数传递时 是值
*
*/
情况三：当参数是String类型时，String是引用数据类型，但是在参数传递时，与基本类型一样
public static void main(String[] args){
//参数是字符串
String uname = “李四”；
sayHello（uname）；
System.out.println("我最后对："+uname+"sayHello");
}
public static void sayHello(String name){
name= "张三"；
System.out.println("我对"+name+"sayHello")；
}
结果： 我对张三sayHello
我最后对李四sayHello
4、有参有返回值方法
语法：
public static 返回值类型 方法名（参数列表）{
方法体
}
例如：
public static String sayHello(String name){
name="张三";
System.out.println("我对"+name+"sayHello");
return name ;
}
调用：
public static void main(String[] args) {
// 参数是字符串
String uname ="李四";
// 将返回值接收 ，这是 uname 才被改变 ，如果不接受，则不改变
uname = sayHello(uname);
System.out.println("我最后对"+uname+"sayHello");
}
结果：
我对张三sayHello
我最后对张三sayHello
5、方法的调用
如果方法体中需要一些位置的数据作为执行条件，那么这些数据可以作为参数
如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型
方法调用两种方式：
- 对象名 方法名（参数）
- 直接写方法名调用，但必须是static修饰的
//获取这个字符串的第一个字符
public void method1(String str){
//返回字符串的第一个字符
return str。charAt（0）；
}
//调用方法
对象名.method1()
//调用静态方法 （static修饰的）
String s = "abc";
char c = method1(s) //s将赋值给方法的形参 str 那么方法执行时str有值
// c就是方法调用后的返回值0
6、方法参数传递
1、方法的参数是基本数据类型，它传递的是值
//计算一个属的平方
public int pow（int a）{
a = a + 2；
return a * a；
}
main:
int num = 4;
int sum = pow(num);//赋值给a
System.out.println(num);//4
System.out.println(sum);//36
2、方法的参数是引用数据类型，它传递的是地址（除了String类型除外）
//参数 是数组类型
public static int pow(int [] arr){
arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;
return arr[0]*arr[0]; // 4*4
}
调用
// 调用另一个pow
int [] array = {2,3};
int sum2 = pow(array) ; // array中存放数组的地址 ，将地址赋值给 arr形参
System.out.println(array[0]);// 4
System.out.println(sum2 ); // 16
7、方法的重载
在一个类中，存在相同的方法名的两个级以上的方法，且它们的参数列表不同（参数类型不通风，参数个数不同，参数顺序不同），不考虑参数名，不考虑返回值类型
一个类中不能存在完全相同的方法，它们是重复的方法。JVM编译不通过
例如：
public int add(int a,int b){
return a+b;
}
//重载
public int add(long a,long b){
return (int)(a+b);
}
//与前两个 不重载
public void add(int c,int d){
}
// 能与 方法1 ，2 构成重载
public void add(int a){
}
// 能与 方法1 ，2 构成重载
public void add(int a ,long b){
}
// 能与 方法1 ，2 构成重载
public void add(long a ,int b){
}
注意：方法名是否相同，参数列表是否相同（数据类型，参数个数，参数顺序）
方法重载的规则
-
方法名称必须相同
-
参数列表不同（类型，个数，顺序等）
-
方法的返回类型可以相同也可以不相同
-
仅仅返回类型不同不足以成为方法的重载
实现理论:
方法名称相同时，编译器会根据调用方法的参数个数，参数类型等逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错
在一个方法中可以调用另外一个方法
//在一个方法中可以调用另外一个方法，它们的执行顺序是这样的
public static void main(String[] args) {
System.out.println("这是main方法 的开始语句块");
method1();
System.out.println("这是main方法 的结束语句块");
}
public static void method1(){
System.out.println("这是method1 的开始语句块");
//在一个方法中可以调用另外一个方法，它们的执行顺序是这样的
method2();
System.out.println("这是method1 的结束语句块");
}
public static void method2(){
System.out.println("这是method2 的开始语句块");
method3();
System.out.println("这是method2 的结束语句块");
}
public static void method3(){
System.out.println("这是method3 的开始语句块");
System.out.println("这是method3 的结束语句块");
}
8、方法的递归调用
1、定义
在一个方法中，运行方法自身调用，这样的调用称为方法的递归调用，为了避免出现方法调用时出现死循环，递归调用中必须定义 方法结束调用的条件。
方法递归调用执行流程
public static void m3(int i){
if(i==5){
return ;
}
System.out.println("这是m3方法开始i :"+ i);
i++;
m3(i);
System.out.println("m3方法的结束 i:"+ i );
}
public static void main(String[] args) {
m3(0); //
}
例题：用户输入一个数字使用递归计算出这个数的阶乘
//使用递归输入一个数计算它的阶乘
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数");
int num=sc.nextInt();
int sum=f(num);
System.out.println(sum);
}
public static int f(int n){
if (n==1)
return 1;
return n*f(n-1);
}
以下是递归的练习题，有兴趣的可以做做
练习1 ： 一组序列 1 ，1, 2，3, 8...13,21,34,55,89,144 n， 第12个数 为多少？
练习2： 1， 3， 5， 7， 9， 11 . 问前10个数的和
练习3 ：前5个阶乘之和 例如 5!+4!+3!+...1!
练习4：定义一个函数，函数有一个整型参数n，
如果参数n为偶数时，调用函数求1/2+1/4+...+1/n,
如果参数n为奇数时，调用函数1/1+1/3+...+1/n
练习5、 1/1+1/2+2/3+3/5+5/8.。。。前8个数之和。