Java中方法的使用详解

1.引言

假设有一个美女博主，每次发的照片都特别漂亮

然后该博主的评论区每次都会有很多粉丝的评论：
哇！宝宝好漂亮，求上衣链接！！！
老婆亲亲！这个口红是什么色号呀？
宝宝迷死我啦！听说宝宝超级聪明，让我来考你一个问题：你的微信号多少……
每次博主都会非常热情的回复粉丝们的评论，但是由于粉丝数量很多，而且很多粉丝问的问题都一样，于是，博主逐渐失去耐心

但是博主还是很疼粉丝的，冷静下来之后，博主想到了一个方法：
她专门发了一个视频，里面主要介绍了每次出镜穿的衣服，以及自己经常用的化妆品的购买平台和店铺信息。
这么一来，她就不用再花费那么大功夫去依次回复每个粉丝的消息了。
从这个过程中我们可以看到：

1. 博主将粉丝普遍的问题整理成了一个视频，减少了很多重复性回复，然后就有更多的时间来处理自己的事情了。
2. 喜欢博主衣服的粉丝，直接去看那个视频，就可以知道去哪里买那件衣服了。
3. 由于博主的粉丝很多，她不一定每条评论都会及时回复，那粉丝可能就会一直评论，但是这样一来，粉丝就可以自行去看那个视频，也省去了很多重复性的事情。

在编程中也是一样，某段代码的功能可能会频繁使用到，如果在每个位置都重新实现一遍：
1.会使程序变得繁琐
2.开发效率低下，做了大量重复性的工作
3.不利于维护，需要改动时，所有遇到该段代码的位置都需要修改
4.不利于复用
因此，在编程中，我们也可以将频繁使用的代码封装成 " 方法 " ,需要用时直接拿来使用即可，避免写很多相同的代码。

2.方法的概念及使用

2.1 什么是方法(method)

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

方法存在的意义：
1.能够模块化的组织代码（当代码规模比较负责的时候）
2.做到一份代码可以在多个位置使用
3.让代码更好理解

比如，现在要开发一款日历，在日历中经常要判断一个年份是否为闰年，则有如下代码：

//判断闰年的代码
int year = 1900;
if ((year % 4 == 0 || year % 100 != 0) || year % 400 == 0){
    System.out.println("是闰年");
}else {
    System.out.println("不是闰年");
}

那方法该如何定义？

1.2 方法的定义

方法语法格式

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

1.实现一个判断年份是否为闰年的方法：

public class Method{
  public static boolean isLeapYear(int year){
     if ((year % 4 == 0 || year % 100 != 0) || year % 400 == 0){
        return true;
    }else {
        return false;
    }
  }
}

2.实现一个两个整数相加的方法：

public class Method{
  public static int add(int a, int b){
     return a + b;
  }
}

注意事项：

• 返回值类型：如果方法有返回值，返回值类型必须要和最后返回的那个值的类型一致；如果没有返回值，必须写成void.
• 方法名字：用小写.
• 参数列表：如果方法中没有参数，括号中什么都不写，如果有参数，需要写上参数类型，多个参数之间用逗号隔开.
• 方法体：方法内部要执行的语句
• 在Java中，方法必须写在类当中；方法不能嵌套定义；没有方法声明一说

1.3 方法调用的执行过程

方法调用过程
调用方法–>传递参数–>找到方法地址–>执行被调方法的方法体–>被调方法结束返回–>回到主调方法继续往下执行
注意事项

• 定义方法的时候，不会执行方法的代码，只有调用的时候才会执行
• 一个方法可以被调很多次

1.4实参和形参的关系

形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值

1. 在Java中，实参的值会拷贝到形参中，形参和实参本质是两个实体。

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

交换两个整型变量：

public class Test2 {
    public static void swap(int x, int y){
        int tmp = x;
        x = y;
        y = tmp;
        System.out.println("x = " + x + " y = " + y);
    }//输出 x = 20 y = 10

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println("a = " + a + " b = " + b);
    }//输出 a = 10 b = 20
}

可以看到，在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产生任何影响。
注意 ：对于基础类型来说，形参相当于实参的拷贝，即传值调用。
解决办法：传引用类型参数（例如数组来解决这个问题）

public class Test2 {
    public static void swap(int[] array){
        int tmp = array[0];
        array[0] = array[1];
        array[1] = tmp;
    }

    public static void main(String[] args) {
        int[] array = {10,20};
        swap(array);
        System.out.println("array[0] = " + array[0] + " array[1] = " + array[1]);
    }//输出array[0] = 20 array[1] = 10
}

2. 方法重载

2.1 为什么方法需要重载

请看下面的两个方法：

public class MethodTest {
    //返回值是int，两个形参的类型也是int
    public static int add(int x, int y){
        return  x + y;
    }

    public static void main(String[] args) {
        //两个整型相加
        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1,b1);
        System.out.println(ret1);
        //两个double类型相加
        double a2 = 10.0;
        double b2 = 20.0;
        double ret2 = add(a2,b2);
        System.out.println(ret2);
    }
}

这个代码会编译出错，提示信息如下：

由于参数类型不匹配，所以double类型的相加不能使用现有的add方法，有一种比较简单粗暴的方法，就是再写一个方法：

public class MethodTest {
    //返回值是int，两个形参的类型也是int
    public static int add(int x, int y){
        return  x + y;
    }
    //返回值是double,两个形参的类型也是double
    public static double addDouble(double x, double y){
        return x + y;
    }
    public static void main(String[] args) {
        //两个整型相加
        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1,b1);
        System.out.println(ret1);
        //两个double类型相加
        double a2 = 10.0;
        double b2 = 20.0;
        double ret2 = addDouble(a2,b2);
        System.out.println(ret2);
    }
}

虽然上述代码可以解决我们的问题，但麻烦的是这样一来，就需要提供很多不同的方法名，而且方法名多了我们脑壳的昏了，本质都是加法，还要为了适应不同的数据类型搞出那么多花里胡哨的的名字。所以一气之下，我们可以冷静下来慢慢写……

开玩笑的，或许我们可以将这些名字都统一为add!

2.2 方法重载概念

在Java中，可以有多个方法的名字相同，而参数列表不同的情况，我们将这种情况称为重载.

public class MethodTest {
    //返回值是int，两个形参的类型是int
    public static int add(int x, int y){
        return  x + y;
    }
    //返回值是double,两个形参的类型是double
    public static double add(double x, double y){
        return x + y;
    }
    //返回值是double,三个形参的类型是double
    public static double add(double x, double y,double z){
        return x + y + z;
    }
    public static void main(String[] args) {
        add(1,2); //调用add(int x, int y)
        add(1.5,2.5); //调用add(double x, double y)
        add(1.5,2.5,3.5); //调用add(double x, double y,double z)
    }
}

重载的规则：

1. 方法名必须相同
2. 参数列表必须不同（参数的个数不同，参数的类型不同，类型的次序必须不同）
3. 与返回值类型是否相同无关
   如果两个方法仅仅只是因为返回值类型不同，是不能构成重载的：

public class MethodTest {
    //返回值是int，两个形参的类型是int
    public static int add(int x, int y){
        return  x + y;
    }
    //返回值是double,两个形参的类型是int
    public static double add(int x, int y){
        return x + y;
    }

    public static void main(String[] args) {
        add(1,2);
    }
}

上述的代码会出现编译错误，错误提示如下：

这是由于编译器在编译代码时，会对实参类型进行推演，根据推演的方法来决定调用哪个方法。