一、数组 

1、 什么是数组？

 数组和变量差不多，也是可以存放数据的，但是数组可以存放多个数据，而且多个数据的数据类型统一  格式  数据类型 [] 数组名称;  还有一种等效的写法，不推荐  数据类型 数组名称[];  变量如果定义好了之后，要想使用，一定要赋值  数组如果定义好了之后，要想使用一定要初始化  初始化：就是在内存当中开辟数组的空间，并且赋值一些默认值(准备工作)  数组的初始化方式有两种：  1、动态初始化，指定数组的长度  2、静态初始化，指定数组的内容

 动态初始化：直接指定数组的长度，也就是数组当中到底可以存放多少个数据  格式一、  数据类型[] 数组名称=new 数据类型[数组长度];  解析：  左侧数据类型：也就是数组当中存放的元素全部都是统一的什么类型  左侧的[]：代表这个一种数组类型  数组名称：就是一个自定义的标识符，通过名称，可以使用数组当中的数据  右侧的new：代表创建动作，内存当中开辟空间，创建数组  右侧数据类型：一定要和左侧的数据类型一样  右侧[]当中的数组长度：也就是到底能存放多少个数据  格式二、  数据类型[] 数组名称;  数组名称=new 数据类型[数组长度];

1     public static void main(String[] args) {
2         //格式一
3         int[] array1=new int[2];
4         //格式二
5         int[] arrar2;
6         arrar2=new int[2];
7     }

 2、数组取值：

如何访问数组当中的元素？ 如果直接打印数组的名称，那么到底的是地址值(的哈希值 )

如何访问数组当中的一个具体元素呢？格式 数组名称[索引编号] 索引：也就是数组当中多个元素的编号，从0开始，一直到“长度-1”位置

动态初始化的时候，数组当中的元素都会被赋予一个默认值。 规则： 如果整数，默认就是0；如果是浮点数，默认是0.0；如果是字符，默认是’\u0000’(Unicode写法)

如果布尔值，默认是false；如果是字符串或其他引用类型，那么是null(空常量)

1     public static void main(String[] args) {
2         int[] arrayA=new int[3];
3         System.out.println(arrayA);//[I@279f2327
4         System.out.println(arrayA[0]);
5         System.out.println(arrayA[1]);
6         System.out.println(arrayA[2]);
7     }

 数组在初始化的时候，还有另外一种方式，静态初始化  静态初始化不会直接指定长度，而是直接指定具体的元素内容  标准格式  数据类型[] 数组名称=new 数据类型[]{元素1,元素2};  标准格式也可以拆分成为两个步骤  数据类型[] 数组名称;  数组名称=new 数据类型[]{….};  简便格式：  数据类型[] 数组名称={元素1,元素2};  一旦使用了简便格式，必须一个步骤完成初始化，不能拆分两个步骤

注意事项：

1、虽然静态初始化没有指定长度，但是仍然可以根据具体元素的个数自动推算出来长度

2、虽然简便格式当中可以不写new….，但是仍然有内存当中开辟空间的过程

3、虽然直接指定了具体元素内容，但是仍然会有默认值被替换的过程

 1     public static void main(String[] args) {
 2         // 动态初始化
 3         int[] arrayA = new int[3];
 4         arrayA[0] = 10;
 5         arrayA[1] = 15;
 6         arrayA[2] = 20;
 7         System.out.println(arrayA[0]);
 8         System.out.println(arrayA[1]);
 9         System.out.println(arrayA[2]);
10         System.out.println("============");
11         // 静态初始化，一个步骤
12         int[] arrayB = new int[] { 30, 40, 50 };
13         System.out.println(arrayB[0]);
14         System.out.println(arrayB[1]);
15         System.out.println(arrayB[2]);
16         System.out.println("============");
17         // 静态初始化，两个步骤
18         int[] arrayC;
19         arrayC = new int[] { 60, 70, 80 };
20         System.out.println(arrayC[0]);
21         System.out.println(arrayC[1]);
22         System.out.println(arrayC[2]);
23         System.out.println("============");
24         int[] arrayD= {11,12,13};
25         System.out.println(arrayD[0]);
26         System.out.println(arrayD[1]);
27         System.out.println(arrayD[2]);
28     }

3、获取数组长度

无论动态还是静态初始化，数组都具有长度，如何才能获取长度呢？ 格式： 数组名称.length 将会得到一个int数字，代表数组的长度 【注意】 一个数组一旦在内存当中创建了，那么数组的长度就不能发生变化

