九、Java的方法

书源丶

已于 2024-04-18 11:56:07 修改

阅读量41

点赞数

分类专栏： java基础文章标签： java 开发语言

于 2023-07-28 07:37:19 首次发布

本文链接：https://blog.csdn.net/qq_57423018/article/details/131972155

版权

java基础专栏收录该内容

26 篇文章 2 订阅

订阅专栏

在Java中本质上就是Api类方法的调用，那么什么说方法呢？
简单的来说方法就是具有某些功能的代码段：某段代码经常使用，所以使用大括号给他括起来，起一个名字，以后使用这个名字就可以代替这段代码，提高复用性，提高封装性，简化了软件设计的思维难度。
以代替这段代码，提高复用性，提高封装性，简化了软件设计的思维难度；
关于方法的认识首先我们要认识七个名词、修饰符、返回值类型、方法名、参数类型、参数列表、形式参数、方法体

//一般情况下，定义方法的语法：
1、修饰符： 可选，告诉编译器如何调用该方法，定义了访问类型。
2、返回值类型： 方法可能会返回值。有些方法不会反回值使用的关键字是void
3、方法名： 方法的实际名称，方法名和参数表共同构成方法签名
4、参数类型： 形式参数像是一个占位符。
//传递值给形势参数。这个值称为实参或变量。
5、参数列表：是指方法的参数类型，顺序和参数的个数，参数是可选的，方法可以不包含任何参数也叫空参。
6、形式参数：在方法被调用时用于接收外接输入的数据。
7、方法体：包含具体的语句，定义该方法的功能

    //方法调用:对象名.方法名（实参列表）
    //java支持两种调用方法的方式，根据方法的返回值来选择
    //当方法返回一个值，方法调用通常被当做一个值。例如 int larger =max(30,40);
    //如果方法返回值是void，方法调用一定是一条语句。例如 System.out.println("hello");

//方法；类似于其他语言的函数    用来完成特定功能的代码片段
方法 是解决一类问题的步骤的有序集合，具有原子性
方法包含于类或对象中 ，在程序中被创建 在其他地方被引用
方法的本意是功能块，一个方法只能完成一个功能利于扩展

1.方法的定义

方法是具有一定功能的代码块 行为=方法=成员方法

(1) 修饰符：现在不需要考虑，直接全部写成public static

(2) 返回值类型：要知道产出的数据类型，产出的内容的类型就是返回值类型

(3) 方法名称：给代码起的名字，只需要是合法的标识符即可

(4) 形式参数:声明了一些只有形，没有值量。声明时在内存中开辟对应的内存空间，空间中此时没有任何内容，未来想要使用这个方法，必须得给空间中赋值，所以在方法内部可以把当前声明的变量当做已知值来用

修饰符返回值类型方法名称(形式参数){

方法体语句;（完成功能的执行逻辑）

return 语句;
}
（return语句:方法可能会有产出要将这个产出的结果返回给调用者，使用return语句返回结果。 return 结果; 如果返回值类型不为void，则一定要写return语句）

返回值类型为void，表示没有产出，不需要写return语句，如果非要写可以写return; 表示结束方法

2.方法调用的三种形式

方法不调用就不会执行，只要调用必然执行

方法名称(实际参数); 只有值，没有类型，将值传递给方法参数赋值（ java都是值传递）

形参：声明变量（定义方法）

实参：给变量赋值（调用）

(1) 直接调用：

方法名称(实际参数);

适合返回值类型是void类型的，方法最终没有产出内容，只是想要在方法内打印某些内容
但是返回值不是void的也可以用，只是表示某些内容的执行

(2) 输出调用：

System.out.println(方法名称(实际参数));

返回值void类型不能用，因为没有返回值
适用于返回值类型不是void类型的，作用只是表示某些结果的打印

(3) 赋值调用：

方法的返回值类型新变量名 = 方法名称(实际参数);

返回值void类型不能用，因为没有返回值
适用于返回值类型不是void类型，作用是可以后续继续使用该方法产出的结果

