Java 基础语法方法的使用

Posted 2021-09-06 吞吞吐吐大魔王

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java 基础语法方法的使用相关的知识，希望对你有一定的参考价值。

文章目录

一、方法的基本用法

1. 什么是方法

方法就是一个代码片段，类似于 C 语言中的函数。它是一个语句的集合，它们在一起执行一个功能

那么方法存在的意义是什么呢？

能够模块化的组织代码
做到让代码被重复使用，一份代码可以用在多个位置
让代码更好理解、更简单
直接调用现有方法，不必重复造轮子

2. 语法格式

方法的定义

public static 方法的返回值 方法名称 ([参数类型 形参]){
    // 方法体代码
    [return 返回值;]
}

方法的调用

定义方法时，不会执行代码，调用时才执行
当方法被调用时，会将实参赋值给形参
参数传递完毕后，就会执行到方法体代码
当方法执行完毕后护（遇到 return 语句），就会回到方法调用位置继续往下执行

接下来我们写一个求两个整数相加的方法，体验一下

public class Test{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
    }
    public static int add(int a, int b){
    	return a + b;
	}
}
// 结果为 ret = 30

注意事项
- public 和 static 两个关键字在此处具有特定含义，后面再介绍
- 方法定义时，参数可以没有，但如果有一定要指定类型
- 方法定义时，返回值可以没有，但如果没有，返回类型应该写出 void
- 方法定义时的参数为“形参”，方法调用时的参数为“实参”
- 方法定义必须在类中
- 和 C 语言不同的是 Java 中没有“函数声明”的概念，所以方法的定义可以写在 main 方法的上方或者下方
- 一个方法可以被多次调用
- 方法的调用需要开辟栈帧，方法结束栈帧就随即结束

其实 Java 中的方法和 C 语言太类似了，不过还是会有不同的，所以接下来继续了解方法吧！

3. 实参和形参的关系

我们先来看一个代码

public class Test{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println("a = "  + a " b = " + b);
    }
    public static void swap(int a, int b){
        int tmp = a;
        int a = b;
        int b = tmp;
    }
}
// 运行结果为 a = 10 b = 20

为啥呢？不过在 C 语言里这样写也是错的，因为形参只是实参的一份临时拷贝，swap 方法里只将形参的值互换了，但是实参的值没有互换。

那么就使用指针传值吧！可惜 Java 中没有指针，那怎么办呢？我们可以使用引用类型，如数组实行两个数的交换，如

public class Test{
    public static void main(String[] args){
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("a = "  + arr[0] " b = " + arr[1]);
    }
    public static void swap(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}
// 运行结果为 a = 20 b = 10

二、方法的重载

1. 重载要解决的问题

什么是重载呢？大家可能都会有这个疑问，接下来我们直接用一个代码，揭开重载的面纱

public class Test{
    public static void main(String[] args){
        //当我们求两个整数和时
        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1, b1);
        System.out.println("ret1 = " + ret1);
        //当我们求两个浮点数和时
        double a2 = 1.5;
        double b2 = 2.4;
        double ret2 = a2 + b2;
        System.ouy.println("ret2 =" + ret2);
    }
    public static int addInt(int a, int b){
    	return a + b;
	}
    public static double addDouble(double a, double b){
    	return a + b;
	}
}

上面我们分别对整数和浮点数求和都写了一个方法，这个做法也是对的。但是 Java 认为 addInt 这样的名字不友好，不如直接就叫 add。啥意思呢，在 Java 中上述代码可以写出这样

public class Test{
    public static void main(String[] args){
        //当我们求两个整数和时
        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1, b1);
        System.out.println("ret1 = " + ret1);
        //当我们求两个浮点数和时
        double a2 = 1.5;
        double b2 = 2.4;
        double ret2 = a2 + b2;
        System.ouy.println("ret2 =" + ret2);
    }
    public static int add(int a, int b){
    	return a + b;
	}
    public static double add(double a, double b){
    	return a + b;
	}
}

细心的可以发现我们把方法名都叫作了 add，这个就叫做重载

