Java基础教程

文章36 |   阅读 18634 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

Java基础系列12-方法

转x33g5p2x  于2021-12-18 转载在 其他  
字(6.2k)|赞(0)|评价(0)|浏览(468)

一.方法概述

假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。

1.1 方法的定义及格式

方法其实就是完成特定功能的代码块，在很多语言里面都有函数的定义 , 函数在Java中被称为方法。

方法实例:

  1. package com.groupies.base.day05;
  2. import org.junit.Test;
  4. public static void main(String[] args) {
  5.     int a = 1;
  6.     //调用有返回值方法 结果为2
  7.     System.out.println(AddOne(a));
  8.     //无法调用SayHello方法
  9.     //因为这里main方法是static修饰的静态类，而SayHello方法是非静态的
  10.     //反之，非静态方法可以调用静态方法，
  11.     SayHello();
  12. }
  14. //有返回值,赋值调用
  15. public static int AddOne(int i){
  16.     return i + 1;
  17. }
  19. //无返回值，static修饰的静态类不能调用
  20. public void SayHello(){
  21. 	System.out.println("hello");
  22. }

1.2 方法格式的解释

方法的格：

  1. 修饰符: 目前记住 public static 即可，还有 private、public、protected 等
  2. 返回值类型: 用于限定返回值的数据类型,byte,short,int,long,float,double,char,boolean。
  3. 方法名：方便我们调用方法,调用方法时通过方法名调用，命名规范 lowerCamelCase（小驼峰）。
  4. 传入参数：调用方法时可以要求传入参数，在方法内使用（可以没有参数）。
    1)参数类型：用于限定调用方法时传入的数据的数据类型。
    2)参数名：用于接收调用方法时传入的数据的变量。
  5. 方法体：完成特定功能的代码。
  6. return 返回值： 结束方法，并且把返回值带给调用者
  1. /* 1.有返回值，带参 */
  2. 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,...) {
  3. 	方法体;
  4. 	return 返回值;
  5. }
  7. /* 2.无返回值 带参 */
  8. 修饰符 void 方法名(参数类型 参数名1,参数类型 参数名2,...) {
  9. 	方法体;
  10. }
  12. /* 3.有返回值，无参 */
  13. 修饰符 返回值类型 方法名() {
  14. 	方法体;
  15. 	return 返回值;
  16. }
  18. /* 4.无返回值 无参 */
  19. 修饰符 void 方法名() {
  20. 	方法体;
  21. }

二.方法案例

2.1 定义求和方法

两个明确:

  1. 返回值类型：其实就是要我们明确方法结果的数据类型
  2. 参数列表：其实就是要我们明确有几个参数参加，并且每个参数都是什么数据类型的

注意事项：方法与方法是平级关系，不能嵌套定义

代码:

  1. package Java_study;
  3. public class fangfa1 {
  4. 	public static void main(String[] args) {
  5. 		//定义两个int类型的变量a,b
  6. 		int a = 1, b = 2;
  7. 		//调用明确返回值的方法，返回结果为 a + b = 1 + 2 = 3
  8. 		System.out.println(add(a, b));
  9. 				
  10. 	}
  11. 	
  12. 	/** * 需求: 求两个数据之和的案例 * * 两个明确: * 返回值类型: int * 参数列表: int a, int b */
  13. 	public static int add(int a, int b) {
  14. 		int c = a + b;
  15. 		return c;
  16. 	}
  18. }

测试记录:

  1. 3

2.2 方法调用之有明确返回值的方法调用

有明确返回值的方法调用：

  1. 单独调用，没有意义
  2. 输出调用，有意义，但是不够好，因为我不一定非要把结果输出
  3. 赋值调用，推荐方式

代码:

  1. package Java_study;
  3. public class fangfa2 {
  4. 	public static void main(String[] args) {
  5. 		// 单独调用
  6. 		// sum(10,20);
  7. 		
  8. 		// 输出调用
  9. 		// System.out.println(sum(10, 20));
  10. 		
  11. 		// 赋值调用
  12. 		int s = add(10, 20);
  13. 		
  14. 		// s:30
  15. 		print(s, "s");
  16. 	}
  17. 	
  18. 	/** * 有明确返回值的方法的调用： * A:单独调用,没有什么意义。 * B:输出调用,有意义,但是不够好，因为我可能需要对求和的结果进行进一步的操作 * C:赋值调用 */
  19. 	public static int add(int a, int b) {
  20. 		return a + b;
  21. 	}
  22. 	
  23. 	/** * 快捷打印的方法 * @param a 数值类型a的值 * @param s 数值类型a的变量名 */
  24. 	public static void print(int a, String s) {
  25. 		System.out.println(s + ":" + a);
  26. 	}
  28. }