class Demo18 {
	public static void main(String[] args) { 
		//直接调用  适用于返回值类型为void的情况 但是不是void也能用
		getSum(10,20);//实际参数和形式参数顺序要一一对应
		
		//输出调用  适用于返回值类型不是void的情况，只将方法的结果打印一次，不做保留
		//返回值为void不能用
		System.out.println(getSum(20,30));

		//赋值调用  适用于返回值类型不是void的情况，后续还要使用方法的结果
		int a = getSum(30,50);//a 80
		//a此时就代表了一个值
		//方法可以嵌套调用 ，但是不能嵌套定义
		System.out.println(getSum(getSum(getSum(30,50),50),30));
	}
	/*
			修饰符	返回值类型	方法名称(参数列表){ //参数列表也被称为形式参数
				方法体语句;
				return 语句;
			}
			//步骤：
			1.需求：定义一个方法，可以计算两个整数的和
			2.修饰符：现阶段都是public static
			3.返回值类型：方法的目的计算两个整数的和，返回最终的和，和为整数，类型为int
			4.方法名称：合法标识符即可  方法名小驼峰命名 getSum
			5.参数列表:方法在执行的过程中，需要外界的一些资源
			计算两个整数的和，首先得有两个整数，int a,int b
			此时ab代表未来一定会有的两个值，只有型，没有值
			方法体语句:计算两个整数的和 int sum = a + b;
			return语句:方法最终产出的结果是sum，需要将sum返回给调用者
			return sum;
			方法和方法是平级的关系，不能嵌套定义
			方法和方法没有先后顺序
			方法不调用不会执行
		*/
	public static int getSum(int a,int b){
		int sum = a + b;
		return sum;
	}
}

3.方法重载和命令行传参

1、方法的重载 ：重载就是在一个类中有相同的函数名称，但形参不同的函数。
2、实现理论：方法名称相同时，编译器会根据调用方法的个数，参数类型等去逐个匹配，选择对应的方法。如果匹配失败，则编译器会报错。
3、方法的重载规则： 单纯返回类型不同不能称为方法重载
第一方法名称必须相同
第二参数列表必须不同（个数不同，或者类型不同，参数的排列不同等）
第三方法返回类型可以相同也能不相同、

递归；A方法调用A方法，就是自己调用自己
递归结构包含两个部分:
    递归头：什么时候不调用自身方法。如果没有头，讲陷入死循环。
    地柜体：什么时候需要调用自身方法。

命令行传参
基本数据类型传参：传递的是值（值拷贝），形参的任何改变不影响实参

引用数据类型传参：传递的值（是地址值），可以通过形参影响实参

java使用的都是“栈”机制，“值”传递
//希望程序运行时给他传递消息，要依靠main（）函数实现
public class Demo4 {
    public static void main(String[] args) {
        //args.length 数组长度
        for (int i=0; i<args.length; i++ ){
            System.out.println("args["+i+"]:" +args[i]);
        }
    }
}

4.方法的注意事项

1、注意事项：

(1) 方法不能嵌套定义。可以嵌套调用，甚至可以自己调用自己(慎用递归)

(2) 方法的先后没有任何区别，需要类作为载体（都在类里，都是平级的关系。）

2、参数列表：

(1) 方法定义上的：

定义方法的时候使用的参数列表，形式参数都是带着数据类型，但是没有实际的值，使用逗号间隔

(2) 方法调用时的：实际参数

在调用方法的时候，只能是值，不要带数据类型，效果就是将值传递给形式参数，给形式参数中的变量赋值，实际参数的顺序和形式参数的顺序一定要一一对应

3、return语句：

(1) 表示方法结束，同时返回最终产出的结果

(2) 如果没有返回值，此时return一般不写，非要写，写return;表示结束方法

(3) 谁来调用这个方法，return语句，就将值返回给谁

(4) return语句返回的结果的类型，必须和方法定义上的返回值类型一致

1、循环结构有哪些格式
for 
while  
do while
2、什么时候用for，什么时候用while
  如果明确知道要循环的次数，一般用for循环
  如果不知道要循环多少次，一般用while
3、while和do...while的区别是什么
while 先判断 后执行
do while 先执行后判断  最少执行一次  
4、死循环的格式
让布尔表达式为true
5、循环控制语句有哪些，分别作用是什么
brake 终止某次循环
continue 跳过某次循环继续下次循环
6、方法的定义格式，及每一部分作用
修饰符  返回值类型 方法名 （形式参数）{
   方法逻辑
  return；结束方法
}
7、方法的调用有哪些形式，什么情况下用什么
三种：
直接调用 方法名（实参）

