方法的调用

自定函数(方法)

函数(方法):

给定一个具有独立功能的代码片段进行"命名",并通过该该类名调用"方法"

main主函数 

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

package study;import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;public class Demo01 {// 自定函数(方法)// 函数(方法):给定一个具有独立功能的代码片段进行"命名",并通过该该类名调用"方法"public static void createorderNo() {// 生成一个订单编号// 订单编号格式规则:// 当前日期+流水号(5位随机数字+字母)// 例如:20240115AX32B// 当前日期:获取当前日期,并转换成字符串// 方式1:// toString():按照默认日期个数yyyy-MM-dd,转换成字符串// String orderNo = LocalDate.now().toString();// 方式2:// format()按照指定日期格式yyyy年MM月dd日,转换成字符串// String orderNo = 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();}
}运行结果：
20240306
93F3C
新订单编号:2024030693F3C

 Demo02调用Demo01类的createorderNo()，需要通过"类名.方法名"调用

package study;public class Demo02 {public static void main(String[] args) {// 创建新订单编号// 调用Demo01类的createorderNo()// 需要通过"类名.方法名"调用Demo01.createorderNo();}
}运行结果：
20240306
C8560
新订单编号:20240306C8560

 定义方法语法结构

        访问修饰符[private/public] static 返回值类型 方法名称(参数){   }

[访问修饰符]: 代表该方法可以使用的范围

[static关键字]: 该方法通过类名调用(如果是在当前类类，可以直接调用，类名省略)

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

[方法名称]: 按照该方法的作用，为方法命名

[方法参数]: 按照该方法的作用，为方法设计参数的个数和类型

方法的定义

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

package study;public class Demo03 {// 方法的定义// 查找3个int类型参数中的最大值public 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(23,11,45);System.out.println("结果1:"+val1);int val2 = max(21,17,5);System.out.println("结果2:"+val2);}
}运行结果：
结果1:45
结果2:21

动态查找

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

package study;public class Demo04 {// 动态查找// 查找N个int类型整数中的最大值private 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,33,55,66,128,41);System.out.println(max);}
}运行结果：
128

两数之和参数

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

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

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

package study;public class Demo05 {public static void main(String[] args) {String ret = twoSum(5,1,4,2,3,5,6,7,8,9);System.out.println(ret);}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) {//1+4=5//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;//方式2return result;}}}return result;}
}运行结果：
1+4=5

通过方法的调用逆序字符串 

package study;public class Demo06 {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 = 0;i <s.length();i++) {
//			char c = s.charAt(i);
//			ret = c+ret;
//		}for(int i = s.length()-1;i>=0;i--) {char c = s.charAt(i);ret = ret + c;}return ret;}
}运行结果：
来风春夜一如忽

通过循环计算整数的位数

package study;public class Demo07 {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.log(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位！

方法的传参 

基本数据类型的参数:传递"值"
引用数据类型的参数:传递"内存地址"

package study;import java.util.Arrays;public class Demo09 {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.println(n + "\t");}System.out.println();}
}

运行结果：

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

通果冒泡排序和二分查找查找数组中的目标元素 

package study;import java.util.Arrays;public class Demo10 {public static void main(String[] args) {int[] arr = {4,3,1,23,12,8,17,7,5};
//		System.out.println("排序前:"+Arrays.toString(arr));
//		sort(arr);
//		System.out.println("排序后:"+Arrays.toString(arr));//查找int ret = binarySearch(arr,3);System.out.println("查找的目标值在数组的下标="+ret);}//冒泡排序public static void sort(int[] ns) {for(int i = 0,n = ns.length;i<n-1;i++) {boolean isSort = true;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 : 在目标数组中查找的目标值//返回值:返回目标值在目标数组中的下标，如果不存在，则返回-1public static int binarySearch(int[] ns,int target) {//先排序sort(ns);//在一个方法中调用另一个方法//再二分查找int low = 0,high = ns.length-1;while(low <= high) {int mid = (low + high) >> 1;if(ns[mid] == target) {return mid;}else if(ns[mid] < target) {low = mid+1;}else if(ns[mid] >target) {high = mid-1;}			}return -1;}
}

运行结果： 

查找的目标值在数组的下标=1

 数组旋转调用方法

package study;import java.util.Arrays;public class Demo11 {public static void main(String[] args) {int[] numbers = {1,2,3,4,5,6,7};System.out.println("原始数组"+Arrays.toString(numbers));right(numbers,3);System.out.println("向左旋转"+Arrays.toString(numbers));right(numbers,2);System.out.println("向右旋转"+Arrays.toString(numbers));}// 向右旋转:把尾元素，通过不断交换，移动到数组的"头部"public static void right(int[] ns,int n) {// 向右旋转几次for(int i = 1;i <= n;i++) {for(int k = ns.length-1;k >0;k--) {//每次向右旋转1位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];}}}
}

运行结果： 

原始数组[1, 2, 3, 4, 5, 6, 7]
向左旋转[5, 6, 7, 1, 2, 3, 4]
向右旋转[3, 4, 5, 6, 7, 1, 2]

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

package study;import java.util.Arrays;public class Demo12 {public static void main(String[] args) {int[] retArr = twoSum(5,1,4,2,3,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]