JavaOOP编程思想-方法
1.什么是方法？
方法是若干个"代码语句片段"的集合，它们完成一个"具体的功能"，并且设置一个"直观易懂"的名字，方便后期在程序中去"使用（调用）"。
2.使用方法的优点
- 使程序变得更简短而清晰
- 有利于程序维护
- 可以提高程序开发的效率
- 提升 了代码的重用性
3.方法的定义
语法格式：
修饰符 （static） 返回值类型 方法名（参数类型 参数名）{
语句1；
语句2；
语句3；
return 返回值；
}
- 修饰符:修饰符,可选部分,定义了该方法的访问范围。
- static关键字:该方法通过类名调用(如果是在当前类内，可以直接调用，类名省略
- 返回值类型:调用方法后返回的数据值的类型;但有些方法执行后没有返回的数据值,在这种情况下,返回值类型部分使用关键字void,
- 方法名:按照该方法的作用，为方法命名。
- 参数:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。按照该方法的作用，为方法设计参数的个数和类型。
- 方法体:方法体包含具体的语句,定义该方法的功能。
示例：
//查找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;
}4.方法的调用
查找3个int类型整数中的最大值
在mian函数中调用自定义的max（方法）函数。
（在当前类中，可以直接调用方法；在其他类中，需要通过"类名.方法名"调用）
//查找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(15, 27, 11);
System.out.println("结果1：" + val1);
int val2 = max(17, 14, 27);
System.out.println("结果2：" + val2);
}
5.方法的返回值
将方法执行的最终结果,通过return关键字,返回至方法调用处。
例如:随机抽奖的方法,需要通过返回值将中奖的结果返回
确认订单的方法,需要通过返回值将订单是否生成的结果返回
- 方法的返回值必须与方法声明时的返回值类型保持一致
- 如果一个方法无需返回值,则需要使用void关键字进行声明。
6.动态参数
- 一个方法中只能有一个参数的动态参数
- 动态参数必须是方法的最后一个参数
- 动态参数在方法中，可做为一个数组使用
示例1： 查找N个int类型整数中的最大值。
public class Text05 {
private static int maxN(int... ns) {
//动态参数
//查找N个int类 型整数中的最大值
int ret = ns[0];//默认值
for(int i = 1;iret) {
ret = ns[i];
}
}
return ret;
}
public static void main(String[] args) {
//可以传入N个参数
int max = maxN(4,89,33,25,66,96,43);
System.out.println(max);
}
} 示例2：求两数之和。
public class Text06 {
//主函数
public static void main(String[] args) {
//调用自定义方法twoSum(),求两数之和
String ret = twoSum(5,0,2,3,5,6,7,8,9);
System.out.println(ret);
}
//两数之和
//参数target :需要查找的目标值
//参数numbers:需要查找的一组整数(动态参数)
//注意:动态参数必须是整个参数列表的最后1部分
public static String twoSum(int target,int... numbers) {
String result = "";
// outer:
for(int i = 0;i示例3：字符串的逆序
public class Text07 {
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示例4：获取任意整数的位数
public class Text08 {
public static void main(String[] args) {
int n1 = 123456;
int len1 = numberLength(n1);
System.out.println(n1+"的长度是"+len1+"位！");
int n2 = 78945612;
int len2 = numberLength(n2);
System.out.println(n2+"的长度是"+len2+"位！");
}
//获取任意整数的位数
public static int numberLength(int numbers) {
//方式1：计算该整数以10为底的对数
int ret = (int)(Math.log10(numbers)+1);
return ret;
//方式2：通过循环
// int ret = 0;
// while(numbers != 0) {
// System.out.println("个位数值："+numbers%10);
// ret++;//记录位数
// numbers = numbers/10;
// }
//
// return ret;
}
}
7.方法的传参
- 基本数据类型的参数：传递"值"
- 引用数据类型的参数：传递"内存地址"
示例1：基本数据类型的传参
public class Text11 {
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示例2：引用数据类型的传参
public class Text09 {
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输出结果：
改变前：[1, 2, 3, 4, 5]
数组array的内存地址：[I@15db9742
数组numbers的内存地址：[I@15db9742
改变中
2 4 6 8 10
改变后：[2, 4, 6, 8, 10]8.课堂练习题：
1.数组的排序，并查找的目标值在数组的下标位置。
public class Text10 {
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) {
for (int i = 0; i < ns.length - 1; i++) {
boolean isSort = true;
for (int k = 0; k < ns.length - 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;
}
}
}
// 二分查找方法
public static int binarySearch(int[] ns, int target) {
// 先排序
sort(ns); //直接调用上面的sort()方法
// 再二分查找
int low = 0, high = ns.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (ns[mid] == target) {
return mid;
} else if (ns[mid] > target) {
high = mid - 1;
} else if (ns[mid] < target) {
low = mid + 1;
}
}
return -1;
}
}
2.数组的旋转
public class Text12 {
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7};
System.out.println("原始数组："+Arrays.toString(numbers));
//向右旋转3位
right(numbers,3);
System.out.println("右旋3位"+Arrays.toString(numbers));
//向左旋转2位
left(numbers,2);
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输出结果为：
原始数组：[1, 2, 3, 4, 5, 6, 7]
右旋3位[5, 6, 7, 1, 2, 3, 4]
左旋2位[7, 1, 2, 3, 4, 5, 6]3.求两数之和等于目标数的下标位置
public class Text13 {
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输出结果为：
[0, 1]