方法加强练习
此需求和代码在文章最下面。
1、方法参数传递
1.1 什么是方法参数传递
概念：在使用方法的时候，传入值或者变量就是参数传递。
1.2 参数传递的本质：
Java的参数传递：
基本数据类型传递的是：值本身。
引用数据类型传递的是：变量在堆中的引用地址。
1.3 值传递
public class _04StackHeap {
public static void main(String[] args) {
int a = 1;
System.out.println("改变前：" + a); // 1
// 调用change方法
change(a);
System.out.println("改变后================ ：" + a); // 1
}
public static void change(int a) {
a = 2;
System.out.println("改变中-------：" + a); // 2
}
}
内存分析图：
1.4 引用地址传递
public class _05StackHeap {
public static void main(String[] args) {
int[] arr = {1, 2};
System.out.println("改变前：" + arr[0]);// 1
System.out.println("改变前：" + arr[1]);// 2
// 调用change方法
change(arr);
System.out.println("改变后================ ：" + arr[0]);// 6
System.out.println("改变后================ ：" + arr[1]);// 9
}
public static void change(int[] arr) {
arr[0] = 6;
arr[1] = 9;
System.out.println("改变中-------：" + arr[0]);// 6
System.out.println("改变中-------：" + arr[1]);// 9
}
}
内存分析图：
2. 可变参数大家先来看几个需求
需求：求2个int变量的和，并且返回，设计一个方法实现
public static int getSum(int a, int b) {
return a + b;
}
需求：求3个int变量的和，并且返回，设计一个方法实现
public static int getSum(int a, int b, int c) {
return a + b + c;
}
大家可以看到，求和的需求是类似的，如果这样的需求有很多，按照我们之前的处理的方式就是要声明很多对应的方法处理。这样的话会有代码重复、可读性不好、并且程序员需要花时间去记忆等缺点，所以我们要用数组优化代码。
public class _03ChangeMethod {
public static void main(String[] args) {
// 需求：求2个int变量的和，并且返回，设计一个方法实现
// 需求：求3个int变量的和，并且返回，设计一个方法实现
// 调用getSum(int[] arr) 方法
int[] arr;
arr = new int[]{1, 2};
// 求3个int参数的和，现在参数就相当于是一个静态创建的数组
int sum2 = getSum(new int[]{1, 2, 3});
System.out.println(sum2);
// 求4个int参数的和，现在参数就相当于是一个静态创建的数组
int sum3 = getSum(new int[]{1, 2, 3, 69});
System.out.println(sum3);
}
public static int getSum(int[] arr) {
int sum = 0;
for (int e : arr) {
sum += e;
}
return sum;
}
}
现在虽然用数组优化了参数个数不定的情况，但是有存在另外一个问题，就是传入参数的时候，需要我们程序员将参数作为元素创建一个数组，也非常麻烦，所以，我们接下来用可变参数来最终解决这些问题。
1. 概念：就是将方法参数个数不定的需求，简化的一种语法，其本质是数组。
2. 作用：简化代码，将数组的创建工作交给了编译器。
3. 语法:
| 修饰符 返回值类型 方法名(其他数据类型 变量, 数据类型... 变量){ 方法体 } |
代码案例：
public class _03ChangeMethod {
public static void main(String[] args) {
// 调用getSum(int... arr) 方法
// 求3个int参数的和，现在参数就相当于是一个静态创建的数组
int sum = getSum(1, 2);
System.out.println(sum);
// 调用getSum(int... arr) 方法
// 求3个int参数的和，现在参数就相当于是一个静态创建的数组
int sum2 = getSum(1, 2, 3);// 现在数组创建交给了编译器，编译器会根据传入的参数临时静态创建一个数组
System.out.println(sum2);
// 求5个int参数的和，现在参数就相当于是一个静态创建的数组
int sum3 = getSum(1, 2, 3, 4, 5);// 现在数组创建交给了编译器，编译器会根据传入的参数临时静态创建一个数组
System.out.println(sum3);
}
public static int getSum(int... arr) {
System.out.println(arr);// 地址
System.out.println(arr.length);// 数组长度
int sum = 0;
for (int e : arr) {
System.out.println("元素：" + e);
sum += e;
}
return sum;
}
}
注意事项:
1. 可变参数本质就是一个数组，只不过这个数组是编译器帮我们程序员创建的。
2. 一个方法只能有一个可变参数，并且只能在形参列表最末尾。
3、Arrays工具类&API文档的使用3.1 什么是工具类
- 概念：简单的认为，就是JDK、或者其他程序员已经帮我们写好的类而已。
- 作用：可以将它看成是现成的轮子，可以直接使用，节约了程序员设计类的时候，提高了开发效率。
Arrays就是JDK设计的用来专门操作数组的工具类。
3.2 工具类怎么使用?
使用他人设计的类，最好的方式是通过自带的API手册（即，相当于说明书）或者百度来学习怎么使用。
使用API手册步骤：
| 1. 点击索引，在搜索栏，输入要使用的类Arrays 2. 简单看一下该类的介绍，能看懂就看，看不懂的就不用管 3. 直接看下这个类中的方法，然后看一下方法的介绍和使用方式 Modifier（修饰符）有static的调用方式是：类名.方法名(实参); Type（返回值类型） ：决定可以用什么类型变量接受方法调用结果 Method （方法名）：看形参列表，调用的时候，必须传入对应的实参 Description （方法的描述和介绍） 4. 看不懂方法的描述，就直接调用一下方法，来看效果 看是否有static修饰，如果有用：类名.方法名(实参); 看是否有static修饰，如果没有用：对象名.方法名(实参); |
Arrays类中常用方法：
| 1. public static String toString(int[] arr)拼接数组中元素，格式：[值1,值2...] 2. public static void sort(int[] arr)将数组中的元素排序，默认升序。从小到大 3. public static int binarySearch(int[] arr,int a)查询变量a在数组arr中第一次出现的下标。如果没有找到返回负数。 注意：建议数组是排好顺序且不重复的，否则查询结果不准确（升序和降序都可以 4. public static int[] copyOf (int[] arr,int newLength)数组的扩容和缩容方法 扩容：如果newLength大于arr数组中用来的长度，就是扩容，扩容后，arr数组所有的元素都已经复制到新数组中 缩容：如果newLength小于arr数组中用来的长度，就是缩容，缩容后，arr数组从后向前缩 5. static int[] copyOfRange(int[] arr, int from, int to) 将指定数组arr的指定下标范围从from到to之间的元素，复制到新数组中。【含头不含尾】 6. public static void fill(int[] arr,int a)将数组arr中的元素批量初始化为a |
代码案例：
public class _06API {
public static void main(String[] args) {
// 1. 调用Arrays类中的 public static String toString(int[] arr)拼接数组中元素，格式：[值1,值2...]
int[] arr = {1, 69, 33, 12, 5};
// 调用toString，因为是static修饰，所以用Arrays类名调用，返回值是String类型，所以，用String变量接收结果
String str = Arrays.toString(arr);// 报错是因为找不到该类Arrays，需要导包
// 打印返回值str即可
System.out.println(str);
// 排序：2. public static void sort(int[] arr)将数组中的元素排序，默认升序。从小到大
Arrays.sort(arr);
// 重新拼接排序后的数组字符串
String str2 = Arrays.toString(arr);
System.out.println("排序后：" + str2);
int binarySearch = Arrays.binarySearch(arr, 12);// [1, 5, 12, 33, 69]
System.out.println("下标：" + binarySearch);
int[] arr2 = {1, 69, 33, 12, 5};
// 扩容
int[] newArr = Arrays.copyOf(arr2, 7);// 因为7 > arr2.length ，所以是扩容
// 将数组newArr拼接字符串，用String变量str3接收
String str3 = Arrays.toString(newArr);
System.out.println("扩容后新数组 ：" + str3);
// 缩容
int[] newArr2 = Arrays.copyOf(arr2, 3);// 因为3 < arr2.length，所以是缩容
// 将数组newArr2拼接字符串，用String变量str4接收
String str4 = Arrays.toString(newArr2);
System.out.println("====缩容后新数组 ：" + str4);
int[] arr3 = {1, 69, 33, 12, 5};
int[] newArr3 = Arrays.copyOfRange(arr3, 1, 3);// 截取数组arr3中包含下标1，到不包含下标3之间的元素，返回到新数组中
// 将数组newArr3拼接字符串，用String变量str5接收
String str5 = Arrays.toString(newArr3);
System.out.println("复制指定下标1~3区间的新数组 ：" + str5);
// 6. public static void fill(int[] arr, int a)将数组arr中的元素批量初始化为a
Arrays.fill(arr3, 996);// 将数组arr3中全部元素批量修改为996
// 将数组arr3拼接字符串，用String变量str6接收
String str6 = Arrays.toString(arr3);
System.out.println("批量初始化后的数组 ：" + str6);
}
}
方法加强练习（需求）
public class _01Homework {
public static void main(String[] args) {
// 1.定义一个方法getMax,接收两个int参数,返回最大的一个数(低级)建议使用三目运算
int max = getMax(1, 2);
System.out.println(max);
System.out.println(getMax(2, 3));// 可以直接打印一个方法，但是该方法返回值类型必须不是void。
// 2.定义一个方法,接收三个int参数,返回最小的一个数(低级)
// 3.设计一个求3个int类型积的方法,并返回这个积(低级)
// 4.设计一个方法，传入一个int的数组，返回该数组中最大的值(中级)
int[] arr = {1, 9, 96, 9, 6, 66};
// 调用getMaxInArray方法
int maxInArray = getMaxInArray(arr);
System.out.println("数组中最大值：" + maxInArray);
// 5.设计一个方法，传入一个参数姓名name、一个参数爱好hobby，打印输出一句话：name的爱好是：hobby
// ===============================选做==========================
char[] arr2 = {'a', 'b', 'c', 'a', 'g'};
char c = 'g';
int indexInArray = getIndexInArray(arr2, c);
System.out.println("下标：" + indexInArray);
// 7.设计一个方法,统计返回一个字符在字符数组中出现的次数(高级)
// 8.设计一个方法,已知这样的整形数组 int[] arr = {1,2,3,4,5,6,7,8,9,11,12}返回其中的奇数和
int[] arr3 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12};
// 调用方法： getOddSum
int oddSum = getOddSum(arr3);
System.out.println("奇数和：" + oddSum);
double[] scores = {11, 34, 76, 77, 88, 99, 58, 97, 56};
printScores(scores); // 返回值是void，直接调用执行即可
// 10.设计一个方法，传入一个int数组，翻转该数组中的元素，并且返回反转后的数组(牛皮做)
// 调用方法：reverse
int[] reverse = reverse(arr3);
for (int e : reverse) {
System.out.println(e);
}
// 打印数组是，没有意义。所以，有了该需求
// 11.需求：请设计一个方法toString，传入一个int[]，将该数组进行字符串拼接，格式如下：[元素1, 元素2, 元素3....]，返回拼接后的字符串
System.out.println(reverse);
// 调用:toString方法
String str = toString(reverse);
System.out.println(str);
}
public static int getMax(int a, int b) {
// 如果用if else语句
// if (a > b) {
// return a;
// } else {
// return b;
// }
return a > b ? a : b;// 是优先级最低的运算，会在执行完三目运算后执行return返回结果
}
public static int getMaxInArray(int[] arr) {
// 先判断参数arr是否非null，如果非null才能继续执行
// 声明一个int类型max，赋值第一个元素arr[0],保存遍历到的最大值
int max = arr[0];
// foreach遍历数组arr
for (int e : arr) {
// 每次循环max都有跟数组元素e对比
if (e > max) {// 如果e比max大,则重新给max赋值为e
max = e;
}
}
// 循环结束后，就找到最大值了，然后返回最大值max
return max;
}
public static int getIndexInArray(char[] arr, char c) {
// 先判断参数arr是否非null，如果非null才能继续执行，否则就可能发生空指针异常。
if (arr == null) {
return -1;// 任意负数表示未找到
}
// 遍历数组
for (int i = 0; i < arr.length; i++) {
// 判断每一个元素arr[i]跟参数c是否相等
if (c == arr[i]) {
return i;// 如果相等直接返回当前下标
}
}
// 循环结束还没有返回，证明没有找到，返回-1
return -1;
}
public static int getOddSum(int[] arr) {
// 非null判断，以后通过抛出异常的方式解决，现在不管
int sum = 0;
// 遍历数组arr
for (int e : arr) {
// 判断当前e是否是奇数
if (e % 2 != 0) {
sum += e;
}
}
return sum;
}
public static void printScores(double[] scores) {
// 非null判断不写了
int countC = 0;// 声明0-60计数器
int countB = 0;// 声明60-80计数器
int countA = 0;// 声明80-100计数器
// 遍历数组 scores
for (double e : scores) {
// 判断元素e属于哪个阶段
if (e >= 0 && e < 60) {
countC++;
} else if (e >= 60 && e < 80) {
countB++;
} else if (e >= 80 && e <= 100) {
countA++;
} else {
System.out.println("分数错误！");
}
}
System.out.println("0-60人数：" + countC + " 60-80人数：" + countB + " 80-100人数：" + countA);
}
public static int[] reverse(int[] arr) {
// 非null判断不写了
// 普通for循环遍历数组arr
for (int i = 0; i < arr.length / 2; i++) {// 通过画图得知循环次数
// 通过画图得知交换的下标关系
// 交换收尾的元素即可
int temp = arr[i];// 声明一个临时变量temp，赋值为arr[i]
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
// 返回数组arr
return arr;
}
public static String toString(int[] arr) {
// 非null判断不写了
// 1. 声明一个String类型str，赋值为"["，用来拼接字符串的
String str = "[";
// 2. 遍历数组arr,初始化条件，从下标0开始，循环结束条件到倒数第二个元素
for (int i = 0; i <= arr.length - 2; i++) {
// 每次循环，都将获取到的元素arr[i]拼接到str中
str += arr[i] + ", ";
}
// System.out.println(str);
// 3. 循环结束后，再将最后一个元素arr[arr.length - 1]拼接上,拼接 结尾]
str += arr[arr.length - 1] + "]";
return str;
}
}
下一章 《面向对象》
