【0 基础学 Java】（七）方法

最新推荐文章于 2024-01-18 07:00:00 发布

编程反思录

最新推荐文章于 2024-01-18 07:00:00 发布

阅读量418

点赞数 1

分类专栏： JavaSE 文章标签： java 编程语言 javase

本文链接：https://blog.csdn.net/qq_44954010/article/details/106688697

版权

JavaSE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

码字不易，对你有帮助 点赞/转发/关注 支持一下作者

微信搜公众号：不会编程的程序圆

看更多干货，获取第一时间更新

看更多示例和代码： https://github.com/hairrrrr/EasyJava，欢迎 star

正文

一方法的基本使用

1.1 什么是方法

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

1.2 方法定义语法

基本语法

// 方法定义
public static 方法返回值类型 方法名称（参数类型 形参 ...){
方法体代码;
return 返回值;
}
// 方法调用
返回值变量 = 方法名称(实参...);

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

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 x, int y) {
		return x + y;
	}
}
// 执行结果
ret = 30

注意：

public 和 static 两个关键字在此处具有特定含义, 我们暂时不讨论, 后面会详细介绍
方法定义时, 参数可以没有. 每个参数要指定类型
方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
方法定义时的参数称为 “形参”, 方法调用时的参数称为 “实参”。参数数量需要匹配。
方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可
Java 中没有 “函数声明” 这样的概念

例2：方法写在调用它的函数的上方或下方都是可以的

方法写在 main 函数上方

public class helloWorld{
			
	public static int addSum(int a, int b){
		
		return a + b;
	}
	
	public static void main(String[] args) {
		
		int a = 10, b = 20;
		int ret = addSum(a, b);
		System.out.println("sum = " + ret);
		
	}		
}

方法写在 main 函数下方

public class helloWorld{
			
	public static void main(String[] args) {
		
		int a = 10, b = 20;
		int ret = addSum(a, b);
		System.out.println("sum = " + ret);
		
	}	

	public static int addSum(int a, int b){
		
		return a + b;
	}
}

以上两种写法都是可以的。

练习：

写一个方法比较两个数的最大值
写一个方法比较三个数的最大值

参考答案：

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = 30;
		int max = threeNumMax(a, b, c);
		System.out.printf("Max = %d", max);
	}
	
	public static int threeNumMax(int x, int y, int z) {
		
		int max = twoNumMax(twoNumMax(x, y), z);
		//twoNumMax(a,b)返回 a，b 中的较大值，然后再次调用twoNumMax比较 这个较大值 与 c
		return max;
	}
	
	public static int twoNumMax(int x, int y) {
		return (x > y ? x : y);
	}
}

1.3 方法调用的执行过程

基本规则

定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行
当方法被调用的时候, 会将实参赋值给形参
参数传递完毕后, 就会执行到方法体代码
当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行
一个方法可以被多次调用

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("第一次调用方法之前");
		int ret = add(a, b);
		System.out.println("第一次调用方法之后");
		System.out.println("ret = " + ret);
		System.out.println("第二次调用方法之前");
		ret = add(30, 50);
		System.out.println("第二次调用方法之后");
		System.out.println("ret = " + ret);
}
	public static int add(int x, int y) {
		System.out.println("调用方法中 x = " + x + " y = " + y);
		return x + y;
}
}
// 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

例 3: 计算 1！ + 2！+ 3！+ 4！+ 5！

Class Test {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1; i <= 5; i++) {
		sum += factor(i);
		}
		System.out.println("sum = " + sum);
	}
	public static int factor(int n) {
		System.out.println("计算 n 的阶乘中! n = " + n);
		int result = 1;
    	for (int i = 1; i <= n; i++) {
		result *= i;
		}
		return result;
	}
}
// 执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153

1.4 实参和形参的关系

例4：交换两个整型变量

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 x, int y) {
		int tmp = x;
		x = y;
		y = tmp;
	}
}
// 运行结果
a = 10 b = 20

分析

刚才的代码，没有完成数据的交换。

对于基础类型来说，形参相当于实参的拷贝，即 传值调用。

上面的代码相当于：

int a = 10;
int b = 20;

int x = a;
int y = b;
int tmp = x;
x = y;
y = tmp;

上面的方法实际上就是创建了 x，y 两个临时变量（形参），将 a，b（实参）的值传给 x，y。然后创建临时变量 tmp 交换的是 x，y 的值。

**解决办法：**传引用类型参数（后面会讲）

1.5 没有返回值的方法

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

代码示例

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
        //没有变量接收 print 方法的返回值，因为它没有返回值
		print(a, b);
	}
	public static void print(int x, int y) {
		System.out.println("x = " + x + " y = " + y);
	}
}