测试记录:

  1. s:30

2.3 方法调用图解

三.方法练习

3.1 求两个数据较大值

需要Scanner键盘录入

代码:

  1. package Java_study;
  2. import java.util.Scanner;
  4. /** * * @author 只是甲 * @date 2021-06-23 * 方法: 求两个数较大值 */
  6. public class fangfa3 {
  7. 	/** * 需求：键盘录入两个数据，返回两个数中的较大值 * * 思考： * 键盘录入两个数据的动作放在哪里比较合适呢? * 假如键盘录入数据的动作放在了返回两个数中的较大值的方法里面，那么，我如果不想返回键盘录入 * 的数据的较大值，我就想返回两个固定值的较大值，我们是不是又得修改代码了。这个时候发现 * 是不合理的，所以我们应该把键盘录入数据的动作放在main方法中。 * * 命名习惯问题： * 类： * 如果是一个单词，首字母大写。Student * 如果是多个单词，每个单词的首字母大写。HelloWorld * * 方法：和变量的命名是一样的规则。 * 如果是一个单词，首字母小写。sum() * 如果是多个单词，从第二个单词开始，每个单词首字母大写。getMax() */	
  8. 	public static void main(String[] args) {
  9. 	    // 调用NewScanner方法创建对象实例
  10. 	    Scanner sc = newScanner();
  11. 	    System.out.println("请依次输入两个数值:");
  12. 	    System.out.println("两个数中较大值为:" + getMax(sc.nextInt(), sc.nextInt()));
  13. 	}
  14. 	    
  15. 	/** * @Description 创建键盘录入对象方法，这样可以少打一个System.in * @return 键盘录入对象实例 */
  16. 	public static Scanner newScanner() {
  17. 	    return new Scanner(System.in);
  18. 	}
  19. 	    
  20. 	/** * * @param a 传入第一个int值 * @param b 传入第二个int值 * @return 返回其中较大的一个值 */
  21. 	public static int getMax(int a, int b) {
  22. 	    //三元运算符
  23. 	    return (a > b) ? a : b;
  24. 	}
  25. 		
  27. }

测试记录:

  1. 请依次输入两个数值:
  2. 100
  3. 99
  4. 两个数中较大值为:100

3.2 void修饰的方法调用

需求：
写一个方法，在控制台输出10次HelloWorld
没有明确返回值的函数调用，其实就是void类型方法的调用，只能单独调用

代码:

  1. package Java_study;
  3. /** * * @author 只是甲 * @date 2021-06-23 * void 修饰的方法调用 */
  4. public class fangfa4 {
  5. 	public static void main(String[] args) {
  6. 		printHelloWorld();
  7. 	}
  8. 	
  9. 	public static void printHelloWorld() {
  10. 		for (int i = 0; i < 10; i ++) {
  11. 			System.out.println("HelloWorld");
  12. 		}
  13. 	}
  15. }

测试记录:

  1. HelloWorld
  2. HelloWorld
  3. HelloWorld
  4. HelloWorld
  5. HelloWorld
  6. HelloWorld
  7. HelloWorld
  8. HelloWorld
  9. HelloWorld
  10. HelloWorld

3.3 在控制台打印1到n的数据

代码:

  1. package Java_study;
  3. /** * @author 只是甲 * @date 2021-06-23 * @remark 在控制台打印1到n的数据 */
  4. public class fangfa5 {
  5. 	public static void main(String[] args) {
  6. 		// 调用方法结果
  7. 		printNumber(3);
  8. 	}
  9. 	
  10. 	 /** * 打印1到n之间的数据(n是调用的时候传递过来的) * * 两个明确： * 返回值类型：void * 参数列表：int * * @param n 1到n之间的数，这里传入n的值 */
  11. 	public static void printNumber(int n) {
  12. 		for (int i = 1; i <= n; i++) {
  13. 			System.out.println(i);
  14. 		}
  15. 	}
  17. }

测试记录:

  1. 1
  2. 2
  3. 3

四.方法重载

方法重载是在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载特点:

  1. 与返回值类型无关，只看方法名和参数列表
  2. 在调用时，虚拟机通过参数列表的不同来区分同名方法

4.1 求和的方法重载

