1.什么是数组？数组的定义有哪几种格式？
存放多个数据值的容器
三种：
  动态：数据类型 [ ] 数组名称 = new 数组类型 [数组长度]；
  静态（标准）：数据类型[ ] 数据名称 = new 数据类型 [ ] { 元素1，元素2，...};
  静态（省略）：数据类型[ ] 数据名称 = { 元素1，元素2，...};

2.什么时候使用动态赋值？什么时候使用静态赋值？
动态：不确定数组的具体内容；
静态：已知数组的具体内容；

3.堆中存放的是什么？栈中存放的是什么？
栈：存放局部变量；方法的运行也在其中；
        堆：new出来的数据，这些数据都有一个地址值；

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引越界异常：访问数组的索引编号不存在时，会发生数据索引越界异常，即索引编号写错 ；
空指针：数组必须进行new初始化才能使用其中的元素，如果只赋一个null，没有进行new化，就会发生空指针异常，即忘了new；

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
数据内容
基本数据：变量值；
引用数据：地址值。

1.什么是数组？数组的定义有哪几种格式？ 存储相同类型的数据  动态跟静态

2.什么时候使用动态赋值？什么时候使用静态赋值？ 知道数据的长度 用动态 知道具体的数值 用静态

3.堆中存放的是什么？栈中存放的是什么？  数组

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？ 越位

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？

王佳盛


1.        什么是数组？数组的定义有哪几种格式？

答：数组是就像一个容器，用来存蓄同一种数据类型的多个数据；
        动态初始化：数据类型[]  数组名称 = new 数据类型[数组长度];
        静态初始化：数据类型[]  数组名称 = new 数据类型[]{元素1，元素2，….};
静态省略格式初始化：数据类型[]  数组名称 = {元素1，元素2，….};

2.        什么时候使用动态赋值？什么时候使用静态赋值？

答：在确定数组内容的时候使用静赋值；不确定数组内容使用动态赋值。

3.        堆中存放的是什么？栈中存放的是什么？

答：凡是new出来的东西都存在堆中；栈存储的是方法中的局部变量，方法的运行一定要在栈中运行。

4.        数组越界异常是怎么产生的？数组空指针异常是怎么产生的？

答：数组越界异常通常是发生使用数组元素时用的索引值超出了数组长度；
        数组空指针异常通常是因为没有new，直接复制null导致的；

5.        参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？

答：参数为基本数据类型时，传递的是变量里面的值；
        参数为引用数据类型时，传递的是数组的地址值。

1.什么是数组？数组的定义有哪几种格式？
（1）数组可以理解成一种容器，用来存放各种数据的。
（2）动态初始化：数据类型[] 数组名称 = new 数据类型[数组长度]
     静态初始化：数据类型[] 数组名称 = new 数据类型[]{元素1，元素2...};
       省略格式：数据类型[] 数组名称 = {元素1，元素2...};;
2.什么时候使用动态赋值？什么时候使用静态赋值？
（1）在知道数组的长度但是内容不知道的时候使用动态赋值，
（2）在知道数组的具体内容时，使用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
（1）堆当中存放的是new出来的东西；
（2）栈存放的是方法中的局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
（1）数组越界异常是因为使用数值访问数组元素时，索引标号找不到，就会数组越界异常
（2）数组必须要new初始化才可以使用，如果我们对数组赋值null，并没有进行new初始化，就会造成数组空指针。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
（1）参数为基本数据类型时，传递的是数据值；
（2）参数为引用数据类型时，传递的是地址值。

1.什么是数组？数组的定义有哪几种格式？
数组：是存储数据长度固定的容器，多个数据的数据类型要保持一致；
定义格式：数据类型[] 数据名称 = new 数据类型[数组长度]；
数据类型[] 数据名称 = new 数据类型[]{}；
数据类型[] 数据名称 = {}；

2.什么时候使用动态赋值？什么时候使用静态赋值？
知道数组具体内容时，用静态赋值；
不知道数组具体内容时，用动态赋值；

3.堆中存放的是什么？栈中存放的是什么？
堆中存放：new出来的东西都存放在堆中；
栈中存放：执行方法时，要让方法区中的方法进栈；

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常：当数组的索引值大于等于数组的长度
数组空指针异常：给数组赋值null的时候

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是变量值
参数为引用数据类型的时候，传递的是数据的地址

