UseOfMethods - 方法的使用 - Java，牛笔了

最新推荐文章于 2024-06-14 16:44:06 发布

前端大妹纸

最新推荐文章于 2024-06-14 16:44:06 发布

阅读量732

点赞数 18

分类专栏： 2024年程序员学习文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/m0_58269070/article/details/136961582

版权

2024年程序员学习专栏收录该内容

297 篇文章 0 订阅

订阅专栏

在这里插入图片描述

图6

在这里插入图片描述

用方法来写

public class UseOfMethods {

public static void main(String[] args) {

int a = 10;

int b = 20;

System.out.println("交换前：a = " + a + " b = " + b);

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;

}

图7

在这里插入图片描述

图8

在这里插入图片描述

由图 7，8.可知这样写不会发生任何改变，因为只是交换形参，也就是说交换的是 swap方法的参数

并不是在交换 main方法的参数，这里的x，y，只是a和b的值的一份拷贝

有人肯定会说像C里面一样，传地址呗！

记住在Java中，是无法取得栈上变量的地址的，也就是说取不到局部变量的地址（图 9）

图9

在这里插入图片描述

如果要去做，只能把 a 和 b 的值，放到堆上（动态空间上）。放在堆上的都是对象。

这道题留着我们讲对象和类，或者数组的时候，再进行讲解。以我们现在的基础还不足以解决该问题。

没有返回值的方法

=======================================================================

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

代码示例

public class UseOfMethods {

public static void main(String[] args) {

int a = 0;

int b = 1;

sum(a,b);

}

public static void sum(int x,int y){

System.out.println(x+y);

// 我在方法中就已经将我们想打印的结果图 10，所以不需要返回值

//但是规定无返回，就不能 return 返回一个值

// return x+y; 图 11，都报错了，就别谈运行

// 但是可以这么写

return ;// 虚晃一枪，你能奈我何？

// 图 12

}

图10

在这里插入图片描述

图11

在这里插入图片描述

图12

在这里插入图片描述

方法的重载

====================================================================

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

代码示例

public class UseOfMethods {

public static void main(String[] args) {

int a = 10;

int b = 20;

int ret = add(a, b);

System.out.println("ret = " + ret);

double a2 = 12.5;

double b2 = 18.5;

double ret2 = add(a2, b2);//图 13

System.out.println("ret2 = " + ret2);

}

public static int add(int x,int y){

return x+y;

}

图13

在这里插入图片描述

由此，我们需要方法的重载：一个函数同时兼容多种参数的情况

那我们怎么实现呢？

代码实例2

public class UseOfMethods {

public static void main(String[] args) {

int a = 10;

int b = 20;

int ret = add(a, b);

System.out.println("ret = " + ret);

double a2 = 12.5;

double b2 = 18.5;

double b3 = 9.0;

double ret2 = add(a2, b2,b3);//图 13

System.out.println("ret2 = " + ret2);

}

public static int add(int x,int y){

return x+y;

}

public static double add(double x,double y,double z){

return (x+y+z);

}

}// 图 14

图14

在这里插入图片描述

记住

方法重载的重点在于函数名要相同，参数个数或者类型要不同。（两者中必有一者不同）

而返回值不重要，只要你接收返回的值的类型是相匹配的就行，要不然无法进行赋值。

另外切记

不要写的一摸一样（参数个数和类型都相同），这样相当于一个变量被重复定义，是会出错的

例如：

public static int add(int x,int y){

return x+y;

}

public static int add(int x,int y){

return x+y;

}

再来看一个错误示范

public class UseOfMethods {

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 (double)(x+y);

}

}// 图 15

图 15

在这里插入图片描述

由图我们可以看出这样写也是不行的，正如我前面所说的 返回值，不是重点，参数类型和个数才是重点

只要你参数的类型和个数一模一样，无论你返回值是什么，都算方法的重定义，程序是会报错的（方法的重定义这是我个人理解）

&ensp

图16

在这里插入图片描述

由此我们可以看出方法的重载有多么强大。

我们可以根据参数的类型和个数来为我们的方法，加载几个新的方法，具有更多的功能

现在你知道了吧方法的重载，有多爽！

补充一个知识点：

如果一个类的两个方法（无论是在同一个类中声明，还是都由一个类继承的，或者一个声明和一个继承的【总的来说不一定是同一个类里的】）

具有相同的名称,但签名不是重写等价的，则称该方法名为重载。（了解即可）

由上我可以总结出方法重载的规则

1. 方法名要相同

2. 方法的参数不同（参数个数或者类型，两者选其一，或者都选，反正至少有一个因素是不同的）

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

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

方法递归

===================================================================

递归的概念

一个方法在执行过程中调用自身, 就称为 “递归”.

递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式

递推公式是递归的重点，推出它，递归就很好写。没推出。就。。。嗯~~~

使用递归之前，需要一个前提

1. 有一个趋近于终止的条件（停止递归的条件）

2. 自己调用自己（让它自己扇自己，扇疼了再停下来，不要问我为什么我举这个例子！）

代码示例

public class UseOfMethods {

public static void main(String[] args) {

func();

}

这样写，就不满足使用递归所需的第一个条件没有一个终止递归的条件

所以该程序会无限递归死循环，最终导致栈溢出（栈空间不是无限大，是有限，func方法一直调用自己下去，最终肯定是会爆满/溢出的）

因为每次调用 func方法时，都会为其在栈上空间开辟块自己的空间

public static void func(){

func();

}

}// 图17

图17

在这里插入图片描述

那我该怎么去写一个可以使用的递归呢？

代码实例2

public class UseOfMethods {

public static void main(String[] args) {

func(3);

}

public static void func(int n){

if(n==1){// 递归的终止的条件，因为 n == 3.每次自己调用自己时，n都会减1，调用 3 次，就结束了

System.out.println(n);

return ;

}

func(n-1);

System.out.println(n);

}

}// 图18

图 18

在这里插入图片描述

其实终止条件，相当于数学里的起始条件

你这样想假设我们不知道 n 为多少，那我们怎么办？先从初始情况分析呗

当 n =0时，怎么办？

n =1时，怎么办？

大于1又怎么办？

en~，是不是有点懂了，当我们处理递归时，我们可以有两种思维

当我们去思考它的终止条件是什么？你可能会被套娃，套成zz。

这时候，我们反过来想想这个值的初始值是多少，满足怎样的条件？（就比如说要大于，小于或等于某个条件）

是不是打开新思路了？‘’

思考递归的时候，横向思考：根据递推公式（个人理解递推公式跟数学的通项公式有点像）去思考

代码执行：纵向执行的（从上往下，一条条执行）

在坐的某些人，经常会自己代入某个数字，然后，拿着数字和代码一个个展开，很烧脑的

虽然我很喜欢这样，但是我只是在我掌握递归规律（递推公式）之后，对代码执行过程的好奇，去展开很小很小的范围。比如1、2、3之类的

太复杂了，对不起，我不玩了。。。

这点不值得提倡，我们需要的是掌握其递归规律，才是重中之重。

举个例子

求 n的阶乘(n==5)

1! == 1 //这就是我们的起始条件，也是我们的终止条件

2! == 2*1 == 2 * 1!

3! == 321 == 3 * 2!

4! == 432*1 == 4 * 3!

5! == 54321 == 5 * 4!

你发现了求 5！的值，它是 5 * （5-1）！

而 4！ == 4 * (4-1)！

3! == 3 * (3-1)!

2! == 2 * （2-1）！

以此类推直到遇到 1！时，他的返回值里不再带其他阶乘，此时 1！是不是很适合作为我们递归的终止条件

由此我们发现了递推公式为 n * （n-1）!

5! == 5 * 4!== 5 * 4 * 3! == 5 * 4 * 3 * 2! == 5 * 3 * 2 * 1(这里只是帮助你们理解，别学，上面的递推公式才是你们该学的)

代码实现

import java.util.Scanner;

public class UseOfMethods{

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int n = sc.nextInt();

System.out.println(factorial(n));

sc.close();//关闭输入

}

public static int factorial(int n){

if(1==n){

return 1;

}

return n*factorial(n-1);// n * (n-1)!

// (n-1)! == factorial(n-1); 即 factorial == ！

}

}// 图19，不懂没关系，我帮你搬下来，对着看

1! == 1 //这就是我们的起始条件，也是我们的终止条件

2! == 2*1 == 2 * 1!

3! == 321 == 3 * 2!

4! == 432*1 == 4 * 3!

5! == 54321 == 5 * 4!

你发现了求 5！的值，它是 5 * （5-1）！

而 4！ == 4 * (4-1)！

3! == 3 * (3-1)!

2! == 2 * （2-1）！

5! == 5 * 4!== 5 * 4 * 3! == 5 * 4 * 3 * 2! == 5 * 3 * 2 * 1

程序运行跟我们刚才藏宝殿是一样的，一层一层的抢。从最里面的开始抢

也就从我们终止条件开始

n == 1; return 1;// 这里的返回值是返回到调用它的上一层级（藏宝殿核心是第一层吗，抢完了，肯定去抢第二程啊）

n == 2 return 2* factorial(2-1) == 2 * 1 == 2

n == 3; return 3 * 2 == 6

n == 4; return 4 * 6 == 24

n == 5; return 5 * ==

考验你们的时候，在下面评论，看你们到底有没有看懂学会

递归的字面意思

递归 n * factorial(n-1)l n-1 就是它传过去的值，称为递， factorial（n-1）返回的值，称为归

结合称为：递归。

你赚的钱迟早是有一天会花完的。。。

赶快跟着我一起卷。

图19

在这里插入图片描述

再来看几道例题

求 1~n之间的和

import java.util.Scanner;

public class UseOfMethods {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int n = sc.nextInt();

System.out.println(sumadd(n));// 图 20

sc.colse()// 关闭输入

}

public static int sumadd(int n){

if(n==1){

return 1;

}

return n + sumadd(n-1);

}

}// 自己琢磨，不懂在下方评论，一起探讨。（n 比 n-1 多了1，看似废话，其实是真理）

图 20

图20

在这里插入图片描述

按照顺序打印一个数字的每一位（例如1234 打印出 1 2 3 4）

import java.util.Scanner;

public class UseOfMethods {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int n = sc.nextInt();

print(n);

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

最后

即使是面试跳槽，那也是一个学习的过程。只有全面的复习，才能让我们更好的充实自己，武装自己，为自己的面试之路不再坎坷！今天就给大家分享一个Github上全面的Java面试题大全，就是这份面试大全助我拿下大厂Offer，月薪提至30K！

我也是第一时间分享出来给大家，希望可以帮助大家都能去往自己心仪的大厂！为金三银四做准备！
一共有20个知识点专题，分别是：