方法的使用

最新推荐文章于 2022-03-14 10:20:49 发布
最新推荐文章于 2022-03-14 10:20:49 发布
阅读量224 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_yifei/article/details/115669348
版权

1. 方法的基本用法

1.1什么是方法(method)

方法就是一个代码片段. 类似于 C 语言中的 “函数”.
方法存在的意义(不要背, 重在体会):
1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子.
回忆一个之前写过的代码: 计算 1! + 2! + 3! + 4! + 5!

int sum = 0;
for (int i = 1; i <= 5; i++) {
    int tmp = 1;
    for (int j = 1; j <= i; j++) {
        tmp *= j;
   }
    sum += tmp; }
System.out.println("sum = " + sum);

这个代码中使用双重循环, 比较容易写错.
接下来我们可以使用方法来优化这个代码.

1.2 方法定义语法

基本语法

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

代码示例: 实现一个方法实现两个整数相加

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

注意事项

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

1.3 方法调用的执行过程

基本规则

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

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

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

代码示例: 计算 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 实参和形参的关系(重要)

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


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.
解决办法: 传引用类型参数 (例如数组来解决这个问题)

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.5 没有返回值的方法

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

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

另外, 如刚才的交换两个整数的方法, 就是没有返回值的.
2. 方法的重载
有些时候我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载.
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 方法.

那么是不是应该创建这样的代码呢?
代码示例

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;
 }
}

这样的写法是对的(例如 Go 语言就是这么做的), 但是 Java 认为 addInt 这样的名字不友好, 不如直接就叫 add
2.2 使用重载
代码示例

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 重载的规则
针对同一个类:
方法名相同
方法的参数不同(参数个数或者参数类型)
方法的返回值类型不影响重载.
代码示例

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. 方法递归

3.1 递归的概念

一个方法在执行过程中调用自身, 就称为 “递归”.
递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
例如, 我们求 N!
起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.
递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!\

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

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 递归执行过程分析

递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 “方法的执行过程”, 尤其是 “方法执行结束
之后, 回到调用位置继续往下执行”.
代码示例: 递归求 N 的阶乘, 加上日志版本

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

执行过程图

程序按照序号中标识的 (1) -> (8) 的顺序执行.
关于 “调用栈”
方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系. 称为调用栈.
每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息.
后面我们借助 IDEA 很容易看到调用栈的内容.

3.3 递归练习

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

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

代码示例2 递归求 1 + 2 + 3 + … + 10

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

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

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

代码示例4 求斐波那契数列的第 N 项
斐波那契数列介绍: https://baike.sogou.com/v267267.htm?
fromTitle=%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97

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

当我们求 fib(40) 的时候发现, 程序执行速度极慢. 原因是进行了大量的重复运算.

class Test { 
 public static int count = 0; // 这个是类的成员变量. 后面会详细介绍到. 
 public static void main(String[] args) { 

 System.out.println(fib(40)); 
 System.out.println(count); 
 } 
 public static int fib(int n) { 
 if (n == 1 || n == 2) { 
 return 1; 
 } 
 if (n == 3) { 
 count++; 
 } 
 return fib(n - 1) + fib(n - 2); 
 } 
} 
// 执行结果
102334155 
39088169 // fib(3) 重复执行了 3 千万次.

可以使用循环的方式来求斐波那契数列问题, 避免出现冗余运算.

