方法的定义以及方法的调用

发布时间:2024年01月18日

”方法“一词来源于日常生活中用语,意思是”指为获得某种东西或达到某种目的而采取的手段与行为方式”。在编程语言中,”方法“有时也被称为”函数”,其含义主要是”实现编程中某个具体功能的办法或方式,是一系列步骤的总结“。

定义方法:

语法结构

/访问修饰符[private/public] static 返回值类型 方法{

}

【访问修饰符】:代表该方法可以适用的范围

【static关键字】:该方法通过类名调用(如果是当前类,可以直接调用,类名省略)

【返回值类型】:该方法调用后,产生并返回的结果类型(如果没有返回值,需要使用void)

【方法名称】:按照该方法的作用,为方法命名

【方法参数】:按照该方法的作用,为方法设计参数的个数和类型

方法调用:

1.在当前类中,可以直接调用方法(因为方法使用了static关键字)

2.不在当前类中需要通过"类名.方法名"调用

方法的参数:

参数的作用:方法在执行过程中,有时需要通过调用时所传入的参数,来决定执行的逻辑。例如︰转账的方法,需要通过参数来决定转账的金额和银行卡号﹔发送验证码短信的方法,需要通过参数来决定发送的目标手机号码。
参数传递时,必须按照方法的参数声明进行传参∶类型一致;顺序一致;数量一致设计方法时,参数不是必须存在的,按照功能逻辑要求,按需使用即可

方法的返回值:

返回值的作用:将方法执行的最终结果,通过return 关键字,返回至方法调用处。

例如︰随机抽奖的方法,需要通过返回值将中奖的结果返回
确认订单的方法,需要通过返回值将订单是否生成的结果返回
√方法的返回值必须与方法声明时的返回值类型保持一致
√如果一个方法无需返回值,则需要使用void关键字进行声明。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;

public class demo02 {
	//自定义函数(方法)
	//函数(方法):给一个具有独立功能的代码片段进行“命名”,并通过该方法调用
	public static void createOrderNo() {
		
		//生成一个订单编号
		//订单编号格式规则
		//当前日期+流水号(5位随机数字+字母)
		//例如:202401155AX32B
		//当前日期转换成字符串
		//方式1:
		//toString():按照默认日期格式yyyy-MM-dd,转换成字符串
		//String orderNo=LocalDate.now().toString();
		
		//方式2:
		//format():按照指定日期格式yyyy年MM月dd日,转换成字符串
		//String orderNo1=LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
		
		//format():按照指定日期格式yyyyMMdd,转换成字符串
		String orderNo=LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
		System.out.println(orderNo);
		
		//流水号
		String traceId=UUID.randomUUID().toString().substring(0,5).toUpperCase();
		System.out.println(traceId);
		
		//订单编号=当前日期+流水号
		orderNo=orderNo+traceId;
		System.out.println("新订单编号:"+orderNo);

		
	}
	
	//main主函数(方法)
	public static void main(String[] args) {
		
		//在当前类中,可以直接调用方法(因为方法使用了static关键字)
		createOrderNo();
		
		
		

	}

}
public class demo03 {

	public static void main(String[] args) {
		// 创建新订单编号
		//调用demo02类的createOrderNo()
		//需要通过"类名.方法名"调用
		
		demo02.createOrderNo();
		
	}

}

运行结果:

20240115
C993B
新订单编号:20240115C993B

查找3个int类型整数中的最大值?

public class demo04 {
	//定义方法
	//语法结构
	//访问修饰符[private/public] static 返回值类型 方法{
	//
	//}
	
	//【访问修饰符】:代表该方法可以适用的范围
	//【static关键字】:该方法通过类名调用(如果是当前类,可以直接调用,类名省略)
	//【返回值类型】:该方法调用后,产生并返回的结果类型(如果没有返回值,需要使用void)
	//【方法名称】:按照该方法的作用,为方法命名
	//【方法参数】:按照该方法的作用,为方法设计参数的个数和类型

		// 方法的定义
		//查找3个int类型整数中的最大值
		private static int max(int a ,int b, int c) {
			int ret=(a>b)?(a>c?a:c):(b>c?b:c);
			return ret;
		}
		public static void main(String[] args) {
		//方法调用
		int val1=max(15,23,17);
		System.out.println("结果1:"+val1);
		
		int val2=max(17,24,27);
		System.out.println("结果1:"+val2);
	}

}

运行结果:

结果1:23
结果1:27

?动态参数

1.一个方法中只能有一个参数的动态参数

2.动态参数必须是方法的最后一个参数√动态参数在方法中,可做为一个数组使用

查找N个int类型整数中的最大值

public class demo05 {

