学习java的方法和重载

@[ toc]

目录

什么是java方法的

方法的定义

方法类似与我们学过的c语言的函数
方法.是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子.
那我们可以根据以下的代码
我们通过计算
1! + 2! + 3! + 4! + 5!`

public class Wdff {
    public static void main(String[] args) {
       int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int tmp = 1;
            for (int j = 1; j <= i; j++) {
                tmp *= j;
            }
            sum += tmp;
        }

        System.out.println("sum = " + sum);
    }
}

我们通过以上的代码，我想我们可以继续优化

怎么定义方法

方法的基本语法
public static 方法返回值 方法名称（[参数类型 形参 …]){
方法体代码;
[return 返回值];
}
// 方法调用
返回值变量 = 方法名称(实参…);

方法的使用

public class Wdff {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 方法的调用
        int ret = add(a, b);//实参
        System.out.println("ret = " + ret);
    }
    // 方法的定义
    public static int add(int x, int y) {//行参
        return x + y;
    }
}

注意事项
public 和 static 两个关键字在此处具有特定含义, 我们暂时不讨论, 后面会详细介绍.
2. 方法定义时, 参数可以没有. 每个参数要指定类型
3. 方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
4. 方法定义时的参数称为 “形参”, 方法调用时的参数称为 “实参”.
5. 方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可.
6. Java 中没有 “函数声明” 这样的概念.

基本规则
定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
当方法被调用的时候, 会将实参赋值给形参.
参数传递完毕后, 就会执行到方法体代码.
当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行

public class Yyyfh {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("第一次调用方法之前");
        int ret = add(a, b);
        System.out.println("第一次调用方法之后");
        System.out.println("ret = " + ret);
        System.out.println("第二次调用方法之前");
        ret = add(30, 50);
        System.out.println("第二次调用方法之后");
        System.out.println("ret = " + ret);
    }
    public static int add(int x, int y) {
        System.out.println("调用方法中 x = " + x + " y = " + y);
        return x + y;
    }
}

实参和形参的关系

在这public static void main(String[] args) {
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("a = " + arr[0] + " b = " + arr[1]);
    }
    public static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}

方法的重载

有些时候我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载.

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



                int a = 10;
                int b = 20;
                int ret = addInt(a, b);
                System.out.println("ret = " + ret);
                double a2 = 10.5;
                double b2 = 20.5;
                double ret2 = addDouble(a2, b2);
                System.out.println("ret2 = " + ret2);
            }
            public static int addInt(int x, int y) {
                return x + y;
            }

            public static double addDouble(double x, double y) {
                return x + y;
            }
        }
        

通过观察以上代码我们可以把他优化为

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



                int a = 10;
                int b = 20;
                int ret = add(a, b);
                System.out.println("ret = " + ret);
                double a2 = 10.5;
                double b2 = 20.5;
                double ret2 = add(a2, b2);
                System.out.println("ret2 = " + ret2);
            }
            public static int add(int x, int y) {
                return x + y;
            }

            public static double add(double x, double y) {
                return x + y;
            }
        }

重载的规则

针对同一个类:
方法名相同
方法的参数不同(参数个数或者参数类型)
方法的返回值类型不影响重载.

public class Yyyfh {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = addInt(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = addDouble(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
    public static int addInt(int x, int y) {
        return x + y;
    }

    public static double addDouble(double x, double y) {
        return x + y;
    }
}