1 public static void main(String[] args) {
2         int[] arrayA= {1,2,3,4,5,6};
3         System.out.println(arrayA.length);
4     }

4、数组索引越界异常

数组元素的索引编号，从0开始，一直到“长度-1”为止

如果一个数组长度为3，那么元素的编号分别是：0，1,2.没有3号元素的

如果访问的数组元素索引不存在，那么 将会发生数组索引越界异常

 1     public static void main(String[] args) {
 2         int[] arrayA = { 10, 20, 30 };
 3         System.out.println(arrayA[0]); // 10
 4         System.out.println(arrayA[1]); // 20
 5         System.out.println(arrayA[2]); // 30
 6         System.out.println("数组的长度：" + arrayA.length);
 7         System.out.println("=====================");
 8         System.out.println(arrayA[3]); // 编译没有报错，运行就报错！
 9         System.out.println(arrayA[-1]); // 数组索引从0开始，绝对不可能为负数
10     }

5、数组内存示意图

二、JAVA内存分配

1、栈(Stack)：主要用来存放局部变量

2、堆(Heap)：凡是new 出来的东西，都在堆当中。堆当中的数据有默认值规则

　　a)：整数，默认是：0

　　b)：浮点数，默认是：0.0

　　c)：字符，默认是："\u0000"(Unicode写法)

　　d)：布尔值，默认是：false

　　e)：引用类型(含字符串)，默认为null(空常量)

3、方法区(Method Area)：存放与class相关的信息

4、本地方法区(Native Method Area)：与操作系统相关

5、寄存器(pc Register)：与CPU相关，性能极高

 三、方法

 格式：

修饰符 返回值类型 方法名称(参数类型 参数名称)

{

　　…方法体

　　return 返回值;

}

解释：

修饰符：目前的固定写法：两个关键字，public static

返回值类型：方法最终产生的数据类型

方法名称：自定义的名称，规则和变量一样

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据，对应的变量名称

方法体：需要执行的若干行代码

return：有两个作用，第一结束当前方法，第二带着后面的返回值交给调用处

返回值：方法的最终数据结果

注意事项：

1、返回值类型必须和返回值对应

2、如果参数有多个，那么用逗号进行分割

调用：

1、单独调用

格式：方法名称(参数值);

在使用单独调用的时候，无法使用方法的返回值

2、打印调用

格式：System.out.println()

3、赋值调用

格式：数据类型 变量名称=方法名称(参数值);

调用方法，并且将返回值交给一个变量。注意，变量的数据类型必须和方法的返回值类型对应

 1 public class Demo03MethodInvoke {
 2     public static void main(String[] args) {
 3         //单独调用
 4         Sum(10,20);
 5         //打印调用
 6         System.out.println(Sum(30,40));
 7         //赋值调用
 8         int result=Sum(50,60);
 9         System.out.println(result);
10     }
11
12     public static int Sum(int a, int b) {
13         return a + b;
14     }
15 }

 方法调用图解

 四、方法重载

现在的问题描述 对于类似的多个方法，全都是执行相加的操作，但是因为参数列表不一样，所以需要记住多个名字，太麻烦！

解决方法 使用方法重载(Overload)的技术，可以达到效果 对于类似功能的多个方法，只要记住一个相同的方法名即可，可以根据参数列表的不同自动适配

方法重载(Overload)：方法的名称相同，但是参数列表不同。

注意事项

什么叫做参数列表不同？

1、参数的个数不同

2、参数的类型不同

3、参数 的多类型顺序不同

重载与下列因素无关

1、与返回值类型无关

2、与参数的名称无关

 1     public static void main(String[] args) {
 2         System.out.println(sum(10, 20));
 3         System.out.println(sum(10, 20, 30));
 4         System.out.println(sum(10, 20, 30, 40));
 5     }
 6
 7     public static int sum(int a, int b) {
 8         return a + b;
 9     }
10
11     public static int sum(int a, int b, int c) {
12         return a + b + c;
13     }
14
15     public static int sum(int a, int b, int c, int d) {
16         return a + b + c + d;
17     }

什么叫“参数传递”？

【形式参数(形参)】：在定义方法的时候，写在小括号之内的参数

eg：public static int sum(int a,int b){…}//这里的a和b是在定义的时候写的，所以是形式参数

【实际参数(实参)】：在调用方法的时候，真正传入方法里的数据，叫做实际参数

eg：int num=sum(10,20); //这里的10和20就是实际参数

 引用类型传参图解