-今天我们学习了数组，请根据自己的理解对下列问题进行回答：

今天需要掌握的知识点有：

1.什么是数组？数组的定义有哪几种格式？
答：数组是一种容器，可以同时存放多个统一类型的数据值。
    数组的定义格式有动态初始化，和静态初始化，以及省略的静态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：当不清楚数组当中的具体内容，选择动态赋值，反之，用静态赋值！
3.堆中存放的是什么？栈中存放的是什么？
答：堆中存放的是new出来的数据，会有一个地址值。
    栈中存放的是方法的局部变量（局部变量：方法的参数）
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：在访问数组元素时，如果索引编号不存在，将会产生越界异常。
    在创建数组时，如果只是赋值了一个null，没有进行new创建，将会发生空指针异常
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候，传递的是实际的参数的返回值！
    参数为引用数据类型的时候，传递的是地址值！

1.什么是数组？数组的定义有哪几种格式？
数组是一种容器，可以同时存放多个数据库
静态初始值数组的标准格式：
数据类型[]数据名称 = new 数据类型[]{}
静态初始值数组的省略格式：
数据类型[]数据名称 = {}
动态初始值数组的标准格式：
数据类型[]数据名称 = new 数据类型[数据长度]
动态初始值数组的省略格式：
数据类型[]数据名称；
数据名称=new 数据类型[数据长度]
2.什么时候使用动态赋值？什么时候使用静态赋值？
如果不确定数组中的具体内容时，用动态赋值
如果已知数组中的具体内容时，用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
只要是new出来的，都存放在堆中。
方法的局部变量存放在栈中。
局部变量：方法的参数，或者是方法{}内部的变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常：如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常
空指针异常：数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候传递返回值；参数为引用数据类型的时候传递的是数组内存的地址

-今天我们学习了数组，请根据自己的理解对下列问题进行回答：

今天需要掌握的知识点有：

1.什么是数组？数组的定义有哪几种格式？
数组的概念：是一种容器，可以同时存放多个数据值。
格式：动态初始化和静态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
3.堆中存放的是什么？栈中存放的是什么？
堆存放的是new出来的数据，,栈存放的是变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常：如果访问数组元素的时候，索引编号并不存在，那么将会发生
数组索引越界异常。
空指针：数组必须进行new初始化才能使用其中的元素，如果只赋一个null，没有进行new化，就会发生空指针异常，即忘了new；

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候传递返回值；参数为引用数据类型的时候传递的是数组内存的地址。

1.什么是数组？数组的定义有哪几种格式？
数组：存储统一数据类型的容器
数组定义的格式：
1.数据类型[]数组名称=new 数据类型[数据长度];
2.数据类型[]数组名称=new 数据类型[]{元素1,元素2, ...};
3.数据类型[]数组名称={元素1,元素2, ...};

2.什么时候使用动态赋值？什么时候使用静态赋值？
知道数组长度时使用动态赋值，
知道数组内容时使用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
堆中存放 new的数据；栈中存放局部变量,运行方法

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常：当调用数组的索引值在数组中不存在
数组空指针异常：当数组赋值null

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是变量
参数为引用数据类型的时候，传递的是数组内存地址

数组是一种容器，可以同时存放多个数据值；它分两种格式，分别是动态初始化和静态初始化。

如果不确定数组里的具体内容，就用动态初始化；或者已经确定了具体内容，那么就用静态初始化。

凡是new出来的东西，都在堆当中；栈中存放的都是方法中的局部变量。

创建数组，赋值3个元素，数组的索引就是[ 0 , 1 , 2 ]没有[ 3 ]索引，因此我们不能访问数组中不存在的索引，
程序运行后，将会抛出"ArrayIndexOutOfBoundsException"数组越界异常。

如数组被赋为null，将不会保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出"NullPointerException"空指针异常。

参数为基本数据类型的时候传递返回值；参数为引用数据类型的时候传递的是数组内存的地址。

1.什么是数组？数组的定义有哪几种格式？
定义：是一种容器，可以存放多个数据值
格式：
1.数据类型[]  数组名称  =  new  数据类型[数组长度]
2.数据类型[] 数组名称 = new 数据类型[]{元素1，元素2...}
3.数据类型[] 数组名称 ={元素1，元素2...}；

2.什么时候使用动态赋值？什么时候使用静态赋值？
不确定内容用动态，确定内容用静态

