黑马程序员--java基础-方法重载与数组

为了解决，一次性能存入大量相同类型这种情况，Java给我们提供了一项新的技术叫做“数组”
数组：数的组合。可以看作存储大量数据的容器。
数组的定义：
数据类型[] 数组名;  //这就定义了一个数组
//数据类型 数组名[];  //不要用这种方法时去写。
数组名 = new 数据类型[数组的大小];  //数组的初始化。

class ArrayDemo {
public static void main(String[] args) {
/*
int a1 = 100;
int a2 = 100;
int a3 = 100;
int a4 = 100;
……

int a85 = 100;
*/

//定义以一个int类型的数组
//int scores[];  //不允许这么写
int[] scores;   //这个东西只是告诉计算机，我需要一个int类型的数组叫做scores
scores = new int[5];  //告诉计算机，这个scores数组的大小为5

//拿到数组的大小。数组名.length  他是int类型的数据
int a = scores.length;
System.out.println(a);

}
}

数组的使用：其实就是对数组中的变量的使用。
存入：
取出：
修改：

class ArrayDemo1 {
public static void main(String[] args) {
//定义一个数组
int[] scores;  //定义一个int类型的数组，名字叫scores
scores = new int[5];  //这个数组的大小为5

//数组的使用
/*
变量的使用：int a;
存入（赋值）：a = 12；
取出（直接拿着变量当作值来使用）
int b = a;
System.out.println(a);
修改（就是直接赋值，这样就把值覆盖了）：a = 15;

难点：
要把“scores[0]”整体看作是一个变量的名字，就相当于a
*/

//存入（赋值）
scores[0] = 12;
//取出（直接拿着变量当作值来使用）
int b = scores[0];
System.out.println(scores[0]);
System.out.println("b="+b);
//修改（就是直接赋值，这样就把值覆盖了）：
scores[0] = 15;
System.out.println(scores[0]);
}
}

class ArrayDemo2 {
public static void main(String[] args) {
int[] arrs;  //定义一个int类型的数组，名字叫做arrs
arrs = new int[5]; //告诉计算机，我们数组的大小为5
arrs[0] = 15;
System.out.println(arrs);
/*
[I@4e4d1abd
[: 代表数组
I: 代表int类型
@：在……地方
4e4d1abd：内存地址。
出现这句话，意味着 数组是“引用数据类型”

*/
}
}

数组定义的格式：
1.数组的动态初始化
数据类型[] 数组名;    //数组的声明
数组名 = new 数据类型[大小];  //数组的初始化
简化版本：
数据类型[] 数组名 =  new 数据类型[大小];

2.数组的静态初始化
数据类型[] 数组名;
数组名 = new 数据类型[]{1,5,3,8};
简化版本：
数据类型[] 数组名 = new 数据类型[]{1,5,3,8};
终极简化版本：
数据类型[] 数组名 = {1,5,3,8};

数组定义常见问题：
1.不能同时使用静态初始化和动态初始化。
2.数组中存储的数据必须和数组的类型保持一致。

class ArrayDemo6 {
public static void main(String[] args) {
int[] arr = new int[5];
/*
int a = 5;

*/

/*
数据类型[] 数组名;
数组名 = new 数据类型[]{1,5,3,8};
简化版本：
数据类型[] 数组名 = new 数据类型[]{1,5,3,8};
终极简化版本：
数据类型[] 数组名 = {1,5,3,8};

int[] brr;
brr = new int[]{7,8,9};

int[] brr = new int[]{7,8,9};
*/
int[] brr = {7,8,9};
System.out.println(brr.length);

int[] arr2 = new int[]{1,5,8};

}
}

数组的常见问题：
1.ArrayIndexOutOfBoundsException:数组索引越界异常
指的是，我们使用的数组的索引，超出了数组索引的范围。
2.可能尚未初始化变量
数组在使用之前必须初始化。
3.NullPointerException:空指针异常。
数组已经变成空的了，但是我们还要想人家要东西，所以就产生了空指针异常。

class ArrayDemo8 {
public static void main(String[] args) {
//int[] arr = new int[3];
//int[] arr;
int[] arr = new int[3];
arr = null;
System.out.println(arr[0]);
}
}

遍历：就是循环一遍，一个一个的拿出来。
数组的遍历：把数组中的元素一个一个的拿出来。

class ArrayDemo9 {
public static void main(String[] args) {
int[] arr = {11,15,19,21,85,33};
/*
arr[0]
arr[1]
arr[2]
……
arr[arr.length-1]

System.out.println(arr[0]);
*/

for (int a = 0; a< arr.length ;a++) {
System.out.println(arr[a]);
}

//求数组中的最大值
int max = arr[0];
/*
max = max > arr[0] ? max : arr[0];
max = max > arr[1] ? max : arr[1];
……
max = max > arr[arr.length-1] ? max : arr[arr.length-1];
*/

for (int a = 0; a < arr.length ; a++) {
max = max > arr[a] ? max : arr[a];
}
System.out.println("数组的最大值为："+max);
}
}

基本数据类型：在值的传递时，传递的“值”
引用数据类型：在值的传递时，传递的是“内存地址”