输出调用  Syetem.out.println（方法名（参数））；

赋值调用  返回值类型   变量名=方法名（参数）；

8、定义一个方法，可以判断两个小数是否相等
import java.util.Random;
class Demo01 {
	/*
	8、定义一个方法，可以判断两个小数是否相等
		修饰符：public static
		返回值类型：比较两个小数是否相等，返回的结果  true和false  boolean  是 和 否 String
		方法名称：isEquals
		参数列表：比较两个小数是否相等，首先得有两个小数  double a,double b;
		方法体语句:比较是否相等的过程   boolean c = a == b;
		return 语句：产出的结果是c   return c;
	*/
	//有参数有返回值
	public static boolean isEquals(double a,double b){
		boolean c = a == b;
		return c;
	}
9、定义一个方法，可以打印1-n的所有整数
	/*9.定义一个方法，可以打印1-n的所有整数
		修饰符  public static
		返回值类型: 打印到控制台，打印出就可以直接看到，不需要返回内容  void
		方法名称：print
		参数列表：打印1-n ， n不知道是多少需要一个n   int n
		方法体语句: for循环
		return语句:因为返回值类型为void所以不需要
	*/
	//有参数无返回值
	public static void print(int n){
		print1();print1();
		print1();
		if(n > 0){
			for(int i = 1; i <= n; i++){
				System.out.println(i);
			}
		}else{
			for(int i = n; i <= 1; i++){
				System.out.println(i);
			}
		}
	}
10、定义一个方法，可以打印“祝大家周末开心愉快”
	/*10、定义一个方法，可以打印“祝大家周末开心愉快”
		修饰符： public static
		返回值类型 不需要返回内容 void
		方法名称: print1
		参数列表：不需要借助外界的资源，所以不写 直接写括号就行
		方法体语句:打印这句话
		return 语句: 不需要写
	*/
	//无参数无返回值
	public static void print1(){
		System.out.println("祝大家周末开心愉快");
	}
11、定义一个方法，可以产出一个11~20的随机数
	/*
	11、定义一个方法，可以产出一个11~20的随机数
		修饰符  public static  
		返回值类型  产出的结果是一个随机数  int
		方法名称 getNumber
		参数列表 不需要外接传递资源  所以不写
		方法体语句: 使用Random 产生随机数
		return 语句: 将产生的随机数返回
	*/
	//无参数有返回值
	public static int getNumber(){
		Random r = new Random();
		//11-20
		//0-9
		int i = r.nextInt(10) + 11;
		return i;
	}
	public static void main(String[] args) {
		//直接调用  都可以
		//但是比较合适的 只能是返回值类型为void的
		print(10);
		print1();
		//输出调用   谁不能用 print 和print1返回值类型为void 不能用
		System.out.println(isEquals(1.1,2.2));
		System.out.println(getNumber());
		//赋值调用  此时 b和i后续还可以使用
		boolean b = isEquals(1.1,2.2);
		int i = getNumber();
	}
}
12、模拟用户登录，正确用户名123正确密码123通过键盘录入登录所需的用户名和密码，如果输入的数据正确，显示登录成功，如果错误，用户继续输入，除非输入正确，否则程序永远不会停止
import java.util.Scanner;
class Demo02 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(true){
			System.out.println("请输入用户名：");
			int username = sc.nextInt();
			System.out.println("请输入密码：");
			int password = sc.nextInt();
			if(username == 123 && password == 123){
				System.out.println("登录成功");
				//登录成功结束循环 break
				break;
			}else{
				System.out.println("登录失败,请重新输入");
			}
		}
	}