3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是new出来的东西，一个地址值；
栈中存放的是方法的局部变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引异常时索引超出范围，
如数组被赋为null，将不会保存数组的内存地址，也就不允许再操作数组了

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是数值；
参数为引用数据类型的时候，传递的是地址值；

1.什么是数组？数组的定义有哪几种格式？
数组是数据储存固定长度的容器，保证多个数据的数据类型一致
数组定义有三种格式
动态数组格式： 数据类型[] 数组名 = new 数据类型[数组长度];
静态数组格式： 数据类型[] 数组名 = new 数据类型[] { 元素1,元素2,元素3,... };
静态数组省略格式: 数据类型[] 数组名 = { 元素1,元素2,元素3,... };

2.什么时候使用动态赋值？什么时候使用静态赋值？
当知道数组长度时使用动态赋值，知道数组内容与长度时使用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是new出来的数组，栈中存放的是局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是数组索引值超出范围
数组空指标异常是数组赋值为null时，将不会保存数组的内存地址，也就不允许再操作数组了
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是数据值值
参数为引用数据类型的时候，传递的是地址值

1.什么是数组？数组的定义有哪几种格式？
答：
        概念：可以同时存放多个数据值的容器；
        格式：
                动态：数据类型 [ ] 数组名称 = new 数组类型 [数组长度]；
                静态（标准）：数据类型[ ] 数据名称 = new 数据类型 [ ] { 元素1，元素2，...};
                静态（省略）：数据类型[ ] 数据名称 = { 元素1，元素2，...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：
        适用场景：
                动态：不确定数组的具体内容；
                静态：已知数组的具体内容；
3.堆中存放的是什么？栈中存放的是什么？
答：
        栈：存放局部变量；方法的运行也在其中；
        堆：new出来的数据，这些数据都有一个地址值；
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：
        索引越界异常：访问数组的索引编号不存在时，会发生数据索引越界异常，即索引编号写错 ；
        空指针：数组必须进行new初始化才能使用其中的元素，如果只赋一个null，没有进行new化，就会发生空指针异常，即忘了new；
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：
        基本数据：变量值；
        引用数据：地址值。

1.什么是数组？数组的定义有哪几种格式？
数组是能同时存储若干个数据的一个容器，数组有两种定义格式，分别是动态初始化和静态初始化。

2.什么时候使用动态赋值？什么时候使用静态赋值？

如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

3.堆中存放的是什么？栈中存放的是什么？

堆中存放的是new创建的东西
栈中存放的是运行中的方法和局部变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？

数组越界索引异常的产生是由于访问了数组中不存在的索引；
数组空指针异常的产生是由于没有给数组提供地址值

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？

参数为基本类型时,传递的是数据值. 参数为引用类型时,传递的是地址值

1.什么是数组？数组的定义有哪几种格式？
数组：是一种容器，可以存放多个数据值。
数组的定义有三种格式：
（1）动态初始化（指定长度）格式：数组格式： 数据类型[] 数组名称 = new 数据类型[数组长度]；
（2）静态初始化（指定内容）分两种格式：
①基本格式：数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，。。。。};
②省略格式：数据类型[] 数组名称 = {元素1，元素2，。。。。};

2.什么时候使用动态赋值？什么时候使用静态赋值？
（1）在不确定数组当中的具体内容，用动态赋值；
（2）已经确定了具体的内容，用静态赋值。

3.堆中存放的是什么？栈中存放的是什么？
（1）.堆（Heap）：new出来定义的东西都在这里面
（2）栈（Stack）：存放的都是方法中的局部变量。方法的运行一定是在栈当中运行！

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
（1）数组越界异常产生原因：在访问数组元素的时候，索引的编号不存在就会引起数组越界异常。
（2）数组空指针异常原因：数组进行了new的初始化才能使用数组中的元素，如果只赋值null没有new创建就会发生数组空指针异常。

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
（1）参数为基本数据类型的时候传递进去的就是数据值。
（2）参数为引用数据类型的时候传递进去的其实是数组的地址值。