class ArrayTest1 {
public static void main(String[] args) {
/*
int a=5;
int b=a;
b=10;
System.out.println(a);
*/

int[] arr = {1,2,3};
int[] brr = arr;
brr[2] = 5;
System.out.println(arr[2]);

}
}

二维数组：存储数组的数组。
一维数组的格式；
数据类型[] 数组名 = new 数据类型[大小];
int[] arr = new int[5];

定义方法：
数据类型[][] 数组名 = new 数据类型[m]
;
m指的是这里边存储了m个数组。
n指的是二维数组中存储的数组的大小。

int[][] arrs = new int[2][3];
2指的是arrs里边存储了2个数组。
3指的是arrs中存储的这两个数组，每个数组的大小都为3

二维数组定义方式2：
数据类型[][] 数组名 = new 数据类型[m][];
m指的是这里边存储了m个数组。

二维数组定义方式3：
数据类型[] 数组名 = {1,5,3,8,9};
int[] arr = {1,5,3,8,9};

int[][] arrs = {{1,2,3},{4,5},{3}};

class ArrayArrayDemo {
public static void main(String[] args) {
/*
int[][] arrs = new int[2][3];
System.out.println(arrs[0]);
System.out.println(arrs[1]);
System.out.println(arrs[0][0]);

//二维数组定义方式2
int[][] arrs = new int[2][];
//System.out.println(arrs[0]);
//System.out.println(arrs[1]);
//System.out.println(arrs[0][0]);

arrs[0] = new int[3];
System.out.println(arrs[0]);
System.out.println(arrs[0][0]);
System.out.println(arrs[1]);
//给arrs[1]赋值
arrs[1] = new int[1];
System.out.println(arrs[1][1]);
*/

//

int[][] arrs = {{1,2,3},{4,5},{3}};
System.out.println(arrs[1][2]);
}
}

二维数组遍历

class ArrayArrayTest {
public static void main(String[] args) {
int[][] arrs = {{1,2,3},{4,5},{3}};
//二维数组遍历//外层循环，遍历二维数组中的数组
for (int a = 0; a < arrs.length ;a++) {
System.out.println(arrs[a]);
//现在发现arrs[a]全都是数组
//内层循环遍历，二维数组中数组的元素
for (int b = 0; b< arrs[a].length ; b++) {
System.out.println(arrs[a][b]);
}
}
}
}

某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

class ArrayArrayTest1 {
public static void main(String[] args) {
//第一季度：22,66,44
int[] arr1 = {22,66,44};
//第二季度：77,33,88
int[] arr2 = {77,33,88};
//第三季度：25,45,65
int[] arr3 = {25,45,65};
//第四季度：11,66,99
int[] arr4 = {11,66,99};

//定义二维数组
int[][] arrs = {arr1,arr2,arr3,arr4};
//int[][] arrs = new int[4][];
//arrs[0] = arr1;

//求整个公司的盈利，就是求这个二维数组的和。
int sum = 0;
//先拿出二维数组中的数组
for (int a = 0;a<arrs.length;a++) {
//arrs[a],就是每个数组
//对这个数组进行遍历
for (int b = 0;b<arrs[a].length;b++) {
sum = sum + arrs[a][b];
}
}
System.out.println(sum);

}
}

方法重载(overload)：
要求：
1.方法名完全相同
2.参数列表不同
3.和返回值、访问修饰符、方法体都没有关系。
参数列表不同的表现：
1.参数个数不同
2.相应位置上参数类型不同。
3.和参数名称没有任何关系。

数组定义与初始化:
数组的声明：
数据类型[] 数组名;
数组的初始化：
数组名 = new 数据类型[大小];

数组定义方式：
数组的动态初始化。
数据类型[] 数组名 = new 数据类型[大小];
数组的静态初始化：
数据类型[] 数组名 = new 数据类型[]{值1，值2……};
数据类型[] 数组名 = {值1，值2……};

数组赋值与使用：
索引：数组中每一个小块的编号。索引有时候也叫做角标、下标。Index
数组最大的索引：数组的长度-1;  //数组的长度：数组名.length
数组最小的索引：0

找到数组中的元素：数组名[索引];
如果找到元素，则就可以把这个元素当作一个变量来处理。

Java的默认值：
整数类型默认值：0
浮点型默认值：0.0
char型默认值：ASCII编码为0的字符。‘\u0000’
boolean型默认值：false
引用数据类型：null
String和数组都是引用数据类型。

参数传递(不同类型的赋值)
基本数据类型：传递和赋值都传递的是值。
引用数据类型：传递和赋值的都是内存地址。String除外。
二维数组(了解)：
定义格式1：
数据类型[][] 数组名 = new 数据类型[m]
;
m表示这个二维数组中存储了m个一维数组。
n表示这二维数组中存储的一维数组的大小都为n
定义格式2：
数据类型[][] 数组名 = new 数据类型[m][];
m表示这个二维数组中存储了m个一维数组。
定义格式3：
数据类型[][] 数组名 = {数组1,数组2……}

二维数组的遍历：
使用循环嵌套遍历。
外层循环遍历二维数组中的每个数组。
内层循环遍历数组中的每个元素。