13、定义方法，方法内可以无限次录入一个整数，当输入数字为0的时候，返回刚才所有录入的整数的和
import java.util.Scanner;
class Demo03 {
	public static void main(String[] args) {
		System.out.println(getSum());
	}	
		//13、定义方法，方法内可以无限次录入一个整数，
	//当输入数字为0的时候，返回刚才所有录入的整数的和
	public static int getSum(){
		Scanner sc = new Scanner(System.in);
		int sum = 0;
		while(true){
			System.out.println("请输入一个整数，为0代表停止下一次输入");
			int i = sc.nextInt();
			if(i == 0){
				break;
			}
			//否则就继续求和
			sum += i;
			//最终返回和
		}
		return sum;
	}
}
14、键盘录入一个数，求该数到0的范围以内所有能被3整数但不能被5整除的数字的和
import java.util.Scanner;
class Demo04 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请录入一个整数");
		int n = sc.nextInt();
		//明确知道循环次数
		int sum = 0;
		for(int i = n; i >= 0; i--){
			if(i % 3 == 0 && i % 5 != 0){
				sum += i;		
			}
		}
		System.out.println(sum);
	}
	//14、键盘录入一个数，求该数到0的范围以内所有能被3整数但不能被5整除的数字的和
}
15、分析以下需求，并用代码实现
	(1)按照从大到小的顺序输出四位数中的个位=千位&&十位=百位(3553,2332,8229)的数字及个数
	(2)每行输出5个满足条件的数，之间使用空格间隔
class Demo05 {
	public static void main(String[] args) {
	/*	
	15、分析以下需求，并用代码实现
	(1)按照从大到小的顺序输出四位数中的个位=千位&&十位=百位(3553,2332,8229)的数字及个数
	(2)每行输出5个满足条件的数，之间使用空格间隔
		从大到小 输出四位数
	*/
		//获取四位数
		int count = 0;
		for(int i = 9999; i >= 1000; i--){
			//获取各个位上的数
			int g = i % 10;
			int s = i / 10 % 10;
			int b = i / 100 % 10;
			int q = i / 1000;
			if(g == q && s == b){
				System.out.print(i + " ");
				//上面的输出语句每执行一次说明有一个满足条件的数
				count++;
				//如果count个数能被5整除 说明够五个
				if(count % 5 == 0){
					System.out.println();
				}
			}
		}
		System.out.println("个数：" + count);
	}
}

5.方法的内存理解

1、栈内存:

jvm虚拟机要运行代码，jvm是运行java代码的容器，jvm本身也是一个软件，运行时需要在内存中开辟空间，jvm将占用的空间划分为五大区域，其中一块叫做栈内存

2、栈内存：

代码中的方法运行的区域，方法运行时需要在栈内存中开辟空间，方法调用时进入栈内存，方法运行完毕，出栈栈内存，释放占有的空间

6.方法的重载

1、有一些功能逻辑相同的代码，如果定义不同的方法名称，就导致记忆量非常大，不好用，为了简化这个过程，将相同的或者相似功能逻辑的代码，都使用同一个方法名

2、方法的重载：在同一个类中，方法名相同，参数列表不同，与返回值类型无关

3、参数列表不同的情况:参数名称不同不算重载

(1) 参数类型的不同

(2) 参数的个数不同

(3) 参数类型的顺序不同

注意：(参数名称不同不算)

class Demo07 {
	public static void main(String[] args) {
		//在调用的时候根据传递的参数的类型不用，匹配对应的方法
		System.out.println(getSum(1,2));
		//根据实际参数的类型，匹配对应形式参数的类型，一致则进行调用
		System.out.println(getSum(1,2,3));
		System.out.println(getSum(1.1,2.2,3.2));
	}
	//计算两个整数的和
	public static int getSum(int a,int b){
		return a + b;
	}
	/*
	方法的参数名称 不同  不算
	public static int getSum(int c,int d){
		return c + d;
	}
	*/
	//在同一个类型中 方法名相同  
	//参数列表不同：
	//1、参数的个数的不同
	//2、个数相同，但是类型不同
	//3、个数相同，类型的顺序不同也算  
	//与返回值类型无关
	//计算三个整数的和
	public static int getSum(int a,int b,int c){
		return a + b + c;
	}
	//计算三个小数的和
	public static double getSum(double a,double b,double c){
		return a + b + c;
	}
	//计算两个小数的和
	public static double getSum(double a,double b){
		return a + b;
	}
	//方法中的形式参数的类型，是有严格的顺序区分的
	//类型顺序的不同，也算重载
	//计算一个整数和一个小数
	public static double getSum(int a,double b){
		return a + b;
	}
	//计算一个小数和一个整数
	public static double getSum(double a,int b){
		return a + b;
	}
}