1.什么是数组？数组的定义有哪几种格式？
数组：是存储数据长度固定的容器，多个数据的数据类型要保持一致；
定义格式：数据类型[] 数据名称 = new 数据类型[数组长度]；
数据类型[] 数据名称 = new 数据类型[]{}；
数据类型[] 数据名称 = {}；
2.什么时候使用动态赋值？什么时候使用静态赋值？
（1）在不确定数组当中的具体内容，用动态赋值；
（2）已经确定了具体的内容，用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是new创建的东西
栈中存放的是运行中的方法和局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引越界异常：访问数组的索引编号不存在时，会发生数据索引越界异常，即索引编号写错 ；
空指针：数组必须进行new初始化才能使用其中的元素，如果只赋一个null，没有进行new化，就会发生空指针异常，即忘了new；
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本类型时,传递的是数据值. 参数为引用类型时,传递的是地址值.

[b]1.什么是数组？数组的定义有哪几种格式？
        数组是用来装数据的容器，更加方便存储数据。
        数组的定义有三种格式：
                1.动态初始化：数据类型 [] 数组名称 = new 数据类型 [数组长度];
                2.静态初始化：数据类型 [] 数组名称 = new 数据类型 []{元素1，元素2，元素3.....};
                3.静态初始化省略格式：数据类型 [] 数组名称 = {元素1，元素2，元素3.....};

2.什么时候使用动态赋值？什么时候使用静态赋值？
        不确定数组之中具体内容时候用动态赋值，有具体的内容用静态赋值。

3.堆中存放的是什么？栈中存放的是什么？
        堆中存放的的都是new出来的东西，堆内存里面存放的东西都有一个地址值，数据都有默认值
        栈中存放的都是方法中的局部变量。

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
        数组越界异常是我们访问了数组中不存在的索引，程序运行时会提示错误
        数组空指针异常是我们给数组赋值一个空常量null，因此运行时会提示错误
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
        参数为基本数据类型的时候，传递的是数据值。
        参数为引用数据类型的时候，传递的是地址值。

1.什么是数组？数组的定义有哪几种格式？
数组就是容器
动态初始化：
数据类型[] 数组名 = new 数据类型[元素个数]
静态初始化：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2....}
数据类型[] 数组名 ={元素1，元素2....}

2.什么时候使用动态赋值？什么时候使用静态赋值？
如果不确定数组里的具体内容，就用动态初始化
确定了数组的具体内容，用静态初始化

3.堆中存放的是什么？栈中存放的是什么？
堆中放的是new出来的东西
栈中存放的是方法的局部变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
访问的数组的索引值超过数组的最大索引
数组赋值为null时，内存中没有地址值。

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数是基本数据类型：传递的时数据类型的返回值；
参数是引用类型：传递的是参数所引用的数据的地址值

1.什么是数组？数组的定义有哪几种格式？
数组就是容器
动态初始化：
数据类型[] 数组名 = new 数据类型[元素个数]
静态初始化：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2....}
数据类型[] 数组名 ={元素1，元素2....}

2.什么时候使用动态赋值？什么时候使用静态赋值？
如果不确定数组里的具体内容，就用动态初始化
确定了数组的具体内容，用静态初始化

3.堆中存放的是什么？栈中存放的是什么？
堆中放的是new出来的东西
栈中存放的是方法的局部变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
访问的数组的索引值超过数组的最大索引
数组赋值为null时，内存中没有地址值。

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数是基本数据类型：传递的时数据类型的返回值；
参数是引用类型：传递的是参数所引用的数据的地址值

1.什么是数组？数组的定义有哪几种格式？
答：
数组是一种容器，可以存放多个数据值；
数组定义有两种，
（1）动态初始化：数据类型[] 数组名称=new 数据类型[数组长度]
（2）静态初始化：数据类型[] 数组名称=new 数据类型[]{数组内容}；
（3）静态初始化的省略格式：数据类型[] 数组名称={数组内容}；

2.什么时候使用动态赋值？什么时候使用静态赋值？
答：当数组内容已知，使用静态赋值，未知使用动态赋值。

3.堆中存放的是什么？栈中存放的是什么？
答：堆heap：凡是new出来的东西都在堆中，堆里面的东西都有一个16进制的地址值；都有默认值；
栈stack：存放方法中的局部变量，方法的运行一定要在栈中运行。


4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：当数组索引值超过数组的长度减1就会访问数组中不存在的索引，此时就是数组越界异常；
数组如果只是赋值了一个null而没有new创建，就会发生数组空指针异常。

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候，传递的是常量值；
参数为引用数据类型的时候，传递的是地址值。