【Java】——方法使用详解

Java 方法的使用：

1.方法的基本用法：

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

方法存在的意义：

（1）能够欧模块化的组织代码；

（2）是代码得到可重用性提高；

（3）使读者更容易理解代码；

（4）可直接实现对方法的调用，不必多次写同功能的代码。

 

1.2方法定义语法：

//方法定义

public static 方法返回值 方法名称（[参数类型 形参...]）{

          方法代码；

         [return 返回值]；

}

//方法调用

返回值变量 = 方法名称（实参...）;

 

//举例1：——实现一个方法实现两个整数相加

 //1.写方法——实现两个整数相加
public class Test {
    //方法的定义
    public static int Add(int num1,int num2){
        return (num1 + num2);
    }
    public static void main(String[] args) {
        int a = 3;
        int b = 7;
        //方法的调用
        int ret = Add(a ,b);
        System.out.println(ret);
    }
}

（1）方法定义时，参数可以没有，每个参数要指定类型；

（2）方法定义时，返回值可以没有，如果没有返回值，则返回值类型要写成void；

（3）方法定义时的参数称为——形参，方法调用时的参数——实参

（4）方法的定义必须在类中，到吗书写在调用位置的上方或者下方均可。

1.3方法调用的执行过程

基本规则

（1）定义方法的时候，不会执行方法的代码，只有调用的时候才会执行；

（2）当你方法被调用的饿时候，会将实参赋值给形参；

（3）参数传递完毕后，就会执行到方法体代码；

（4）当方法执行完毕之后（遇到return语句），就执行完毕，回到方法调用位置继续往下执行；

（5）一个方法可以被多次调用。

举例2——计算两个整数相加

举例3——计算1！ +2！ +3！ +4！ + 5！

1.4实参和形参的关系

举例4：——交换两个变量

public class Test {
    //2.实参和形参的关系——交换两个变量
    public static void swap(int num1,int num2){
        int tmp = num1;
        num1 = num2;
        num2 = tmp;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println("a = " + a+",b =" + b);
    }
}

代码截图：

原因分析：——此代码并没有完成数据的交换

对于基础类型——形参相当于实参的拷贝——即传值调用

//观察可发现，对x 和y 的修改，不影响a  和  b

int a = 10;

int b = 20;

int x = a;

int y = b;

int tmp = x;

x = y;

y = tmp;

解决方法——传引用类型——例如数组来解决此问题

代码实现：

public class Test {
    //3.实现数据的交换——传引用类型参数——如传数组
    public static void swap(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
    public static void main(String[] args) {
        int[] arr = {10,20};
        swap(arr);
        System.out.println("a = " + arr[0] + ",b =" + arr[1]);
    }
}

结果截图：

1.5没有返回值的方法

方法的返回值是可选,有些时候可以没有返回值。

举例：

public class Test {
    //4.方法是可以没有返回值类型的
    public static void print(int x,int y){
        System.out.println("x = " + x + ",y = " + y);
    }
    public static void main(String[] args) {
     int a = 10;
     int b = 20;
     print(a,b);
    }
}

结果截图：

2.方法的重载

2.1使用重载

举例1———实现各类型及个数数据的求和

代码实现：

public class Test {
    //5.重载——同一个方法名字，参数类型几个数不同
    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;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a,b);
        System.out.println("ret = " + ret);

        double a1 = 20.5;
        double b1= 30.1;
        double ret1 = add(a1,b1);
        System.out.println("ret1 = "+ ret1);

        double a2 = 20.3;
        double b2 = 20.5;
        double c2 = 23.1;
        double ret2 = add(a2,b2,c2);
        System.out.println("ret2 = "+ ret2);
    }
}

结果截图：

2.2重载的规则

   针对同一个类：

（1）方法名相同

（2）方法的参数不同（参数个数或者参数类型不同）

（3）方法的返回值类型不影响重载

3.方法递归

3.1方法递归的概念

一个方法在执行过程中调用本身——即递归——有一个起始条件，一个递推公式。

举例1——求n!——使用递归

代码实现：

public class Test {
    //6.递归——求n!
    public static int factor(int n){
        if(n == 1){
            return 1;
        }
        return n * factor(n - 1);//factor调用函数自身
    }
    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
}

结果截图：

调用栈——方法在调用的时候，会有一个“栈”这样的内存空间描述当前的调用关系。

每一次的方法调用就称为一个“栈帧”，每个栈帧包含了这次调用的参数是哪些，返回到哪里继续执行等信息。

3.2递归执行过程分析

举例：

代码实现：

public class Test {
    //递归求n的阶乘分析
    public static int factor(int n){
        System.out.println("函数开始，n = " + n);
        if(n == 1){
            System.out.println("函数结束，n = 1 ret= 1");
            return 1;
        }

        int ret;
        ret = n * factor(n - 1);
        System.out.println("函数结束，n = " + n + ",ret = " + ret);
        return ret;
    }

    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println( "ret = "+ ret);
    }
}

结果截图：