🦄个人主页:-雷阵雨-

🦄专栏：JAVA

⚙️操作环境:IntelliJ IDEA Community Edition 2022.1.4

目录

一：方法的概念以及使用

1.1：方法的概念

1.2：方法的定义

1.3：方法调用的过程

1.4：实参和形参的关系（重点）

1.5：没有返回值的方法

二：方法重载

2.1：为什么需要方法重载

2.2：方法重载的概念：

三：总结

一：方法的概念以及使用

1.1：方法的概念

方法就是一个代码片段 . 类似于 C 语言中的 " 函数 " 。方法存在的意义 ( 不要背 , 重在体会 ):

1. 是能够模块化的组织代码 ( 当代码规模比较复杂的时候 ).

2. 做到代码被重复使用 , 一份代码可以在多个位置使用 .

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

4. 直接调用现有方法开发 , 不必重复造轮子

1.2：方法的定义

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
方法体代码;
[return 返回值];
}

让我举个例子：

main：

Scanner scanner = new Scanner(System.in);//输入
System.out.println("请输入年份：");
int year = scanner.nextInt();//创建变量
boolean Leapyear = isLeapyear(year);//调用方法
System.out.println(year + "   是否为闰年：   " + Leapyear);

这句话就是重点调用方法，调用方法名（变量/常量），括号中的变量与方法中的不需要一样。（可一样也可不一样）

但是同一个作用域不能出现两个相同命名的变量

方法：（重点方法第一行，学会写方法）

 public static boolean isLeapyear(int year) {
        if (year % 100 == 0) {
            //判断正百年
            if (year % 400 == 0) {
                return true;
            } else {
                return false;
            }
        } else {
            if (year % 4 == 0) {
                return true;
            } else {
                return false;
            }
        }
    }

上图只是创建方法，只是定义，没有使用

【 注意事项 】

1. 修饰符：现阶段直接使用 public static 固定搭配（修饰符直接就先记住public static）

2. 返回值类型 ：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成 void（）这个是重点，就是形参和实参的类型要相等。

3. 方法名字：采用小驼峰命名 （习惯小驼峰，这是建议，但是不可以使用关键字作为变量的命名。）

4. 参数列表：如果方法没有参数， () 中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开

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

6. 在 java 当中，方法必须写在类当中

7. 在 java 当中，方法不能嵌套定义

8. 在 java 当中，没有方法声明一说

1.3：方法调用的过程

  【方法调用过程】

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

执行 

【 注意事项 】

1.定义方法的时候 , 不会执行方法的代码 . 只有调用的时候才会执行 .

2.一个方法可以被多次调用 .

public class Test {
    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;
    }

运行结果：

只有被调用了才会执行，main中的变量值不会被改变。

1.4：实参和形参的关系（重点）

ava 中方法的形参就相当于 sum 函数中的自变量 n ，用来接收 sum 函数在调用时传递的值的 。形参的名字可以随意 取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值 。

public static int getSum(int N){ // N是形参
return (1+N)*N / 2;
}
getSum(10); // 10是实参,在方法调用时，形参N用来保存10
getSum(100); // 100是实参，在方法调用时，形参N用来保存100

public static int add(int a, int b){
return a + b;
}
add(2, 3); // 2和3是实参，在调用时传给形参a和b

就是实参传值，然后到方法进入内语句。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("main: a = " + a + " b = " + b);
    }
    public static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
        System.out.println("swap: x = " + x + " y = " + y);
    }
}

运行结果：

可以看到，在 swap 函数交换之后，形参 x 和 y 的值发生了改变，但是 main 方法中 a 和 b 还是交换之前的值，即没有交换成功

方法执行结束，就要返回到调用位置。

【 原因分析 】

实参 a 和 b 是 main 方法中的两个变量，其空间在 main 方法的栈 ( 一块特殊的内存空间 ) 中，而形参 x 和 y 是 swap 方法中的两个变量，x 和 y 的空间在 swap 方法运行时的栈中，因此：实参 a 和 b 与 形参 x 和 y 是两个没有任何关联性的变量， 在 swap 方法调用时，只是将实参 a 和 b 中的值拷贝了一份传递给了形参 x 和 y ，因此对形参 x 和 y 操作不会对实参 a 和 b产生任何影响。

注意：对于 基础类型 来说 , 形参相当于实参的拷贝 . 即 传值调用

1.5：没有返回值的方法

方法的返回值是可选的 . 有些时候可以没有的，没有时返回值类型必须写成 void

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

                int a = 10;
                int b = 20;
                print(a, b);
    }
    public static void print(int x, int y) {
        System.out.println("x = " + x + " y = " + y);
    }
}

运行结果：

不需要返回值，类中调用方法，在方法中打印。另外, 如刚才的交换两个整数的方法, 就是没有返回值的.

二：方法重载

2.1：为什么需要方法重载

给大家一个代码展示：

            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;
    }

上在idea中的照片，更直观的看到报错信息：

大家可以看到在

这一行出现报错信息，让我们一步步来：

看一下idea给我们的报错信息是为什么。

第一列是我们需要的变量类型为int 第二列是用户提供的类型，将出现了实参和形参类型不匹配，所以两次调用只有第一次的类型匹配，才可以使用add方法，这个时候我们就需要方法重载。

顺便看一下运行结果：（更有说服力）

这样就更直观一点。

这种情况肯定有解决办法:
 

            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 = add2(a2, b2);
            System.out.println("ret2 = " + ret2);
    }
    public static int add(int x,int y){
        return x+y;
    }
    public static double add2(double x,double y){
        return x+y;
    }

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

上述代码确实可以解决问题，但不友好的地方是：需要提供许多不同的方法名，而取名字本来就是让人头疼的事 情。那能否将所有的名字都给成 add 呢？

（这段代码可是有伏笔哦！！！）可以看一下方法命名oooo

2.2：方法重载的概念：

在自然语言中，经常会出现 “ 一词多义 ” 的现象，比如： “ 好人”

在自然语言中， 一个词语如果有多重含义 ，那么就说该词语 被重载了 ，具体代表什么含义需要结合具体的场景。 在Java 中方法也是可以重载的。

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

（重点重点）

代码最具有说服力：

            int a = 10;
            int b = 20;
            int ret = add(a, b);
            System.out.println("ret = " + ret);
            double a6 = 10.5;
            double b6 = 20.5;
            double ret2 = add(a6, b6);
            System.out.println("ret2 = " + ret2);
            double a2 = 10.5;
            double b2 = 20.5;
            double c3= 30.5;
            double ret3 = add(a2, b2,c3);
            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 static double add(double x, double y,double z ){
        return x+y+z;
    }

运行结果：

每一个方法名都是相同的，但是每次类中都可以调用不同的方法。

注意：

1. 方法名必须相同

2. 参数列表必须不同 ( 参数的个数不同、参数的类型不同、类型的次序必须不同 )

3. 与返回值类型是否相同无关

/ 注意：两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的

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

三：总结

 本片博客讲述java中方法使用，以及重载的概念。希望可以帮助学习Java的同学，如果有不足可以评论留言，最后也谢谢看到最后的同学。