Java:5.方法的使用

本文介绍

1. 方法的定义以及使用

2. 方法传参

3. 方法重载

4. 递归

1.方法的概念及使用:

1.1什么是方法(method)

方法就是一个代码片段 . 类似于 C 语言中的 " 函数 " 。方法存在的意义:

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

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

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

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

1.2方法的定义:

方法的语法格式:

// 方法定义

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

                方法体代码 ;

      [ return 返回值 ];

}

示例一:实现一个函数,检测一个年份是否为闰年

1 public class Method{      定义一个方法
2    public static   boolean    isLeapYear(   int     year){
3  //   修饰符      返回值类型      方法名称  参数类型   形参
4     if(year%4==0 && year%100!=0 || year%400==0){     //条件:1能整除4;2不能被100整除;
5       return true;                                                       3能被 400整除
6       }else{
7              return false;
8            }
9    }
10 }                                                        

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

1 public class Method{
2 //方法的定义
3 piblic static int add(intx,inty){
4  return x+y;
5   }
6 }

注意事项:

1. 修饰符：现阶段直接使用 public static 固定搭配

2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值,       必须写成 void

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

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

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

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

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

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

1.3方法的调用的执行过程

【方法调用过程】

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

注意事项:

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

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

代码示例 1 计算两个整数相加;

1 public calss Method{
2   pulbic static void main(String[] args){
3     int a = 10;
4     int b = 20;
5     System.out.println("第一次调用方法之前");
6     int ret = add(a,b);
7     System.out.println("第一次调用方法之后");
8     System.out.println("ret = " + ret);
9     
10    System.out.println("第二次调用方法之前");
11    ret = add(30,50);                            //表示方法中+x中的x的值
12    System.out.println("第二次调用方法之后");
13    System.out.println("ret="+ret);
14    }
15     
16    public static int add(intx,inty){
17      System.out.println("调用方法中x="+x  +  "y="+y);
18       return x+y;                   //30      //50
19      }
20   }

// 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

代码示例 : 计算 1! + 2! + 3! + 4! + 5!

1  public class TestMethod{
2    public static void main(String[] args){
3    
4    public static int fac(int n){                //定义计算阶乘的方法
5      System.out.println("计算n的阶乘中n!="+n);
6      int result = 1;
7      for(int i=1;i<n;i++){
8         result *=i;        //result = result*i:  计算阶乘
9        }
10    return result;
11   }
12 }
13
14    int sum = 0;                             //主函数
15    for(int i =1;i<5; i++){
16     sum +=fac(i);   //调用阶乘的方法.计算总和
17     }
18   System.out.println("sum="+sum);
19  }


// 执行结果
计算 n 的阶乘中 n! = 1
计算 n 的阶乘中 n! = 2
计算 n 的阶乘中 n! = 3
计算 n 的阶乘中 n! = 4
计算 n 的阶乘中 n! = 5
sum = 153

1.4实参和形参的关系(重要)

方法的形参相当于数学函数中的自变量.

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

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

再如:

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

注意:在java中,实参的值永远都是拷贝到形参中,形参和实参本质是两个实体

代码示例: 交换两个整型变量

1 public class TestMethod{
2   public static void main(String[] args){     主函数
3    int a = 10;
4    int b = 20;
5    swap(a,b);
6    System.out.println("main:a="+a  +  "b="+b);
7 }
8
9  public static void swap(int x, int y){    //定义交换方法
10    int tmp = x;
11    x=y;
12    y=tmp;
13    System.out.println("swap:x="+x  +  "y="+y);
14    }
15 }
// 运行结果
swap: x = 20 y = 10
main: 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

产生任何影响。

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

1 int a = 10;
2 int b = 20;
3
4 int x=a;
5 int y=b;
6
7 int tmp=x;
8 x=y;
9 y=tmp;           //可以看到, 对 x 和 y 的修改, 不影响 a 和 b.

【 解决办法 】 : 传引用类型参数 ( 例如数组来解决这个问题 )

1 public class TestMethod {
2 public static void main(String[] args) {
3 int[] arr = {10, 20};
4 swap(arr);
5 System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
6 }
7 public static void swap(int[] arr) {
8 int tmp = arr[0];
9 arr[0] = arr[1];
10 arr[1] = tmp;
11  }
12 }
  // 运行结果arr[0] = 20 arr[1] = 10