代码:

  1. package Java_study;
  3. /** * * @author 只是甲 * @date 2021-06-23 * @remark 方法重载，求和 */
  4. public class fangfa6 {
  5. 	/* * 方法重载：在同一个类中，出现了方法名相同的情况。 * * 方法重载的特点： * 方法名相同，参数列表不同。方法重载与返回值无关。 * * 参数列表不同： * 参数的个数不同。 * 参数对应的数据类型不同。 * * 注意事项： * 在调用方法的时候，java虚拟机会根据方法名及参数列表的不同来区分方法。 */
  6. 	public static void main(String[] args) {
  7. 		// 定义两个变量
  8. 		int a = 10;
  9. 		int b = 20;
  10. 		// 求和
  11. 		int result = sum(a, b);
  12. 		// result:30
  13. 		System.out.println("result:" + result);
  14. 		
  15. 		//定义变量
  16. 		int c = 30;
  17. 		int result2 = sum(a, b, c);
  18. 		//result2:60
  19. 		System.out.println("result2:" + result2);
  20. 	}
  21. 	
  22. 	/** * 方法重载1：两个参数时的求和 * @param a 参数1 * @param b 参数2 * @return 参数1 + 参数2 */
  23. 	public static int sum(int a, int b) {
  24. 		return a + b;
  25. 	}
  26. 	
  27. 	/** * 方法重载2：三个参数时的求和 * @param a 参数1 * @param b 参数2 * @param c 参数3 * @return 参数1 + 参数2 + 参数3 */
  28. 	public static int sum(int a, int b, int c) {
  29. 		return a + b + c;
  30. 	}
  32. }

测试记录:

  1. result:30
  2. result2:60

4.2 比较两个数据是否相等

同一个方法，通过重载的方式，可以对比不同的数据类型。

代码:

  1. package Java_study;
  3. /** * * @author 只是甲 * @date 2021-06-23 * @remark 方法重载-比较两个数据是否相等 * */
  4. public class fangfa7 {
  5. 	/** * 需求：比较两个数据是否相等。 * 参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型， * 并在main方法中进行测试 */
  6. 	public static void main(String[] args) {
  7. 		// 不相等
  8. 		System.out.println(compare(10, 20));
  9. 		// 不相等
  10. 		System.out.println(compare((byte)10, (byte)20));
  11. 		// 不相等
  12. 		System.out.println(compare((short)10, (short)20));
  13. 		// 不相等
  14. 		System.out.println(compare(10L, 20L));
  15. 	}
  16. 	
  17. 	/** * 方法重载1：两个 short 类型参数比较是否相等 * @param a short类型参数1 * @param b short类型参数2 * @return 返回判断结果，参数1和参数2是否相等 */
  18. 	public static String compare(short a, short b) {
  19. 		return (a == b) ? "相等!" : "不相等!";
  20. 	}
  21. 	
  22. 	/** * 方法重载2：两个 int 类型参数比较是否相等 * @param a int类型参数1 * @param b int类型参数2 * @return 返回判断结果，参数1和参数2是否相等 */
  23. 	public static String compare(int a, int b) {
  24. 		return (a == b) ? "相等" : "不相等!";
  25. 	}
  26. 	
  27. 	/** * 方法重载3：两个 long 类型参数比较是否相等 * @param a long类型参数1 * @param b long类型参数2 * @return 返回判断结果，参数1和参数2是否相等 */
  28. 	public static String compare(long a, long b) {
  29. 		return (a == b) ? "相等" : "不相等!";
  30. 	}
  32. }

测试记录:

  1. 不相等!
  2. 不相等!
  3. 不相等!
  4. 不相等!

五. 方法参数类型详解

5.1 方法中参数传递

5.1.1 方法参数是基本类型的情况和图解

方法的参数是基本类型的时候：形式参数的改变不影响实际参数

  1. 形式参数：用于接收实际数据的变量;
  2. 实际参数：实际参与运算的变量。

代码:

  1. package Java_study;
  3. /** * * @author 只是甲 * @date 2021-06-23 * @remark 方法的基本类型的情况和图解 */
  4. public class fangfa8 {
  5. 	 public static void main(String[] args) {
  6. 	        // 定义变量
  7. 	        int a = 10;
  8. 	        int b = 20;
  9. 	        System.out.println("a:" + a + ",b:" + b);// a:10,b:20
  10. 	        change(a, b);
  11. 	        System.out.println("a:" + a + ",b:" + b);// a:10,b:20
  12. 	    }
  14. 	    public static void change(int a, int b) { 
  15. 	        System.out.println("a:" + a + ",b:" + b);// a:10,b:20
  16. 	        a = b; // a=20;
  17. 	        b = a + b;// b=40;
  18. 	        System.out.println("a:" + a + ",b:" + b);// a:20,b:40
  19. 	    }
  21. }

测试记录:

  1. a:10,b:20
  2. a:10,b:20
  3. a:20,b:40
  4. a:10,b:20

方法参数是基本类型的情况和图解：

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/113975052

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/119736908

内容来源于网络，如有侵权，请联系作者删除！

上一篇：数组简介
下一篇：面向对象简介
Javajava方法重载

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com