2. 什么是重载

含义

同一个方法名字相同，提供不同版本的实现，称为重载
满足要求
- 方法名相同
- 参数列表不同（参数的个数或者参数的类型不同）
- 返回值不作要求
以上条件都满足时，才是重载。后面我们还会讲到重写，这是面试时时常会被问到的问题
注意事项

重载不是必须在一个类当中（继承）

三、方法递归

1. 什么是递归

概念

一个方法在执行过程中调用自身，就称为“递归”
实行条件
- 存在限制条件，当满足这个限制条件的时候，递归便不再继续
- 每次递归调用之后越来越接近这个限制条件
递归其实就是调用自己嘛，如果不存在限制条件只是调用自己的话，就可能有错误，如
```
public class Test{
    public static void main(String[] args){
        func();
    }
    public static void func(){
        func();
    }
}
```
上述代码就会栈溢出（StackOverflowError），因为方法调用时都会在栈上开辟内存，无休止的调用就会导致无休止的开辟，使栈溢出

2. 递归执行过程分析

既然知道什么是递归后，我们先来看一个求 n 的阶乘的例子

public class Test{
    public static void main(String[] args){
        int num = 4;
        int ret = factor(num);
        System.out.println(ret);
    }
    public static int factor(int n){
        if(n == 1 || n == 0) 
            return 1;
        else
            return n * factor(n-1);
    }
}
// 结果为24

而接下来我用两种方法为大家分析一下递归的执行过程

分析方法一

递归其实可以分为递和归两部分，如上图，红色路线就是递（将新的数值传递给方法调用），橙色路线就是归（从最后的限制条件得到的值，依次往回传回去）

分析方法二
我们可以直接把这个方法放到栈上面去看，我们知道栈的特点是后进后出。最左边的图表示是四次调用方法，往右，由于 n == 1 时遇到限制条件，fac(1) 方法返回1并且结束（该方法在栈上随即销毁）。再往右，fac(2) 方法返回2并且结束（该方法在栈上随即销毁）。再往右，fac(3) 方法返回6并且结束（该方法在栈上随即销毁）。最后，fac(4) 方法返回24并且结束（该方法在栈上随即销毁）。

3. 递归练习

接下来我们做几个练习，让方法递归的理解更加深刻一些吧！

按顺序打印一个数字的每一位

public static void print(int num){
    if(num < 10)
        System.out.print(num);
    else{
        print(num / 10);
        System.out.print(num % 10);
    }
}

求 1 + 2 + … + n 的和

public static int sum(int num){
	if(num == 1)
		return 1;
	else
		return num + sum(num - 1);
}

写一个递归方法，输入一个非负整数，返回组成它的数字之和

 public static int sum(int num){
    if(num < 10)
        return num;
    else
        return num % 10 + sum(num / 10);
}

求斐波那契数列数列的第 N 项

public static int fic(int num){
    if(num == 1 || num == 2) 
        return 1;
    else 
        return fic(num - 1) + fic(num -2);
}

4. 递归小结

递归是一种重要的编程解决问题的方式，我们已经知道了递归的用法，但是我们还应该知道什么时候使用递归更好。就比如上述求斐波那契数列的第 N 项，其实并不推荐使用递归去求，因为 N 越大，重复计算的次数就越多，这时就更推荐迭代法，如

public static int fic(int num){
    int f1 = 1;
    int f2 = 1;
    int f3 = 1;
    int i = 0;
    for(i = 3; i <= num; i++){
        f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
    }
    return f3;
}

四、总结

这次学习了 Java 中方法的使用，其实学习的过程很轻松，因为和 C 语言的函数太像了。如果大家上述有什么没有理解的话，可以给我私信或者浏览我之前写过的 C 语言函数的文章第五章 C世界函数的故事（1）和第六章 C世界函数的故事（2）以加深理解。
希望大家喜欢哦！

以上是关于Java 基础语法方法的使用的主要内容，如果未能解决你的问题，请参考以下文章

JSP开发中的基础语法

java基础3-重载+命令行传参+递归+数组+排序