例5：没有返回值的方法可能是有“缺陷”的

没有返回值：

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		addSum(a, b);
	}
	public static void addSum1(int x, int y) {
		System.out.println("a + b = "+ (x + y));
	}
}
//输出
a + b = 30

有返回值：

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int ret = addSum(a, b);
		System.out.printf("%d + %d = %d, 2 * (%d + %d) = %d", a, b, ret, a, b, 2*ret);
	}
	public static int addSum2(int x, int y) {
		return x + y;
	}
}
//输出：
10 + 20 = 30, 2 * (10 + 20) = 60

可以看到，对于没有返回值的方法来说，addSum1 仅仅是讲参数相加然后输出而已；而 addSum2 将计算结果返回， main 函数拿到了计算结果，可以做更多的操作（比如示例种的运算），当然也可以输出。

void 类型的函数可以 return 吗？

class Test {
	public static void main(String[] args) {
	testVoidReturn();
}
	public static void testVoidReturn(){
		return;
		System.out.println("return 是没有什么用的！");
	}
}
//编译报错：
Test.java:9: 错误: 无法访问的语句
                System.out.println("return 是没有什么用的！");
                ^
1 个错误

二方法的重载

有些时候我们需要用一个函数同时兼容多种参数的情况，我们就可以使用到方法重载。

2.1 方法重载要解决的问题

class Test {
	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可能会有损失
double ret2 = add(a2, b2);
					^

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

2.2 使用重载

对于上面的问题，下面这种方法是否可行？

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int ret = addInt(a, b);
		System.out.println("ret = " + ret);
		double a2 = 10.5;
		double b2 = 20.5;
		double ret2 = addDouble(a2, b2);
		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;
	}
}

重新命名一个新的方法来实现对不同类型的变量的相加。但是 Java 是支持方法重载的。我们一般使用下面的方式：

class Test {
	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);
		double a3 = 10.5;
		double b3 = 10.5;
		double c3 = 20.5;
		double ret3 = add(a3, b3, c3);
		System.out.println("ret3 = " + ret3);
}
	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;
	}
	
}

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数字相加.
同一个方法名字, 提供不同版本的实现, 称为 方法重载

2.3 方法重载的规则

针对同一个类:

方法名相同
方法的参数不同(参数个数或者参数类型)
方法的返回值类型不影响重载(与 C++ 不同)

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 x, int y) {
		return x + y;
	}
	public static double add(int x, int y) {
		return x + y;
	}
}
// 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
							^
1 个错误

当两个方法的名字相同，参数也相同，但是返回值不同的时候，不构成重载。

三方法递归

3.1 递归的概念

一个方法在执行过程中调用自身，就称为 "递归。

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

3.2 递归执行过程

public static void main(String[] args) {
	int n = 5;
	int ret = factor(n);
	System.out.println("ret = " + ret);
}
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 = n * factor(n - 1);
	System.out.println("函数结束, n = " + n + " ret = " + ret);
	return ret;
}
// 执行结果
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

关于 “调用栈”
方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系，称为调用栈。
每一次的方法调用就称为一个 “栈帧”，每个栈帧中包含了这次调用的参数是哪些，返回到哪里继续执行等信息。
后面我们借助 IDEA 很容易看到调用栈的内容。

3.3 递归练习

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

(例如 1234 打印出 1 2 3 4)

方法1：

	public static void printEveryDigit(int num){
		
		if(num / 10 == 0){
			System.out.print(num);
		}
		else{
			printEveryDigit(num / 10);
			System.out.print(" " + num % 10);
		}
	}
}

方法2：

public static void print(int num) {
		if (num > 9) {
			print(num / 10);
		}
		System.out.println(num % 10);
	}

2.递归求 1 + 2 + 3 + … + 10

class Test {
    
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = scan.nextInt();
		int sum = printSum(num);
		System.out.println(sum);
}
	public static int printSum(int num) {
		if(num == 1){
			return 1;
		}
		return num + printSum(num - 1);	
	}
}

3.写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19

class Test {
	public static void main(String[] args) {
	Scanner scan = new Scanner(System.in);
	int num = scan.nextInt();
	int sum = printSumOfDigit(num);
	System.out.println(sum);
}
	public static int printSumOfDigit(int num) {
		if(num > 9){
			return (num % 10) + printSumOfDigit(num / 10);
		}
		return num;	
	}
}

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

public static int Fib(int n) {
		if(n == 1 || n == 2){
			return 1;
		}
		return Fib(n - 1) + Fib(n - 2);
}

3.4 递归小结

递归是一种重要的编程解决问题的方式.

有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易.

有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效.