public static int fib(int n) { 
 int last2 = 1; 
 int last1 = 1; 
 int cur = 0; 
 for (int i = 3; i <= n; i++) { 
 cur = last1 + last2; 
 last2 = last1; 
 last1 = cur; 
 } 
 return cur; 
}
java_yifei
关注
第26讲： Python中以is开头的字符串方法使用案例
江晓龙的博客
03-23 1万+
主要用来判断字符串是否是Python中的关键字，需要导入keyword模块中的iskeyword方法。需要注意的是六、VI这种大写数字、英文数字在Python也被认为是数字。主要是判断字符串是否是标准的字符串，没有特殊字符串值之类想。
头歌--Java入门 - 方法的使用
m0_56638814的博客
04-10 7210
头歌实践--Java入门 - 方法的使用
JAVA编程(递归典型题目)
03-27
JAVA编程(递归典型题目)关于递归的~
使用方法
热门推荐
飞星的博客
11-11 14万+
使用方法 晚上洗头后吹干 用发膜，用完发膜用 卷发修复。 使用方法：清洗头发过后，干发帽包一会儿，而后用吹风机将发根吹至7成干，挤出一点点均匀涂抹于头发上（倒抓的手法），丝毫没有黏腻感，最后待头发自然风干。 维生素a 一天一粒 人工泪液 每次一到两滴，一天一只，不舒服就不用了 ...
Java—方法的使用
一朵花花
08-12 1502
方法的基本用法 方法定义 方法就是一个功能 方法就是一个代码片段，类似于 C 语言中的 “函数” 基本语法格式： //方法定义 修饰符 返回值类型 方法名称([形式参数列表 ...]){ 方法体; [return 返回值]; } 注意事项： 在现阶段，方法的修饰暂时采用—> public static 固定搭配 [ ]内部的表示可有可无 方法必须定义在类中 方法名要采用小驼峰的形式 Java中的返回值可有可无，看业务需求，若有返回值，返回值类型需要和方法的返回值类型匹配 行书参数列表：形参
springboot静态方法使用配置文件的参数
n009ww的博客
08-22 6473
编程时经常需要写一些工具类，大部分的工具类都是static的方法，由于static方法中不能引用非静态的变量，若我们需要使用配置文件中的变量该如何弄呢？请看下面的例子 springboot写法 /** * jsoup通过代理爬取数据 */ @Component public class JsoupUtils { private static Logger logger = ...
Map的使用方法
我的博客
02-25 5124
Map Map是一个键值对形式的集合，类似object，区别是Map允许任何的键（key） Map语法 new Map() 创建map map.set(key, value) 存储键值对 map.get（key）根据key获取value，没有返回undefined map.has（key）key存在返回true， 没有返回false map.delete（key）根据key删除指定项 map.clear（）清空map map.size 返回长度 const map = new Map(); ma.
JS基础使用
m0_66757763的博客
02-09 2605
1.JS的三种使用方式：行内js（在html标签上直接写js代码） 外部js（定义js文件，通过script标签的src属性引入对应的js文件，如果script标签设置了src属性，则在srcipt双标签中的js文件不会生效） 内部js（在script标签中写js代码，script标签可以放在head或hody中，建议放在body中） 2.js语句：js代码一行为单位，代码从上往下执行，一行一条语句 语句可以不加分号结尾，但若一行定义多条语句，每句语句只以分号结尾 表达式不需要加分号，加了会引起报错 3
java笔试涉及编程题
oh geez
10-21 1445
1、如何实现字符串的反转及替换？ 当我们要将一个字符串翻转或者替换时，方法很多，可以自己写实现也可以使用String或StringBuffer/StringBuilder中的方法。有一道很常见的面试题是用递归实现字符串反转，代码如下所示： public static String reverse(String originStr) { if(originStr == null || originStr.length() <= 1) return ori
Java介绍方法
MoXie_的博客
08-07 205
在程序中包含比较复杂的逻辑和功能时，可以将这些功能分解为若干个子功能分别实现，而这些子功能组合在一起，便形成了完整的程序。 方法定义在类中，通过对象完成对它们的调用，最后组成整个程序。通俗的讲，程序就是各个对象对方法的调用。 在Java语言中，按照方法定义方式的不同，可以将其分为两种: 系统方法，无需定义，直接调用即可，如：Scanner类的nextInt()等 自定义方法，则为用户自己编写实现。 ...
Java 用法
Z小t的专栏
05-11 249
1、date 和 calendar1.计算某一月份的最大天数Calendar time=Calendar.getInstance(); time.clear(); time.set(Calendar.YEAR,year); //year 为 int time.set(Calendar.MONTH,i-1);//注意,Calendar对象默认一月为0 int day=time.ge
Java递归练习
Zincy星辰
03-14 1466
1. 递归求N的阶乘 //递归求n的阶乘 public class test { //求n的阶乘方法 public static int func(int n) { if (n == 1) { return 1; } int tmp = n * func(n-1); return tmp; } public static void main(String[] args) { ..
나 이나用法
shuangshui的专栏
11-20 9300
<br />나/이나的用法<br /><br /> （1）“나/이나”表示让步选择，或者最次的选择。有时还有虽然是最好的，但是语气上好像不满足的样态。“나”用在开音节的体词或状语后，“이나”用在闭音节的体词或状语后。<br /><br /> 如：<br /> 우리는 참견말고 굿이나 보다 떡이나 먹자.<br /> 咱们别参与什么了，看看热闹等结果吧。<br /><br /> 그것이나 가져라.<br /> 就拿那个吧。<br /><br /> 아무것이나 가져 와라.<br /> 随便拿
JAVA使用方法
weixin_44771613的博客
08-13 483
JAVA使用方法JAVA使用方法初步认识方法带参数的方法如何重载方法如何创建递归方法 JAVA使用方法 本次将讨论如何使用方法来根据功能对代码进行分组，详细讨论方法的基础知识、具有返回值的方法以及如何将参数传递给方法。如何重载方法，以及如何使递归方法。 初步认识方法 在面向对象编程中，类有两个重要部分，即数据和方法，方法有时也称为函数。构造方法，构造方法是类里面一个特殊的方法，用来初始化对象。类中的数据表示对象的属性，而方法表示对象的行为。 方法是一种根据代码的功能和用途将代码分组到特定块中的技术。将一个
Java基本用法
fjaljda的博客
02-18 380
Java面向对象编程 继承 extends关键字 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下： class 父类 { } class 子类 extends 父类 { } 注意： Java 不支持多继承，但支持多重继承。 implements关键字 使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。 //定义A,B接口，A接口定义eat，sleep抽象
java中的基本用法
银滴子的博客
08-01 759
java中的基本语法
Java递归练习题
无区新手的博客
02-12 1627
1,从键盘接收一个文件夹路径,统计该文件夹大小 package demo; import java.io.File; import java.util.Scanner; public class Test1 { public static void main(String[] args) { File file = getDirectory(); System.out.prin...
SSM框架原理、作用及使用方法详解
SSM框架原理、作用及使用方法 SSM框架是springMVC、spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层、controller层、service层、DAO层四层。使用springMVC负责请求的转发和视图管理，spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值