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

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

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

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

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

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

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

1.数组相当于一个容器，可以装载同一个类型的多个数据。
   静态数组定义格式：int[] array =  new int[]{};
   静态数组的省略格式：int[] array = {元素1，元素2.....};
   动态数组定义格式：int[] array = new int[];
2.长度确定，数组的内容不确定使用动态赋值
   数组的内容确定，长度不确定使用静态赋值
3.堆中存放的是地址值，就是new出来的东西都在里面
   栈中主要存放的是局部变量
4.数组越界异常的原因是索引值写错了
   数组空指针异常的原因是没有new数据
5.参数是基本数据类型的时候，传递的是具体的值
   参数是引用数据类型的时候，传递的是参数的地址值

洪文生
1.什么是数组？数组的定义有哪几种格式？
数组是存放同一种数据类型的容器。
两种定义格式：动态和静态，静态又细分出一种简写格式。
动态格式：数据类型[]  数组名称 = new 数据类型[数组长度]；
静态格式：数据类型[]  数组名称 = new 数据类型[]  {元素1，元素2，。。。}；
静态的简写格式：数据类型[]  数组名称 =  {元素1，元素2，。。。}；

2.什么时候使用动态赋值？什么时候使用静态赋值？
当不确定数组内容时，使用动态赋值；反之，使用静态赋值。

3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是对象或者实体。栈中存放的是局部变量，包括方法中的局部变量。

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常：数组的索引值超过了相应数组的角标值。
空指针异常：数组被赋值为null时发生。

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是相对应的实际参数。
参数为引用数据类型的时候，传递的是相对应引用数据的地址值

贾宗虎

1.什么是数组？数组的定义有哪几种格式？
   将同一个数据类型的固定长度的多个数据,存放在一个容器里面统一管理,这个容器叫数组.   三种:   1) 数据类型[] 变量名 = new 数据类型[数组长度];
              2)数据类型[] 变量名 = new 数据类型[]{ 1,2,3,4,5,6,7.......};
              3)数据类型[] 变量名 = {1,2,3,4,5,6,7......................}
2.什么时候使用动态赋值？什么时候使用静态赋值？
   知道数组要存放多少个元素,但不知道具体元素的时候,用动态赋值.
   具体的知道要存放的每个元素的时候,用静态赋值.

3.堆中存放的是什么？栈中存放的是什么？
   new出来的,都放在堆里.
   栈中存放的 是 方法,以及方法中,在运行时所需要的数据

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
    数组越界异常: 使用数组的索引值 超过了数组的长度-1.
    空指针异常 : 访问的索引值所在的数组元素为null

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

   为基本类型的时候,传递的是具体的数据
   为引用数据类型的时候,传递的是这个数据在内存中的 地址值.

林梅源

1.什么是数组？数组的定义有哪几种格式？
数组就是存放数据的容器，有三种格式；
动态格式； 数据类型[ ] 数组名称 = new 数据类型[ 数据个数]；如；int [ ] array = new int [5] ;
静态格式； 数据类型[ ] 数组名称 = new 数据类型[ ]{元素1，元素2.。。。。。。。} ；
                  如；int [ ] array = new int []{1,2,3,4,5} ;
省略静态格式；  数据类型[ ] 数组名称 ={元素1，元素2.。。。}如；int [ ] array = {1,2,3,4,5} ;
2.什么时候使用动态赋值？什么时候使用静态赋值？
知道元素具体个数的时候用动态赋值，不知道具体个数的时候用静态。
3.堆中存放的是什么？栈中存放的是什么？
new出来的东西；
是方法在执行时的相关的内容；
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引越界，数组个数错误；
空指针异常，null；

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

