JavaSE——方法的使用

在编程的过程中，某段功能的代码可能会频繁的使用到，如果每次都实现一次的话，会使程序变得繁琐，开发的效率也低，当需要改动时，所有用到该段代码的位置都需要修改，不利于后期维护。

因此，我们可以将频繁使用的代码封装成方法，需要时直接拿来链接（即：方法名——方法的入口）使用即可。

1. 方法的概念及使用

1.1 什么是方法？

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

1. 能够模块化的组织代码，
2. 一份代码可以再多个位置使用
3. 让代码更好理解，简单
4. 直接调用现有的方法开发，不必重复造轮子

1.2 如何定义方法？

方法的语法格式：

权限修饰符  返回值类型  方法名[参数类型  参数名] [throws异常类型]  {
     
     
    方法体代码; //方法内部要执行的语句
    [return 返回值]
}

注意：

1. 返回值类型：如果方法有返回值，返回值类型必须与返回的实体类型一致，如果没有返回值就写 void 。
2. 修饰符：
3. 方法的命名：一般采用小驼峰命名，除首单词，其余单词的首字母大写，其他字母小写。
4. 参数列表：如果方法没有什么参数，（）中什么都不用写，如果有参数，需指定参数的类型，多个参数之间使用逗号隔开
5. Java中，方法必须写在类当中。
6. 方法不能嵌套定义（不能在方法里再定义另外的方法）。
7. Java中没有声明。
   示例：检测一个年份是否为闰年的方法

public class Method {
     
     
 //方法的定义
 public static boolen isLeapYear(int year) {
     
     
      if((0==year%4&&0!=year%100)||(0==year%400)) {
     
     
          return true;
       }else {
     
        
           rerurn false;
        }
       }
  }

示例：实现一个两个整数的相加的方法

 public class Method {
     
     
  //方法的定义
   public static int add(int x,int y) {
     
     
        return x+y;
    }
 }

1.3 方法是如何执行的？

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

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

示例：计算两个整数相加

public class Method {
     
     
  public static void main(String[] args) {
     
     
      int a = 10;
      int b = 20;
      int ret = add;
      ret = add(30,50);
  }
  public static int add(int x,int y) {
     
     
       System.out.println("x = "+x+" y = "+y);
       rerurn x+y;
  }
}

1.4 实参和形参的关系

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

示例：

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

Java中，对于基础类型来说,实参的值永远都是拷贝到形参中，即 传值调用,形参和实参本质是两个实体


示例:交换两个整型变量

public class TestMethod {
     
     
   public static void main(String[] argd) {
     
     
       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 = 20 y = 10
main:a = 10 b = 20

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

实参a和b是main方法中的两个变量,其空间在main方法的栈中,形参x和y是swap方法中的两个变量,其空间在swap方法运行时的栈中,实参a和b与形参x和y是两个没有任何关联性的变量.

在swap方法调用时,只是将实参a和b中的值拷贝了一份传递给了形参x和y,因此对形参x和y操作不会对实参a和b产生任何影响

解决办法:传引用类型参数(例如数组)

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

//运行结果
arr[0] = 20 arr[0] = 10

2. 方法的重载

2.1 什么是方法的重载?

先看下面两段代码:

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

//编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失

由于参数类型不匹配,所以不能直接使用现有的add方法


用一种简单粗暴的方法:

public class TestMethod {
     
     
   public static void main(String[] args) {
     
     
       int a = 10;
       int b = 20;
       int ret = addInt(a,b);
       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;
    }
}

上述代码确实可以解决问题,但是不友好的地方是:需要提供许多不同的方法名,能否将所有的名字都改成add呢?

在自然语言中,一个词语如果有多重含义,就说这个词语被重载了,它具体代表什么含义需要结合具体的场景,在Java中,方法也是可以重载的,如果多个方法的名字相同,参数列表不同,则称这几种方法被重载了.

方法构成重载的条件:

• 方法名必须相同
• 参数列表必须不同(参数个数不同、参数的类型不同、类型的次序必须不同)
• 与返回值类型是否相同无关,如果仅仅因为返回值类型不同,是不能构成重载的.
• 编译器在编译代码时,会对实参类型进行推演,根据推演结果决定调用哪个方法.