		// 动态参数
		//查找N个int类型整数中的最大值
		public static int maxN(int... ns) {
			
			int ret=ns[0];
			for(int i=1;i<ns.length;i++) {
				if(ns[i]>ret) {
					ret=ns[i];
				}
			}
			return ret;
		}
		
		public static void main(String[] args) {
			//可以传入N个整数
			int max=maxN(4,61,8,23,178,5);
			System.out.println(max);
		}

}

运行结果:

178

两数之和?

参数target:需要查找的目标值

参数numbers:需要查找的一组整数(动态参数)

注意:动态参数必须是整个参数列表的最后1部分

public class demo06 {

	public static void main(String[] args) {
		String ret = twoSum(5,1,4,2,3,4,5,6,7,8,9);
		System.out.println(ret);
	}
	//两数之和
	//参数target:需要查找的目标值
	//参数numbers:需要查找的一组整数(动态参数)
	//注意:动态参数必须是整个参数列表的最后1部分
	
	public static String twoSum(int target,int ...numbers) {
		String result="";
		outter:
		for(int i=0;i<numbers.length-1;i++){
			for(int k=i+1;k<numbers.length;k++) {
				if(numbers[i]+numbers[k]==target) {
				//3+4=7
				//result=numbers[i]+"+"+numbers[k]+"="+(numbers[i]+numbers[k]);
				
				//String.format():格式化拼接
				result=String.format("%d+%d=%d", numbers[i],numbers[k],numbers[i]+numbers[k]);
				
				//方式1:
//				break outter;
				//方式2:
				return result;
			}
		}
	}
	return result;
 }
}

运行结果:

1+4=5

字符串逆序

import java.util.Arrays;

public class demo07 {

	public static void main(String[] args) {
		// 方法的调用
		String ret=reverse("忽如一夜春风来");
		System.out.println(ret);

	}
	
	//方法的定义
	//字符串逆序
	//参数s:原始字符串
	public static String reverse(String s) {
		String ret="";
		for(int i=s.length()-1;i>0;i--) {
			char c=s.charAt(i);
			ret=ret+c;
		}
		return ret;
	}
//	
//	public static String reverse(String s) {
//		String ret="";
//		for(int i=0;i<s.length();i++) {
//			char c=s.charAt(i);
//			ret=c+ret;
//		
//		}
//		return ret;
//	}

}

运行结果:

来风春夜一如忽

获取任意整数的位数?

方式1:计算该整数以10为底的对数+1

方式2:通过循环

public class demo08 {

	public static void main(String[] args) {
		
		int n1=12345;
		int len1=numberLength(n1);
		System.out.println(n1+"的长度是:"+len1+"位");
		
		int n2=789456;
		int len2=numberLength(n2);
		System.out.printf("%d的长度是%d位!",n2,len2);
	}
		//获取任意整数的位数
		public static int numberLength(int number) {
			//方式1:计算该整数以10为底的对数
			//int ret=(int)(Math.log10(number)+1);
			//return ret;
			
			//方式2:通过循环
			int ret=0;
			while(number !=0) {
				System.out.println("个位数值:"+number%10);
				ret++;//记录位数
				number=number/10;
			}
			
		return ret;
	}

}

运行结果:

个位数值:5
个位数值:4
个位数值:3
个位数值:2
个位数值:1
12345的长度是:5位
个位数值:6
个位数值:5
个位数值:4
个位数值:9
个位数值:8
个位数值:7
789456的长度是6位!

基本数据类型的传参:传递“值”?

import java.util.Arrays;

public class demo09 {

	public static void main(String[] args) {
		// 基本数据类型的传参:传递“值”
		int n1=3,n2=5;
		System.out.printf("改变前:,数字%d,数字%d\n",n1,n2);
		grow1(n1,n2);
		System.out.printf("改变后:,数字%d,数字%d\n",n1,n2);

	}
	
	public static void grow1(int a,int b) {
		a=a<<1;
		b=b<<1;
		System.out.printf("改变中:,数字%d,数字%d\n",a,b);
	}

}

运行结果;

改变前:,数字3,数字5
改变中:,数字6,数字10
改变后:,数字3,数字5

引用数据类型的传参:传递内存地址?

import java.util.Arrays;

public class demo10 {

	public static void main(String[] args) {
		// 定义数组,保存一组“需要进行扩容”的整数
		int[] array= {1,2,3,4,5};
		System.out.println("改变前:"+Arrays.toString(array));
		System.out.println("数组array的内存地址:"+array);
		
		//引用数据类型的传参:传递内存地址
		//array传递的是内存地址
		grow2(array);
		System.out.println("改变后:"+Arrays.toString(array));

	}
	//引用数据类型的传参
	//参数numbers接受的是内存地址
	
