本文介绍了编程中的方法和函数概念，包括它们在语法结构中的应用，访问修饰符、静态方法的使用，参数的设计与传递，返回值的作用，以及动态参数、数组操作、排序算法和查找方法的实例。
”方法“一词来源于日常生活中用语，意思是”指为获得某种东西或达到某种目的而采取的手段与行为方式”。在编程语言中，”方法“有时也被称为”函数”，其含义主要是”实现编程中某个具体功能的办法或方式，是一系列步骤的总结“。
定义方法：
语法结构
/访问修饰符[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]
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