1.什么是数组？数组的定义有哪几种格式？
数组就是存放数据长度固定的容器，容器内的数据的数据类型要一致；
数组的定义分为三种格式
（1）动态初始化类型
格式：数据类型[ ]  数组名=new  数据类型[数组长度 ]
例子：int[] arr = new int[5];
（2）标准的静态初始化
格式：数据类型[ ]  数组名=new  数据类型[ ]{元素1，元素2，元素3...}
例子：int[] arr = new int[]{1,2,3,4,5};
（3）省略的静态初始化
格式：数据类型[ ]  数组名={元素1，元素2，元素3...}
例子：int[] arr ={1,2,3,4,5};

2.什么时候使用动态赋值？什么时候使用静态赋值？
当初始值为0的时候使用动态赋值，初始值为一直基本数据类型的元素的时候使用静态赋值


3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是使用new创建的对象，栈中存放的是存放方法中的局部变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是因为索引超出数组本身的索引值范围；
数组空指针异常是因为数组中的元素布在保存数组地址里面

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

官启文
1.什么是数组？数组的定义有哪几种格式？
数组就是一个容器，可以同时存储多个数据，
1，动态，数据类型[] a = new 数据类型[index];
2，静态, 数据类型[] b = new 数据类型[]{1，2，3}；
         数据类型[] c ={1，2，3}；

2.什么时候使用动态赋值？什么时候使用静态赋值？
数据不明确用动态，明确用静态

3.堆中存放的是什么？栈中存放的是什么？
堆内存放new，栈放方法和参数。

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
index超出数组长度，
int [] a=null;
System.out.println(a[0]);

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

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

数组就是存储多个相同类型数据的集合，属于引用数据类型。
动态初始化：（1）数据类型[] 数组名称 = new 数据类型[数组长度]；
静态初始化：（2）数据类型[] 数组名称 = new 数据类型[]{元素1,元素2……}；
           （3）数据类型[] 数组名称 = {元素1,元素2……}；

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

当不知道数组内容时用动态初始化，知道具体内容时用静态初始化。

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

堆中存放的是new出来的数据；栈中存放的是变量。

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

数组越界异常一般是引用索引值超过了定义值；当未给数组初始化时会出现数组空指针异常。

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

参数为基本数据类型的时候，传递的是具体数据；参数为引用数据类型的时候，传递的是地址值；

