Day05笔记
课程内容
1、方法的重载
2、数组
一、方法的重载
1、重载：Overload，超载
2、方法的重载：在同一个类中，方法名称相同，参数列表不同，与返回值类型无关
3、说明：
（1）在同一个类中：方法的重载发生在同一个类型中的方法之间，如果是不同的类或者是无关的类，不存在重载的情况
（2）方法名称相同：多个方法的名字一模一样
（3）参数列表不同：参数的类型不同，参数个数不同，参数顺序不同
（4）与返回值类型无关：方法是否重载，与返回值类型没有任何关系
4、重载的好处：
（1）没有重载的情况：对于方法逻辑相似但参数列表不同的方法，需要起不同的名字，在开发中名字的记忆会造成许多麻烦，也不便于程序员进行开发
（2）有重载的情况：对于方法逻辑相似但参数列表不同的方法，采用相同的方法名称，减轻名字繁杂的负担，在调用的时候，会根据参数列表的数据类型，数据顺序以及数据个数匹配到对应的方法，不用程序员操心
5、我们学过的常见的重载：
println方法，任意类型的数据，都可以通过这个方法进行打印
在官方的PrintStream类型中，有多个println方法的重载，这些方法参数列表不同，当我们调用输出语句的时候，会根据实际参数的类型，匹配到合适的println方法，之后进行打印
代码示例
package comg.offcn.demos;
public class Demo01_Overload {
public static void main(String[] args) {
getSum(10, 10);
System.out.println(getSum(10, 5, 1.5));
}
/*public static void getSum1(int a, int b) {
System.out.println(a + b);
}
public static void getSum2(double a, double b) {
System.out.println(a + b);
}*/
public static void getSum(int a, int b) {
System.out.println("--------");
System.out.println(a + b);
}
public static double getSum(int a, int b, double c) {
System.out.println("!!!!!!!!!!");
return a + b + c;
}
public static void getSum(double a, double b) {
System.out.println(a + b);
}
public static void getSum(double a, int b) {
System.out.println(a + b);
}
public static void getSum(int a, double b) {
System.out.println(a + b);
}
public static void getSum(int a, int b, int c) {
System.out.println(a + b + c);
}
}
二、数组
（一）概述
1、数组：就是用于存储相同数据类型数据的容器
2、使用数组的原因：
（1）没有数组：在代码中，有许多的变量，不方便统一管理，也不容易记住变量名称
（2）有数组：将同一个类型的数据，用一个数组进行统一管理，数组中有位置，位置上有编号，我们可以通过位置的编号找到位置，位置上存储的是我们需要的数据，这样就方便我们统一操作这些零散的数据
3、数组的定义格式：
数据类型[] 数组名称 = new 数据类型[数组的容量];
4、说明：
（1）元素：存储在数组中的数据，存储在数组中的变量
（2）数组元素的类型：要和数组的类型保持完全一致，一个数组中只能够存储一种数据类型的数据
（3）数据类型：在数组定义格式中：=两侧的数据类型要保持完全一致
（4）数组名称：合法标识符即可，遵循小驼峰原则
（5）=：赋值符号，将数组的地址赋值给数组的名称
（6）new：新建，在JVM的堆内存中开辟空间创建数组
（7）数组容量：表示数组中能存储的数据的个数，可以自定义，但是必须是正整数
（8）[]:一对[]表示一维数组，几对[]就表示几维数组
5、打印数组的结果解释：[I@7852e922
（1）[：一个[表示一维数组，几个[就表示几维数组
（2）I：表示数组的数据类型，I是int类型
（3）@：分隔符，没有特殊含义
（4）7852e922：是一个十六进制的数字，在计算机中，数组有真实的存储地址，为了保证安全，我们没有任何的获取方法。在底层，通过调用hashCode方法，将数组的真实地址计算成int类型的数据，int类型的数据再转换为16进制的数据，就得到了当前的数据
6、注意：以后我们将打印的结果，就称之为地址
代码示例
package comg.offcn.demos;
public class Demo02_Array {
public static void main(String[] args) {
//数据类型[] 数组名称 = new 数据类型[数组容量];
//一个数组定义成什么类型，就只能存储什么类型的数据
//表示一个只能存储int类型数据的数组，容量是5，能存储5个int数
int[] arr = new int[5];
System.out.println(arr);
}
}
（二）数组的初始化
1、为数组分配空间，并且赋值
2、分类：动态初始化、静态初始化
3、动态初始化：在程序运行的过程中，才能知道究竟给数组赋了什么值
数据类型[] 数组名称 = new 数据类型[数组的容量];
元素的赋值方式：
数组名称[元素的索引] = 元素值;
索引：又叫做下标、角标、脚标
元素在数组中的位置的编号。索引从0开始，是正整数，按照升序排列。索引的范围时0~数组长度-1
注意事项：
（1）所有的元素，都需要逐个赋值
（2）如果数组中某个位置没有赋值，那么就按照数组的类型具有默认值，数组是整数型，默认值为0，数组是浮点型，默认值为0.0
4、静态初始化：在程序的书写过程中，就知道数组的每一个位置上存储的是什么元素
数据类型[] 数组名称 = new 数据类型[]{元素1, 元素2, 元素3, ... , 元素n};
注意事项：
（1）=右侧的[]中，不能书写任何的内容
（2）大括号中有多少个元素，将来在运行的时候，就会根据实际的元素个数，创建一个与元素个数相等容量的数组
（3）{}中的元素用逗号隔开
（4）{}中的元素数据类型，必须和数组的数据类型保持一致
5、静态初始化的简写格式：
数据类型[] 数组名称 = {元素1, 元素2, 元素3, ... , 元素n};
注意事项：此格式声明和赋值不能拆分开，需要写在一起。其余两种格式声明和赋值可以拆分。
代码示例
package comg.offcn.demos;
public class Demo03_Init {
public static void main(String[] args) {
int[] arr;
arr = new int[3];
int[] arr1;
arr1 = new int[] {1, 2};
int[] arr2 = {1, 2, 3, 4, 5};
}
public static void test3() {
int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
}
public static void test2() {
//数据类型[] 数组名称 = new 数据类型[]{元素1, 元素2, 元素3, ... , 元素n};
int[] arr = new int[] {1, 2, 4};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
public static void test1() {
//动态初始化
int[] arr = new int[3];
/*double[] arr = new double[3];
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);*/
//赋值操作格式：数组名称[索引] = 元素值;
arr[0] = 3;
arr[1] = 66;
arr[2] = 8;
//数组元素的获取：数组名称[索引]
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
三、数组的内存理解
（一）JVM的内存划分
1、JVM是执行java程序的容器，内存空间很大，需要划分为不同的区域。不同的区域，具有不同的功能，需要使用不同特点的区域来完成不同代码部分的执行。
2、栈【常用】：用于执行方法。每个方法会单独分配一块空间，此空间称之为栈帧，把方法分配给内存空间，形象的称之为进栈，方法执行完毕后释放空间，称之为出栈。运行特点：先进后出，后进先出
3、堆【常用】：用于存储数组、对象等数据量较大的数据的空间。堆中，一般存储的都是引用数据类型。
4、方法区【常用】：用于存储类的字节码对象，存储常量、存储静态变量等。
5、程序计数器：用于控制程序执行、控制程序执行那段代码
6、本地方法区：用于执行本地方法。C语言、C++方法就是本地方法
（二）一个数组的内存图
代码示例
package comg.offcn.demos;
public class Demo04_OnlyArrayPicture {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 11;
arr[1] = -8;
arr[2] = 73;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
（三）两个引用指向同一个数组的内存图
1、引用：
在内存中的一个变量，存储的是另外一个空间的数据的地址值。称数据的地址为引用。存储引用的变量，就叫做引用数据类型。
2、两个引用指向同一个数组：
任意一个引用修改了数组的内容，另外一个数组访问到的也就是修改后的内容。
3、图示：
代码示例
package comg.offcn.demos;
public class Demo05_TwoAddress {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 73;
arr1[1] = 125;
int[] arr2 = arr1;
arr2[0] = 273;
arr2[2] = 10;
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
四、数组的异常
（一）异常
1、在程序的运行过程中，出现了和正常情况不符合的情况或者条件，导致程序无法继续运行下去，就叫做异常。
2、数组在运行的过程中，常见的异常：
（1）数组索引越界异常
（2）空指针异常
（二）数组索引越界异常
1、Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
异常 在..里面 线程 主 数组 索引 在..之外 边界 异常
2、数组索引越界异常：
（1）产生原因：在访问数组索引的过程中，访问的索引超出了数组所具有的索引的范围，就会出现此异常
（2）避免方式：不要访问数组不存在的索引
代码示例
package com.offcn.demos;
public class Demo06_ArrayIndexOutOfBoundsException {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
/*
* Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
* 异常 在..里面 线程 主 数组 索引 在..之外 边界 异常
*
* */
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
}
}
（三）空指针异常
1、Exception in thread "main" java.lang.NullPointerException
空 指针 异常
2、空指针异常；
（1）null：表示空，在栈内存方法中的引用中，表示不记录任何地址
（2）指针：在java中，不存在指针，C语言中有指针的概念，java由C语言发展而来，所以沿用了C语言的说法，形象的表示一种行为：地址值指向堆内存中的实际数据。至于指针这个说法，是一个舶来品。
3、空指针异常的产生原因：当前的引用空间中没有任何地址指向具体的数据，仍然要通过这个引用访问某些数据，此时就只能抛出异常。
4、避免方式：在使用引用之前，先判断是否为null，如果不为null再去访问
代码示例
package com.offcn.demos;
public class Demo07_NullPointerException {
public static void main(String[] args) {
/*
* Exception in thread "main" java.lang.NullPointerException
* 空 指针 异常
*
*
* */
int[] arr = null;
System.out.println(arr[0]);
}
}
五、数组的操作
（一）数组的遍历
1、遍历：一个一个经历数组的每一个元素，数组中所有的元素都挨个访问一遍
2、方式：
（1）数组的索引范围：0~数组长度-1
（2）通过循环，让初始化变量充当数组的索引，循环可以获取到每一个索引
（3）通过循环获取到的索引，来进一步获取数组中的每一个元素
3、索引：
最大索引的获取：数组的长度-1
数组长度的获取：数组名称.length
最大索引：数组名称.length - 1
代码示例
package com.offcn.demos;
public class Demo08_PrintElement {
public static void main(String[] args) {
int[] arr = {33, 61, -5, 8, 23, 79, 12};
//索引从0开始，到数组长度-1结束
/*for(int i = 0; i <= 6; i++) {
System.out.println(arr[i]);
}*/
for(int i = 0; i <= arr.length - 1; i++) {
System.out.println(arr[i]);
}
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
（二）数组的最值
1、给定一个数组，获取这个数组的最大值或者最小值
2、打擂思想：
声明一个变量，存储当前数组的某一个元素，并假设其为最大值，之后遍历整个数组，获取到每一个元素，每一个元素都和当前的变量中假设的最大值去比较，如果当前数组元素的值大于变量中的元素，就将当前更大的值作为目前最大值。直到数组中所有元素都遍历完毕，最大值就获取到了
3、思路图示：
代码示例
package com.offcn.demos;
public class Demo09_TheBestValue {
public static void main(String[] args) {
int[] arr = {33, 61, -5, 8, 23, 79, 12};
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if(min > arr[i]) {
min = arr[i];
}
}
System.out.println(min);
}
public static void test1(int[] arr) {
//获取最大值
//1.准备擂台，假设第一个元素就是最大值
int max = arr[0];
//2.遍历数组，获取数组的每一个元素
for(int i = 0; i <= arr.length - 1; i++) {
//3.将当前遍历得到的元素与目前假设的最大值进行比较
if(max < arr[i]) {
//4.将更大值赋值给变量
max = arr[i];
}
}
//5.整个比较都结束后，最大值就获取到了
System.out.println(max);
}
}
（三）数组的反转
1、数组的反转，将数组第一个元素和最后一个元素互换，第二个元素和倒数第二个元素互换，以此类推，将数组原来的元素顺序进行首位颠倒。
2、图示：
代码示例
package com.offcn.demos;
public class Demo10_ArrayReverse {
public static void main(String[] args) {
int[] arr = {33, 61, -5, 8, 23, 79, 12};
printArr(arr);
//i表示开始位置的索引，j表示最后位置的索引，i从前往后移动，j从后往前移动，始终保证i在前j在后
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
System.out.println();
printArr(arr);
}
public static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
（四）数组的查找
1、给定一个数，在指定的数组中查找该数字第一次出现的索引，并且返回此索引，如果该数字不存在，则返回-1
代码示例
package com.offcn.demos;
public class Demo11_数组的查找 {
public static void main(String[] args) {
int[] arr = {33, 61, -5, 8, 23, 79, 12, -5};
System.out.println(getIndex(arr, 100));
}
/*
* arr：待查找的数组
* num：待查找的数据
*
* */
public static int getIndex(int[] arr, int num) {
if (arr != null) {
//1.遍历数组获取每一个元素
for (int i = 0; i < arr.length; i++) {
//2.将当前元素和目标元素进行判断
if (arr[i] == num) {
return i;
}
}
}
return -1;
}
}