	public static void grow2(int[] numbers) {
		System.out.println("数组numbers的内存地址:"+numbers);
		for(int i=0;i<numbers.length;i++) {
			numbers[i]=numbers[i]<<1;
		}
		
		System.out.printf("改变中:");
		for(int n:numbers) {
			System.out.print(n+"\t");
		}
		System.out.println();
	}
}

运行结果:

改变前:[1, 2, 3, 4, 5]
数组array的内存地址:[I@1eb44e46
数组numbers的内存地址:[I@1eb44e46
改变中:2	4	6	8	10	
改变后:[2, 4, 6, 8, 10]

数组的排序(冒泡排序)查找(二分查找)方法的定义与调用?

import java.util.Arrays;

public class demo11 {

	public static void main(String[] args) {
		int[] arr= {4,3,2,8,1,9,4,7,12,5};
		
//		System.out.println("排序前:"+Arrays.toString(arr));
//		
//		sort(arr);
//		
//		System.out.println("排序后:"+Arrays.toString(arr));
		
		//查找
		int ret=binarySearch(arr,2);
		System.out.println("查找的目标元素的下标="+ret);
	}
	//冒泡排序
	public static void sort(int[] ns) {
		boolean isSort=true;
		for(int i=0,n=ns.length;i<n-1;i++) {
			for(int k=0;k<n-1-i;k++) {
				if(ns[k]>ns[k+1]) {
					ns[k]=ns[k]^ns[k+1];
					ns[k+1]=ns[k]^ns[k+1];
					ns[k]=ns[k]^ns[k+1];
					isSort=false;
				}
			}
			if(isSort) {
				break;
			}
		}
	}
	
	//查找
	//参数ns:要查找的目标数组
	//参数target:在目标数组中查找的目标值
	//返回值:返回值在目标数组中的下标,如果不存在,则返回-1
	public static int binarySearch(int[] ns,int target)	{
		//先排序
		sort(ns);//在一个方法中调用另一个方法
		
		//再二分查找
		int low=0,high=ns.length-1;
		while(low<=high) {
			int mid=(low+high)/2;
			
			if(ns[mid]==target) {
				return mid;
			}else if(mid>target){
				high=mid-1;
			}else if(mid<target) {
				low=mid+1;
			}
		}
		
		return -1;
	
	}

}

运行结果:

查找的目标元素的下标=1

数组旋转?方法的定义与调用

import java.util.Arrays;

public class demo12 {

	public static void main(String[] args) {
		int[]numbers= {1,2,3,4,5,6,7};
		//向右旋转3位
		right(numbers,3);
		System.out.println("右旋转3位"+Arrays.toString(numbers));
		//向左旋转3位
		left(numbers,3);
		System.out.println("左旋转3位"+Arrays.toString(numbers));

	}
	//向右旋转:把尾元素,通过不断交换,移动到数组的头部
	public static void right(int[] ns,int n) {
		//向右旋转几次
		for(int i=1;i<=n;i++) {
			//每次旋转1位
			for(int k=ns.length-1;k>0;k--) {
				ns[k]=ns[k]^ns[k-1];
				ns[k-1]=ns[k]^ns[k-1];
				ns[k]=ns[k]^ns[k-1];
			}
		}
	}
	//向左旋转:把头元素,通过不断交换,移动到数组的尾部
	public static void left(int[] ns,int n) {
		for(int i=1;i<=n;i++) {
			for(int k=0;k<ns.length-1;k++) {
				ns[k]=ns[k]^ns[k+1];
				ns[k+1]=ns[k]^ns[k+1];
				ns[k]=ns[k]^ns[k+1];
			}
		}
	}
}

运行结果:

右旋转3位[5, 6, 7, 1, 2, 3, 4]
左旋转3位[1, 2, 3, 4, 5, 6, 7]

使用数组,返回查找到的两个下标值?

import java.util.Arrays;

public class demo13 {

	public static void main(String[] args) {
		int[] retArr = twoSum(5,1,4,2,3,4,5,6,7,8,9);
		System.out.println(Arrays.toString(retArr));
	}
	
	//使用数组,返回查找到的两个下标值
	public static int[] twoSum(int target,int ...numbers) {
		int[] rets= {-1,-1};
		outter:
		for(int i=0;i<numbers.length-1;i++){
			for(int k=i+1;k<numbers.length;k++) {
				if(numbers[i]+numbers[k]==target) {
					rets[0]=i;
					rets[1]=k;
					break outter;
				}
			}

	}
		return rets;
	}
}

运行结果:

[0, 1]

文章来源:https://blog.csdn.net/m0_68041576/article/details/135608361
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。