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

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

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、数组就是存放多个数据的容器；
定义格式：数据类型 [ ] 数组名称=new 数据类型 [数组长度]；
                 数据类型 [ ] 数组名称=new 数据类型 [ ]{元素1，元素2，....}；
                 数据类型 [ ] 数组名称={元素1，元素2，...};
2、当知道数组长度，不知道数组元素时用动态赋值；
     当知道数组元素不知道数组长度时用静态赋值；
3、堆中存放的是new出来的东西；
     栈中存放的是变量；
4、数组越界异常：索引超出数组长度；
     数组空指针异常：数组赋值为null；
5、参数为基本数据类型的时候，传递的是数值；；
     参数为引用数据类型的时候，传递的是地址值；

刘思聪

1.什么是数组？数组的定义有哪几种格式？
数组是保存多个同种数据类型的变量的容器，定义方式有：动态初始化：
数据类型[] 数组名()=new 数据类型[数组长度];

静态初始化：
标准：数据类型[] 数组名()=new 数据类型[]{元素1,元素2,.....};
简化：数据类型[] 数组名()={元素1,元素2,.....};


2.什么时候使用动态赋值？什么时候使用静态赋值？
当数组长度已知时候使用动态赋值

当知道具体的每个元素的值的时候使用静态赋值。


3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是所有new出来的东西（目前的话包括数组的具体的元素值等引用类型数据的具体内容）

栈中存放的是方法在执行时的相关的内容（如方法内的变量、创建的数组的地址值等）

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组索引越界异常是因为所写的索引值超出了要访问的数组的索引值的范围（超过了数组长度-1或者出现了负数等）。
空指针异常则是引用了为null的情况下去试图访问具体的元素（即引用了不存在的数组的时候却偏要访问其中的元素）

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

基本类型传递的时候传递的是具体的值。引用类型在传递的时候，传递的是该引用的地址值。

1. 数组：数组就是存储数据的固定容器，多个数组类型要一致。
动态初始化：数据储存的数组类型[] 数组名字 = new 数组的类型【长度】；
静态初始化：数据类型【】 数组名字 = new 数组的类型{元素1，元素2.元素3.。。。}
省略型静态：数组类型【】 数组名字 ={元素1，元素2，元素3......}
2知道元素的数据时用静态，只知道长度时用动态
3堆中存放的是new出来的数据’，栈中存放的是方法？
4.越界异常就是超出了数组的长度。空指针异常就是没有数据
5作为基本数据类型时，传递的是本身的数据类型，作为引用数据类型时，传递的是地址

1.用来储存长度固定 数据类型一致的容器 int[] a=new int[] int[] a=new int[]{}  int[] a={}
2.元素个数确定时
3. 数据    地址
4.int[] a={0};souta[1]  a=null
5.数据 地址

唐杰

1.什么是数组？数组的定义有哪几种格式？
数组是用于存放多个相同数据的容量,有三种定义格式,动态初始化,静态初始化以及简化的静态初始化.

2.什么时候使用动态赋值？什么时候使用静态赋值？动态赋值的特性是指定长度,静态的特性是指定内容,当不知道具体内容的时候用动态.

3.堆中存放的是什么？栈中存放的是什么？
使用new创建出来的数据都是存放在堆中.
栈中存放的是方法中的局部变量(方法的参数或者{}中的变量),方法的运行一定要在栈中运行.

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常时因为调用的数组元素索引值超过了数组的长度.
数组空指针是指向地址为空,没有数据.

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

基本参数类型的时候,传递的是一个基本类型的值.
引用数据类型时,传递的是一个地址值到方法.

一、数组好比一个 容器，它可以同时存放多个元素。
数组的定义有两种方式：
1、静态初始化化数组格式
2、动态初始化数组格式
其中静态初始化有两种：一种是标准初始化数组，还有一种是简化初始化数组。
二、一般不确定内容使用动态，确定内容使用静态

三、堆中存放的new出来的对象，栈中存放的是引用数据类型，就比如数组名和变量名之类的。

四、数组越界指的是存放的数据超过了定义的容量。空指针指的是只是给数组定义，没有创建对象。这样的数组是没有空间的，在给数组赋值的时候就会报空指针异常。
五、参数为基本数据类型的时候传的是实际的数值，而参数为引用数据类型的时候传的是内存地址的哈希值。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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