吴香斌
1.什么是数组？数组的定义有哪几种格式？
数组类似于一个容器，可以用来存储多个数据。
有三种格式：
1.动态方式：数据类型[] 数组名称 = new 数据类型[长度值];
2.静态方式：数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，...}；
3.简略方式：数据类型[] 数组名称 = {元素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 数据类型[] { 元素1, 元素2, … };
                3、省略的静态初始化
                        数组类型[] 数组名称 = { 元素1, 元素2, … };

2.什么时候使用动态赋值？什么时候使用静态赋值？
        创建数组时需要指定数组长度，使用动态赋值。
        创建数组时不需要直接指定数组长度，而是直接指定数组的具体元素时，使用静态赋值。

3.堆中存放的是什么？栈中存放的是什么？
        堆中存放的是new出来的东西。
        栈中存放的是方法中的局部变量。方法的运行一定要在栈中运行。

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
        访问数组元素时，指定的索引编号不存在，就会产生数组越界异常ArrayIndexOutOfBoundsException。
        创建数组时，只是赋值为null，在操作该数组时就会产生空指针异常NullPointerException。

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

刘杭生

1.什么是数组？数组的定义有哪几种格式？
        1）数组就是存储数据长度固定的容器
        2）        1.数据类型[] 数组名字 = new 数组存储的数据类型[长度];
                2.数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
                3.数据类型[] 数组名 = {元素1,元素2,元素3...};
       
2.什么时候使用动态赋值？什么时候使用静态赋值？
        1）如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

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

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
        1）是访问数组元素的时候，索引编号并不存在，产生的。
        2）数组如果只是赋值了一个null，没有进行new创建，会产生空指针异常现象。

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
        1）基本数据类型的时候，传递的是具体的值。
        2）参数为引用数据类型的时候，传递的是地址值。

王博

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

2.什么时候使用动态赋值？什么时候使用静态赋值？
只知道数组长度就用动态初始化
知道内容就用动态初始化


3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是new出来的
栈中存放的是方法和变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引值超过了数组的长度就会产生越界异常
数组值为空值时会产生空指针异常


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

刘慧梅
1.什么是数组？数组的定义有哪几种格式？
数组相当于一种容器，可以同时存放多个数据
三种格式：
动态初始化格式：数据类型[] 数组名 = new 数据类型[数组长度];
静态初始化格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
静态初始化省略格式：数据类型[] 数组名 = {元素1,元素2,元素3...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
知道数组中的数据内容时使用动态赋值；不知道数组中的数据内容时使用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是new出来的东西；栈中存放的是方法中的局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组的越界异常因为索引值写错。
数组中的空指针异常时因为没有写new。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是具体的基本类型数值。

参数为引用数据类型的时候，传递的是内存中的地址值。

1.什么是数组？数组的定义有哪几种格式？
数组是存放基本类型或者引用数据类型的容器。
定义的方式有动态初始化，静态初始化，省略的静态初始化。

2.什么时候使用动态赋值？什么时候使用静态赋值？
指定长度的时候用动态赋值，指定内容的时候用静态赋值

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

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
   数据越界异常是使用了索引超出数组长度的值。
   数组空指针异常是数组指向一个null的对象。

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

1：数组：存储数据的固定容器.
动态数组格式:数组类型[]数组名=new 数组类型[数组长度]
静态省略格式：数组类型[]数组名={元素1，元素2，元素3，……….}
格式2；数组类型[]数组名=new 数组类型[]{元素}

2：长度确定，数组元素不确定用动态，反之用静态.
3堆中存放new的东西，栈中存方法数据
4:调用的数组元素超出了数组长度；没有数据
5：传递具体的值；地址
  

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

一个可以用来放数据的容器。
有三种。一种动态两种静态。
动态：数组类型[]数组名称=new数组类型[]
静态：数组类型[]数组名称=new数组类型[]{}
简化静态：数组类型[]数组名称={};

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

知道具体长度的时候用动态赋值。其余时候用静态赋值。

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

栈中存放的是方法中的局部变量 例如数组名称。堆中存放的是new出来的东西

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

使用数组里面的东西的时候，索引值比0小比数组长度大即会产生。
空指针异常是数组中为null 还去使用数组就会产生。

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

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

姓名：刘宵
1.什么是数组？数组的定义有哪几种格式？

数组就是存放一组数据类型相同的一个长度不可改变的容器。
数组定义有三种格式。①数据类型 [] 数组名=new 数据类型[数组长度]
                                        ②数据类型 [] 数组名=new 数据类型[]｛数组元素｝
                                        ③数据类型 [] 数组名={数组元素}

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

当数组元素内容不知道的时候使用动态赋值，反之使用静态赋值。

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

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

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

当数组的索引值的取值范围，不在数组范围内的时候，就会出现数组越界异常。
数组空指针异常是数组所指向的地址为空时，就会出现空指针异常。

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

参数为基本数据类型的时候，传递的是地址单元中的内容也就是数据，为引用类型的时候，传递的是该参数的地址值。

彭东亮
1.什么是数组？数组的定义有哪几种格式？
数组是一个数据的集合，且该集合的数据的数据类型必须相同；
数据有三种格式，其中数组的动态初始化格式：（1）数据类型 [] 数组名称=new 数据类型 [长度];数组的静态初始化：（2）数据类型 [] 数组名称=new 数据类型 [] {元素1、元素2...};（3）数据类型 [] 数组名称={元素1、元素2...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
当数组中元素不确定是用动态赋值；数组中元素确定是用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放new出来的数据，栈中存放main方法
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
当索引超出数组的长度则会产生数组的越界异常；当数组为空时，则会产生数组空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数作为基本数据类型的时候，传递的是数据值；参数作为应用数据类型的时候，传递的是地址值。

王宇晨
1.什么是数组？数组的定义有哪几种格式？
     数组相当于一个容器，可以存放多个数据。     动态初始化数组格式：数据类型[] 数组名 = 数据类型[数组长度]；
     静态初始化数组基本格式：数据类型[] 数组名 = 数据类型[]{元素1，元素2...}；
     静态初始化数组省略格式：数据类型[] 数组名 = {元素1，元素2...}；
2.什么时候使用动态赋值？什么时候使用静态赋值？
     如果不确定数组的具体内容就用动态赋值；
     如果已经确定了数组的具体内容就用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
      堆中存放的是new出来的东西；
      栈中存放的是方法中的局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
       越界异常：在访问数组是找不到索引值
       空指针异常：数组只进行了null赋值，没有进行new创建。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？

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

1.什么是数组？数组的定义有哪几种格式？
数组是用来存储多个同类型数据的容器;定义有三种格式：（1）数据类型[] 数组名 = new 数据类型[数组长度];（2）数据类型[] 数组名 = new 数据类型[]{数据1,数据2...};（3）数据类型[] 数组名 = {数据1,数据2...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
当不确定数组内的具体数据时，使用动态赋值比较方便。当在初始化数组时就确定了数组所需的元素，则使用静态赋值比较方便。
3.堆中存放的是什么？栈中存放的是什么？
堆内存中存储的是创建的对象或数组，new创建的都存在堆内存中。栈内存存放的是方法运行时使用的内存，包括方法中的局部变量等。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是索引的数值超出了数组的长度产生的。数组空指针异常是数组的引用地址为空引起的。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
传递的是具体的数据类型的常量值。
传递的是对象的内存地址。

1.什么是数组？数组的定义有哪几种格式？
数据容器   3种格式
如  int[] arr =int[5]
     int[] arr =int[]{1,2,3,4,5}
     int[] arr = {1,2,3,4,5}
2.什么时候使用动态赋值？什么时候使用静态赋值？
   不知道具体元素使用动态，知道使用静态
3.堆中存放的是什么？栈中存放的是什么？
堆内存存放数据 数组  栈内存 为运行内存
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
  索引超过数组个数   数组为空
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
  数值   堆内存地址

1.相同元素类型的一组数据，有三种定义格式
2.在知道长度用动态，不知道用静态
3.堆中存放数组值，栈中存放方法名和地址
4.超过数组长度，未初始化数组
5.数值，地址’

1.数组：存储多个数据类型相同的数据，长度固定的容器。
   格式：动态初始化   数据类型[ ] 数组名=new 数据类型[元素长度]；
             静态初始化   数据类型[ ] 数组名=new 数据类型[ ]{元素1、元素2...}
             省略的静态初始化   数据类型[ ] 数组名={元素1、元素2...}
2.当元素众多赋值困难时使用动态；元素少能赋值方便时用静态。
3.堆中放的是new出来的内容，数组数据，地址；栈中是main方法进栈，数组名，数组赋值的值。
4.数组越界异常：数组索引超出了数组的长度。  空指针：空常量null赋值给数组。
5.参数为基本数据类型时传递的是数据值。参数为引用数据类型时传递的是地址值。

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

数组相当于一个用来存储数据类型相同的容器，

动态初始化： 数据类型[ ] 数组名字 = new 数据类型[长度];

静态初始化： 数据类型[ ] 数组名字 = new 数据类型[ ]{元素1，。。。元素n};

省略的静态初始化: 数据类型[ ] 数组名字 = {元素1，。。。元素n};

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

只知道数组的长度用动态初始化，直到数组的元素用静态初始化

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

new出来的都在堆内存中；
栈中存放的是方法，

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

指定的数组索引值超出的数组索引；空指针是指，定义了数组没对数组赋值。

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

数组在传递时都是传递的地址值