一、方法

1、方法的定义

/*
    [修饰符列表] 返回值类型 方法名(形式参数列表){
        方法体；
        // return;终止当前方法
    }
    方法写完之后需要调用去使用，不调用没法用
    1、修饰符列表：不是必选的
    2、返回值类型：可以是任何数据类型（基本数据类型和引用数据类型）
        返回值：一般是指一个方法执行结束之后的结果，通常返回一个数据，返回值实际给的是调用者
        当一个方法执行结束不返回任何值时，需要写void关键字，表示无返回值，但是也可以写return
    3、注意：如果返回值类型不是void，那么在方法执行结束后必须使用  return 值;  ，来完成值的返回
            如果没有return中编译器会报错
            只要return执行，当前方法必然结束
    4、方法名
        方法名要见名知意，规则首字母消息，后面每个单词首字母大写
    5、形式参数列表：
        每一个参数都是局部变量，方法结束后内存释放
        个数：0-n个，使用逗号隔开  (int x,int y,double z,String s)
    6、方法体
        方法体中编写业务逻辑代码，遵循自上而下的顺序执行，
        需要数据，数据来源就是形参
*/

public class MethodTest01{
    public static void main(String[] args){
        
    }
}

2、方法的调用

压栈：方法只有在调用的时候才会在栈中分配空间，并且调用时就压栈

弹栈：方法执行结束之后，该方法所在的空间就会释放，此时会发生弹栈

方法调用叫做压栈，方法结束叫做弹栈

/*
    方法必须调用才能使用
    1、调用：
        类名.方法名(实际参数列表);
    2、实参和形参的数据类型必须一一对应
*/
public class MethodTest02{
    public static void main(String[] args){
        // 调用方法
        // (10,2)叫做实际参数列表 实参
        // 接收方法的返回值：使用变量来接收，
        // 也可以不接收，但是不接收没有意义啊
        int result = MethodTest02.divide(10,2);
        System.out.println(result);
        // 自动类型转换  可以
        double jieguo = MethodTest02.divide(10,2);
        // 注意：：对于没有返回值的方法，变量不可以接收
    }
    public static int divide(int x,int y){
        T.print();// 调用方法不一定非要在main方法中，不要把main方法特殊化
        return x / y;
    }
}
class T{
    public static void print(){
        System.out.println("hello");
    }
}

/*
    调用方法时，什么时候类名可以省略
    a方法调用b方法，a和b方法在同一个类的时候，“类名.”可以省略
    不在同一个类中的时候，不可以省略
*/
public class MethodTest04{
    public static void main(String[] args){
        MethodTest04.print();
        // “类名.”可以省略不写，因为在同一个类中
        print();
        // 跨类调用的时候不可以省略
        MyClass.print1();
    }
    public static void print(){
        System.out.println("hello");
    }
}
// 类2
class MyClass{
    public static void print1(){
        System.out.println("hello");
    }
    public static void print2(){
        System.out.println("hello");
    }
}

3、实际参数列表

/*
    实际参数列表
*/
public class MethodTest03{
    public static void main(String[] args){
        // 使用小容量
        byte b1 = 10;
        byte b2 = 20;
        // 把小容量传进去是可以的
        int result = MethodTest03.divide(10,20);
    }
    public static int divide(int x,int y){
        return x / y;
    }
}

 4、break;和return;语句的区别

/*
    break终止最近的循环
    return终止当前方法
*/

public class MethodTest05{
    public static void main(String[] args){
        for(int i = 0;i < 10;i++){
            if(i == 5){
                // break;// 终止for循环
                return;// 终止当前方法，不是一个级别  也就是hello不会输出
            }
            System.out.println(i);
        }
        System.out.println("hello");
    }
}

二、方法的重载overload

  1、方法重载机制：

  功能相似的，可以让方法名相同，更加易于代码的编写

  注意：重载不能随便用，如果两个功能压根不相干，之间根本没有关系，此时使用重载机制，会导致编码更麻烦。无法进行功能的区分

  2、java语言中，怎么进行方法区分：

  首先java编译器会通过方法名进行区分，方法名相同下，会通过方法的参数类型区分

  注意：方法重载和方法的返回值类型以及修饰符无关

public calss OverloadTest01{
    public static void main(String[] args){
        System.out.println(sum(10,20));
        System.out.println(sum(10L,20L));
        System.out.println(sum(10.0,20.0));
    }
    // 计算int类型数据求和
    public static int sum(int a,int b){
        return a + b;
    }
    // 计算long类型数据求和
    public static long sum(long a,long b){
        return a + b;
    }
    // 计算double类型数据求和
    public static double sum(double a,double b){
        return a + b;
    }
}

  3、什么时候代码发生重载

  条件1：在同一个类中

  条件2：方法名相同

  条件3：参数列表不同：参数的个数、类型、顺序不同都算不同

三、方法的递归

  1、方法递归

  方法自己调用自己，就是方法递归

  当递归时，程序没有结束条件，一定会发生栈内存溢出错误

  所以 ：递归必须要有结束条件

public class RecursionTest01{
    public static void main(String[] args){
        doSome();
    }
    public static void doSome(){
        System.out.println("doSome");
    }
}