1.5没有返回值的方法:

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

代码示例:

1 class Test{
2   public static void main(String[] args){
3     int a=10;
4     int b=20;
5    print(a,b);
6 }
7
8   public static void print(int x,int y){       //没有返回值的方法中必须用void来代替
9     System.out.println("x="+x  +  "y="+y);
10   }
11 }

2.方法的重载:

2.1为什么需要方法的重载

1 public class TestMethod {
2 public static void main(String[] args) {
3 int a = 10;
4 int b = 20;
5 int ret = add(a, b);
6 System.out.println("ret = " + ret);
7 double a2 = 10.5;
8 double b2 = 20.5;
9 double ret2 = add(a2, b2);                //2.而调用方法从double转换到int可能会有损失
10 System.out.println("ret2 = " + ret2);
11 }
12 public static int add(int x, int y) {   //1.定义的加法方法中用的是int
13 return x + y;
14  }
15 }
// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);

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

一种比较简单粗暴的解决方法如下：

1 public class TestMethod {
2 public static void main(String[] args) {
3 int a = 10;
4 int b = 20;
5 int ret = addInt(a, b);
6 System.out.println("ret = " + ret);
7 double a2 = 10.5;
8 double b2 = 20.5;
9 double ret2 = addDouble(a2, b2);
10 System.out.println("ret2 = " + ret2);
11 }
12 public static int addInt(int x, int y) {    //直接将double强转成int类型
13 return x + y;
14 }
15 public static double addDouble(double x, double y) {
16 return x + y;
17  }
18 }

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

2.2方法重载的概念

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

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

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

如:

1 public class TestMethod{
2  public static void main(String[] args){
3   add(1,2);                    //调用add(int,int)
4   add(1.5,2.5);                //调用add(double,double)
5   add(1.5,2.5,3.5);            //调用add(double,double,double)
6  }
7
8  public static int add(int x,int y){
9    return x+y;
10  }
11 public static double add(double x,double y){
12  return x+y;
13  }
14 public static double add(double x;double y,double z){
15  return x+y+z;
16  }
17 }

注意:

1. 方法名必须相同

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

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

// 注意：两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的
1 public class TestMethod {
2 public static void main(String[] args) {
3 int a = 10;
4 int b = 20;
5 int ret = add(a, b);
6 System.out.println("ret = " + ret);
7 }
8 public static int add(int x, int y) {
9 return x + y;
10 }
11 public static double add(int x, int y) {
12 return x + y;
13  }
14 }
// 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
^
1 个错误

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

2.3方法签名:

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那 为什么类中就 可以定义方法名相同的方法呢？

方法签名即： 经过编译器编译修改过之后方法最终的名字。具体方式： 方法全路径名 + 参数列表 + 返回值类型，构成 方法完整的名字。

3.递归:(一个方法在执行过程中调用自身, 就称为 "递归")

3.1递归的本质:

有些时候，我们 遇到的问题直接并不好解决，但是发现将原问题 拆分成其子问题 之后，子问题与原问题有相同的解法，等子问题解 决之后，原问题就迎刃而解了 。

递归的必要条件：

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同

2. 递归出口

代码示例 : 递归求 N 的阶乘:

1 public static void main(String[] args){
2  int n=5;
3  int ret = factor(n);
4  System.out.println("ret="+ret);
5  }
6
7 public static int factor(int n){
8  if(n==1){
9   return 1;
10  }
11  return n*factor(n-1);  //factor调用自身函数
12 }
//执行结果
ret = 120

3.2递归执行过程分析

代码示例:求N的阶乘:

3.3递归的小练习:

代码示例 1 按顺序打印一个数字的每一位 ( 例如 1234 打印出 1 2 3 4)

1 public class 习题 {
2            public static void main(String[] args) {
3                //按顺序打印一个数字的每一位(例如1234 打印出1 2 3 4)
4                print(1234);
5            }
6            public static void print(int num){
7                if(num>9) {
8                    print(num / 10);  //方法中调用自身,递归调用，打印出每一位
9                }
10                 System.out.println(num % 10);  //打印出最后一位
11
12            }
13        }