Java中的方法

什么是方法

方法：是一个代码片段，类似于C语言中的函数。

1.当代码规模比较复杂时，能够模块化地组织代码；

2.做到代码被重复使用，一份代码可以在多处位置使用；

3.让代码更好理解更简单；

4.直接调用现有方法开发；

方法的定义

语法结构：

修饰符  返回值类型 方法名称（[参数类型 形参...]）{

        方法体代码；

        [return 返回值];

}

例如：实现闰年的判断

//public:访问修饰限定符    static：静态关键字    int：返回值类型   q：方法名  括号中是形式参数列表
    //判断是否为闰年 判断是否需要使用Boolean
    public static boolean isLeapYears(int year){
        //方法体;
        //在if判断语句之前无需定义year     因为year已经在上述作为形参定义了
        if((year %4 == 0 && year %100 != 0)||year%400==0){
            System.out.println(year+"是闰年");
            //boolean类型必须要有返回类型（返回true、false）
            //不能先执行return语句，一旦执行return语句则表示方法执行结束，之后不能被执行
            return true;
        }else{
            System.out.println(year+"不是闰年");
            return false;
        }
    }

    public static void main(String[] args) {
        //使用方法需要先调用
        isLeapYears(2023);
        //若是上述语句进行调用，并非用到返回值
        boolean year =isLeapYears(2023);
        System.out.println(year);
        //此时便可返回false
    }

对于上述题目：主函数中调用isLeapYears进行传参（2023）使用year来接受返回值；

对于传参：1.确定方法类型、个数、顺序都要一一匹配；2.接受返回值也需要一一匹配；

改进：判断1000-2000年之间的闰年

    public static boolean isLeapYears(int year){
        if((year %4 == 0 && year %100 != 0)||year%400==0){
            return true;
        }else{
            return false;
        }
    }
    public static void main(String[] args) {
        for (int i = 1000; i < 2000; i++) {
            boolean year=isLeapYears(i);
            if (year==true){
                System.out.println(i+"是闰年");
            }
        }
    }

方法从编写到使用

1.定义方法（决定方法返回值是什么类型、方法名是什么、形参有几个什么类型什么顺序

2.使用方法，（调用方法。 方法名（），看有几个参数都是什么类型什么顺序

3.观察方法是否要有返回值，若有返回值要不要接收返回值，用什么类型接收，接收了返回值用返回值做什么。

例如：实现两个数相加

public static int add(int a,int b) {
        return a+b;
    }
    public static void main(String[] args) {
        //方法使用int类型调用方法时也应使用int类型
        int a=20;
        int b=30;
        int a1=add(2,3);//只需要输入（2，3） 编译器会自己完善
        System.out.println("a1"+"="+a1);//a1=5
        //可以接收返回值将返回值扩大5倍，并使用   若方法无返回值（void型）则不能接收！
        int t=a1*5;
        System.out.println(t);
        int a2=add(a,b);
        System.out.println("a2"+"="+a2);//a2=50
    }

注意：

1.初阶可以直接使用public static固定搭配；

2.返回值类型：若方法有返回值，返回值类型必与返回的实体类型一致；若无返回值，必写void；

3.方法名字：采用小驼峰命名；

4.参数列表：若方法无参数，括号中什么都不写，若有参数需指定参数类型，多个参数之间需用逗号隔开；

5.方法体：方法内部要执行的语句

6.在Java当中，方法必须写在类当中、方法不能嵌套定义、没有方法声明的概念；

方法调用执行过程

方法调用过程：调用方法-->传递参数-->找到方法地址-->执行被调方法的方法体-->被调方法结束返回-->回到主调方法继续向下执行

注意：定义方法的时候，不会执行方法的代码，只有调用的时候才会执行；一个方法可以被多次调用；方法的执行是在一块内存当中，这块内存叫做栈，当方法结束后方法所开辟的栈帧就被回收了（因此方法的调用是在栈上的、方法遇到return或者右花括号代表当前方法结束了，对应方法开辟的栈帧回收了、）；

例如：计算1！+2！+3！+...

 public static int fucNum(int num){
        int sum=0;
        for (int i = 1; i <= num; i++) {
            int ret= fuc(i);
            sum += ret;
        }
        return sum;
    }
    public static int fuc(int n){
        int ret=1;
        for (int i = 1; i <= n; i++) {
            ret *=i;
        }
        return ret;
    }
    public static void main(String[] args) {
        System.out.println(fucNum(5));
    }

实参和形参的关系

方法的形参相当于数学函数中的自变量，用来接收函数在调用时传递的值，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递的值。

//例如
public static int facSum(int N){ //N是形参
    return (1+N)*N/2;
}
facSum(10);    //10是实参在方法调用时，形参N来保存10
facSum(20);    //20也是如此
//例如
public static int add(int x,int y){
    retuen x+y;
}
add(2,3);//此时2和3是实参在调用时传给形参x和y

Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体；

方法重载

1.方法名称必须相同；

2.方法的参数列表不同（类型、顺序、个数），和返回值无关；

3.编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法；

 public static double sum(double a,double b){
        return a+b;
    }
    public static double sum(int b,double a){
        return a+b;
    }
    public static double sum(double a,int b){
        return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
    public static int sum(int a,int b){
        return a+b;
    }
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int ret = sum(a,b);
        System.out.println(ret);
        double d1=12.4;
        double d2=17.8;
        double ret2 = sum(d1,d2);
        System.out.println(ret2);

    }