黑马程序员技术交流社区

标题: 【厦门JavaEE基础6期-每日总结】数组 [打印本页]

作者: 厦门校区 时间: 2019-3-4 18:43
标题: 【厦门JavaEE基础6期-每日总结】数组
今天我们学习了数组，请根据自己的理解对下列问题进行回答：

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

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

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

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

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

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

作者: Wyt1935 时间: 2019-3-4 21:30
本帖最后由 Wyt1935 于 2019-3-4 21:36 编辑

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

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

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

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

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

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

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

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

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

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

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

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

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

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

作者: 廖艺铭 时间: 2019-3-4 21:36
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致;
三种
1)动态初始化数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
2)静态初始化(标准格式) 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
3)静态初始化(省略格式) 数据类型[] 数组名 = {元素1,元素2,元素3...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
当不确定数组中元素的值时使用动态赋值;
当数组元素的值可以确定时使用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是程序中new出来的内容，对象或者数组
栈中存放的是方法中的局部变量，方法运行时会入栈执行
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是由于访问数组元素时索引超出数组长度，运行后产生;
数组空指针异常是由于数组名赋值为null后，不再保存数组的内存地址，此时如果再操作数组运行时就会产生空指针异常
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型时传递的是参数存储的值;
参数为引用数据类型时传递的是该引用存储的地址值

作者: 郑海波 时间: 2019-3-4 21:37
1.什么是数组？数组的定义有哪几种格式？
答：数组含义——数组是一种容器，可以同时存放多个数据值；
它分两种格式，分别是动态初始化和静态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：如果不确定数组里的具体内容，就用动态初始化；如果已经确定了具体内容，就用静态初始化。
3.堆中存放的是什么？栈中存放的是什么？
答：凡是new出来的东西，都在堆当中；栈中存放的都是方法中的局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：当访问数组的某个值的位置超过数组的最大长度，运行时就会产生越界异常；
如果赋予数组为null，将不会保存数组的内存地址，也就不允许再操作数组，因此运行的时候会抛出"NullPointerException"空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候传递返回值；参数为引用数据类型的时候传递的是内存的地址。

作者: 黑马6期陈华 时间: 2019-3-4 21:39
1.什么是数组？数组的定义有哪几种格式？
（1）数组就是一种可以容纳多个数据的容器。
（2）数组的定义有两种格式：
静态初始化，例：int[] arr = { 1, 2, 3 };
动态初始化，例：int[] arr = new int[ 3 ];
2.什么时候使用动态赋值？什么时候使用静态赋值？
（1）当数组的元素个数确定时，使用静态赋值；
（2）当数组的元素个数不确定时，使用动态赋值。
3.堆中存放的是什么？栈中存放的是什么？
（1）堆中存放着所有new出来的东西，以及他们的16进制地址值，还有各个数据所对应的默认值、数据值；
（2）栈中存放着方法中的局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
（1）数组越界异常：一个数组的元素索引值从0开始，一直到arr.length-1为止。如果在程序运行过程中对元素的调用超出了这个范围，则会抛出数组越界异常；
（2）数组空指针异常有两种情况：
情况一：当一个数组只是被定义了而没有new来初始化的时候，此时去调用数组里的元素，会抛出空指针异常；
情况二：当一个数组被赋值为null的时候，此时去调用数组里的元素，也会抛出空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
（1）参数为基本数据类型的时候，传递的是变量所存储的常量值；
（2）参数为引用数据类型的时候，传递的是参数所引用的在堆中的地址值，以对堆内存中的引用数据进行操作。

作者: 陈前凌 时间: 2019-3-4 21:39
1.什么是数组？数组的定义有哪几种格式？
定义：是一种容器，可以存放多个数据值
格式：
1.数据类型[] 数组名称 = new 数据类型[数组长度]
2.数据类型[] 数组名称 = new 数据类型[]{元素1，元素2...}
3.数据类型[] 数组名称 ={元素1，元素2...}；

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

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

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

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

作者: 刘曾铭 时间: 2019-3-4 21:41
1.什么是数组？数组的定义有哪几种格式？
      概念：可以同时存放多个数据值的容器；
      格式：
            动态：数据类型 [ ] 数组名称 = new 数组类型 [数组长度]；
            静态（标准）：数据类型[ ] 数据名称 = new 数据类型 [ ] { 元素1，元素2，...};
            静态（省略）：数据类型[ ] 数据名称 = { 元素1，元素2，...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
         适用场景：
            动态：不确定数组的具体内容；
            静态：已知数组的具体内容；

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

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

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

作者: 陈志铖 时间: 2019-3-4 21:44
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名 = {元素1,元素2,元素3...};

2.什么时候使用动态赋值？什么时候使用静态赋值？
如果不确定数组里的具体内容,就用动态初始化;
已经确定了具体内容,就用静态初始化
3.堆中存放的是什么？栈中存放的是什么？
堆内存:存储对象或者数组，new来创建的，都存储在堆内存。
方法栈:方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
如果访问数组元素的时候,索引编号并不存在,那么将会发生数组越界异常;
如数组被赋为null，将不会保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出"NullPointerException"空指针异常.
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是数据值
参数为引用数据类型的时候，传递的是内存地址值

作者: 吴越 时间: 2019-3-4 21:45
1.什么是数组？数组的定义有哪几种格式？
数组是能同时存储若干个数据的一个容器，数组有两种定义格式，分别是定义数组长度（动态初始化）和定义数组内容（静态初始化）。

2.什么时候使用动态赋值？什么时候使用静态赋值？
确定数组长度，但是不确定数组内容的时候使用动态赋值。
确定数组的内容时，使用静态赋值。

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

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

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

作者: 李伟艺 时间: 2019-3-4 21:46
1.什么是数组？数组的定义有哪几种格式？
数组是一种容器，将相同数据类型的值存放在一起
格式有
数据类型[] 数组名 = new 数据类型[参数个数]；
数据类型[] 数组名 = new 数据类型{元素1、元素2.。。。}；
数据类型[] 数组名 = {元素1、元素2.。。。}；

2.什么时候使用动态赋值？什么时候使用静态赋值？
不知道具体元素，只知道个数的时候用动态赋值
知道具体元素的时候，用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
堆中放的是地址值
栈中存放的是对象

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
当输入的下标大于数组的最大下表时，就会产生数组越界异常
当数组中没有任何元素时，就会产生数组空指针异常
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是传递的时值。
数为引用数据类型的时候，传递的是地址值。

作者: 开心的小孩 时间: 2019-3-4 21:48

1.什么是数组？数组的定义有哪几种格式？
   数组的概率：是一种容器，可以同时存放多个数据值
   动态初始化（指定长度）
数据类型【】数组名称=new 数据类型【数组长度】
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名 = {元素1,元素2,元素3...}
  2静态初始化（指定内容）

2.什么时候使用动态赋值？什么时候使用静态赋值？
   动态初始化指定长度

静态初始化指定内容

3.堆中存放的是什么？栈中存放的是什么？
   方是new出来的东西，都在推当中，
   存放的都是方法的局部变量，方法的运行一定在stack中
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
   1 数组索引值超出长度或数组中不存在的索引，
   arr=null
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
1. 1整数类型（byte/short/int/long）默认为0
2浮点类型（double/folat）默认为0.0
3布尔类型（boolean）默认为false

4. 引用类型（String）默认为null
5如果是字符类型，默认欸‘\u0000’;

作者: 梦翼_李宗贤 时间: 2019-3-4 21:48
1、存放数据的容器；三种
2、在数组的元素不确定的时候使用动态赋值；在确定数组的元素时用静态赋值
3、堆：凡是new出来的都在堆里，堆中的数据都有一个16进制的地址值；
栈：存放方法中的局部变量，一旦超出作用域，立刻从栈中消失；方法的运行一定要在栈当中；
4、数组下标索引超出数组的最大下标索引；数组没有new
5、参数为基本数据类型时，传递的是数据值；参数为引用数据类型时，传递的时内存地址值

作者: 李煜霖 时间: 2019-3-4 21:48
1.
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致
数组的定义格式：
(1).数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3...};
(2).数据类型[] 数组名 = new 数据类型[长度];
(3).数据类型[] 数组名 = {元素1,元素2,元素3...};
2.
当知道数组个数的时候而不知道具体元素时使用动态赋值；
当知道每个具体元素的时候使用静态赋值。
3.
堆中存放的是：对象或者数组，new来创建的。
栈中存放的是：方法，比如main方法。
4.
数组越界异常是我们访问数组中不存在的索引而产生的。
数组空指针异常是我们操作了arr = null 的数组。
5.
参数为基本数据类型的时候，传递的是数据值；
参数为引用数据类型的时候传递的是地址值。

作者: 王冠琦 时间: 2019-3-4 21:49
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

2.什么时候使用动态赋值？什么时候使用静态赋值？
数组长度，元素个数不确定时，用动态赋值
数组里面各个元素都确定时，用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
存储对象或者数组，new出来的都储存在堆内存里
栈中放的是运行的方法，比如main方法等，方法要运行要进栈，方法有后来居上的特点，后面进栈的会出现压栈的情况

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
比如一个数组只有3个元素，数组的索引就是0,1,2，没有3索引，因此我们不能访问数组中不存在的索引，如果访问了就会出现数组的越界异常
arr = null;这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此如果再访问的时候就会出现空指针异常。

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

作者: 罗加铭 时间: 2019-3-4 21:49
1.什么是数组？数组的定义有哪几种格式？
答：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致
格式：数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名 = {元素1,元素2,元素3...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：不知道数组长度的时候用动态赋值，知道数组存储长度的时候用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
答：堆存储对象或者数组，new来创建的，都存储在堆内存；栈是方法运行时使用的内存，比如main方法运行，进入方法栈中执行
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：使用超出数组索引范围的数值索引会产生越界异常；不保存数组地址会产生数组空指针异常
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：基本数据类型传递的是数值内容；引用数据类型传递的是数组内存地址

作者: 6期江岳 时间: 2019-3-4 21:50
1、数组是一种容器，可以存储多个数据类型相同的数据。有两种格式：
动态初始化：数据类型[] 数组名称=new数据类型[数组长度];
静态初始化：数据类型[] 数组名称 = new 数据类型[]{元素1,元素2...}；
2、确定数组长度时用动态，确定元素内容的用静态。
3、堆中存放的是new出来的东西，而栈是存放方法中的局部变量
4、越界是因为访问索引值不符合数组长度，空指针异常是应为，创建数组时没有new 而是赋值一个null。
5、基本数据类型是数据值，引用类型是一个地址值

作者: 魏政 时间: 2019-3-4 21:50
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

2.什么时候使用动态赋值？什么时候使用静态赋值？
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

3.堆中存放的是什么？栈中存放的是什么？
堆内存存储对象或者数组，new来创建的，都存储在堆内存中。

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常：
如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常
空指针异常：
（1）引用数据类型赋值为null；
（2）数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null，没有进行new创建，会发生空指针异常。

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

作者: 开心的小孩 时间: 2019-3-4 21:51
陈鹏涛：
1.什么是数组？数组的定义有哪几种格式？
   数组的概率：是一种容器，可以同时存放多个数据值
   动态初始化（指定长度）
数据类型【】数组名称=new 数据类型【数组长度】
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名 = {元素1,元素2,元素3...}
  2静态初始化（指定内容）

2.什么时候使用动态赋值？什么时候使用静态赋值？
   动态初始化指定长度

静态初始化指定内容

3.堆中存放的是什么？栈中存放的是什么？
   方是new出来的东西，都在推当中，
   存放的都是方法的局部变量，方法的运行一定在stack中
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
   1 数组索引值超出长度或数组中不存在的索引，
   arr=null
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
1. 1整数类型（byte/short/int/long）默认为0
2浮点类型（double/folat）默认为0.0
3布尔类型（boolean）默认为false
  数址值

4. 引用类型（String）默认为null
5如果是字符类型，默认欸‘\u0000’
内存值

作者: zhaizhile 时间: 2019-3-4 21:53

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

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

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

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

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

作者: 厦门第六期刘鹏 时间: 2019-3-4 21:54
1.什么是数组？数组的定义有哪几种格式？存储相同类型的数据动态跟静态

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

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

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

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

作者: javawjs 时间: 2019-3-4 21:54
王佳盛

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

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

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

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

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

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

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

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

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

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

作者: 李智梁 时间: 2019-3-4 21:54
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）参数为引用数据类型时，传递的是地址值。

作者: 叶彬彬 时间: 2019-3-4 21:55

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

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

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

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

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

作者: 管文祥 时间: 2019-3-4 21:56

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

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

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

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

作者: 林艺彬 时间: 2019-3-4 21:57

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

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

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

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

作者: 黄杰南 时间: 2019-3-4 21:57
1.什么是数组？数组的定义有哪几种格式？
数组：存储统一数据类型的容器
数组定义的格式：
1.数据类型[]数组名称=new 数据类型[数据长度];
2.数据类型[]数组名称=new 数据类型[]{元素1,元素2, ...};
3.数据类型[]数组名称={元素1,元素2, ...};

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

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

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

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

作者: 陈驰煜 时间: 2019-3-4 21:57
数组是一种容器，可以同时存放多个数据值；它分两种格式，分别是动态初始化和静态初始化。

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

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

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

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

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

作者: 龙舟 时间: 2019-3-4 21:58
1.什么是数组？数组的定义有哪几种格式？
定义：是一种容器，可以存放多个数据值
格式：
1.数据类型[] 数组名称 = new 数据类型[数组长度]
2.数据类型[] 数组名称 = new 数据类型[]{元素1，元素2...}
3.数据类型[] 数组名称 ={元素1，元素2...}；

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

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

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

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

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

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

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

作者: 黄成龙 时间: 2019-3-4 22:03
1.什么是数组？数组的定义有哪几种格式？
数组是能同时存储若干个数据的一个容器，数组有两种定义格式，分别是动态初始化和静态初始化。

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

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

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

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

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

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

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

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

作者: 林志鹏 时间: 2019-3-4 22:03
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）参数为引用数据类型的时候传递进去的其实是数组的地址值。

作者: 卢勇炜 时间: 2019-3-4 22:34

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

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

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

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

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

作者: 黄振明 时间: 2019-3-4 23:01
1.什么是数组？数组的定义有哪几种格式？
数组就是容器
动态初始化：
数据类型[] 数组名 = new 数据类型[元素个数]
静态初始化：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2....}
数据类型[] 数组名 ={元素1，元素2....}

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

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

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

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

作者: 黄振明 时间: 2019-3-4 23:03
1.什么是数组？数组的定义有哪几种格式？
数组就是容器
动态初始化：
数据类型[] 数组名 = new 数据类型[元素个数]
静态初始化：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2....}
数据类型[] 数组名 ={元素1，元素2....}

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

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

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

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

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

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

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

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

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

作者: 黑马林伟明 时间: 2019-3-4 23:56
、存放数据的容器；三种
2、在数组的元素不确定的时候使用动态赋值；在确定数组的元素时用静态赋值
3、堆：凡是new出来的都在堆里，堆中的数据都有一个16进制的地址值；
栈：存放方法中的局部变量，一旦超出作用域，立刻从栈中消失；方法的运行一定要在栈当中；
4、数组下标索引超出数组的最大下标索引；数组没有new
5、参数为基本数据类型时，传递的是数据值；参数为引用数据类型时，传递的时内存地址值

作者: LPY 时间: 2019-3-4 23:58

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

作者: 王旭艺 时间: 2019-3-5 00:13

1.什么是数组？数组的定义有哪几种格式？
数组概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型

要一致。
动态格式：数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[

长度]
静态格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...}

或数据类型[] 数组名 = {元素1,元素2,元素3...}

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

3.堆中存放的是什么？栈中存放的是什么？
堆中存放存储对象或者数组，new来创建的
栈中存放main方法

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是索引值超出范围而产生的编写错误；
数组空指针异常是将null赋予数组而产生的

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

递的是什么？
数组作为方法参数传递，传递的参数是数组内存的地址。

作者: 唐彬桂 时间: 2019-3-5 00:27
1.什么是数组？数组的定义有哪几种格式？
数组就是可以保存多个数值。
两种一个静态初始化，一个动态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
知道数组里的数据的时候用静态反之用动态

3.堆中存放的是什么？栈中存放的是什么？
堆中存放new出来的值，栈中存放方法的局部变量，方法运行的时候也会进入栈
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是超出了索引范围。
数组空指针是被赋值mull。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是数值；
参数为引用数据类型的时候，传递的是地址值；

作者: 庄家琦 时间: 2019-3-5 01:44
1.什么是数组？数组的定义有哪几种格式？

数组就是把同样的的量集合在一个框里.我们可以直接拿取使用这个框
目前是三种动态数组数据类型[]数组名称=new 数据类型[数组长度]
   静态数组数据类型[]数组名称=new 数据类型[]{数组织}

2.什么时候使用动态赋值？什么时候使用静态赋值？
不知道数组织有多少的时候用动态  知道用静态

3.堆中存放的是什么？栈中存放的是什么？
堆中存放数组  栈存放所有除了数组

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
读取超出了数组长度

数组内部为空

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

基本数据类型时候传递的是基本数据类型的值
引用传递的是内存值再从内存中提取引用类型的值

作者: 陈弘帅 时间: 2019-3-5 13:10

1.什么是数组？数组的定义有哪几种格式？
答：数组含义——数组是一种容器，可以同时存放多个数据值；
它分两种格式，分别是动态初始化和静态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：如果不确定数组里的具体内容，就用动态初始化；如果已经确定了具体内容，就用静态初始化。
3.堆中存放的是什么？栈中存放的是什么？
答：凡是new出来的东西，都在堆当中；栈中存放的都是方法中的局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：当访问数组的某个值的位置超过数组的最大长度，运行时就会产生越界异常；
如果赋予数组为null，将不会保存数组的内存地址，也就不允许再操作数组，因此运行的时候会抛出"NullPointerException"空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候传递返回值；参数为引用数据类型的时候传递的是内存的地址。

作者: 卢春旭 时间: 2019-3-5 14:23
1.
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

2.
数组长度，元素个数不确定时，用动态赋值
数组里面各个元素都确定时，用静态赋值

3.
存储对象或者数组，new出来的都储存在堆内存里
栈中放的是运行的方法，比如main方法等，方法要运行要进栈，方法有后来居上的特点，后面进栈的会出现压栈的情况

4.
比如一个数组只有3个元素，数组的索引就是0,1,2，没有3索引，因此我们不能访问数组中不存在的索引，如果访问了就会出现数组的越界异常
arr = null;这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此如果再访问的时候就会出现空指针异常。

5.
参数为基本数据类型的时候，传递的是数据值。
参数为引用数据类型的时候，传递的是地址值（即数组的内存地址）。

作者: 蓝建华 时间: 2019-3-5 18:17
1.什么是数组？数组的定义有哪几种格式？
答：数组就是一个容易，可以储存相同数据类型的值
      有两种，静态赋值和动态赋值

2.什么时候使用动态赋值？什么时候使用静态赋值？
答：在确定长度，不知道内容的情况下使用动态赋值
   在确认内容的情况下，使用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
答：堆中存放的是 new出来的东西
   栈中存放的方法中的变量，常量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：数组的越界异常是因为引用的索引超过了最大值
   数组的空指针异常是因为在数组没有任何数据的情况下直接运行他

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

作者: 梦翼_李宗贤 时间: 2019-3-5 21:33
1、当需要实现一个功能时，不关系具体实现步骤，而是找一个已经具有该功能的人来做
2、类是对一类事物的描述，是抽象的；对象是一类事物的实例，是具体的；类是对象的模板，对象是类的实体
3、定义位置不一样：局部变量在方法内部定义；成员变量写在类中方法外；
作用域不一样：局部变量只能在定义位置临近的大括号中使用，出了这大括号就不能使用；成员变量在整个类中都可以使用
默认值不一样：局部变量没有默认值，必须赋值才能使用；成员变量没有赋值会有一个默认值，规则和数组一样
内存的位置不一样：局部变量位于栈内存；成员变量位于堆内存
生命周期不一样：局部变量随着方法进栈诞生，随着方法出栈消失；成员变量随着对象创建诞生，随着对象被垃圾回收而消失
4、使用private关键字来修饰成员变量，对需要访问的成员变量提供对应的get/set方法；
适当的封装可以让代码更容易理解与维护，也加强了代码的安全性；
5、this代表所在类的当前对象的引用地址值，即对像自己的引用；使用this修饰方法中的变量，解决了成员变量被隐藏的问题
6、构造方法：创建对象的方法，当通过new关键字创建对象的时候，就是在调用构造方法；
一般有两种构造方法，无参构造方法和全参构造方法；
如果没有编写任何构造方法，那么编译器会默认生成一个无参无方法体的构造方法；
如果编写有至少一个构造方法，那么编译器就不会生成构造方法；
7、可以通过有参构造方法和set方法给对象中的属性赋值；如果对象中的成员变量没有用private关键字修饰，那么还可以用对象名.属性名来赋值

作者: 罗加铭 时间: 2019-3-5 21:34
1.什么是面向对象的思想？
答：面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算
机事件的设计思想
2.类和对象的关系？
答：类是对象的模板，对象是类的实体
3.成员变量和局部变量的区别？
答：定义位置不同；作用范围不同；初始值不同
4.封装在我们的程序中哪里可以体现的到？为什么要使用封装？
答：在类中可以体现；避免外界随意的对类中的属性进行修改
5.什么是this关键字？它有什么用途？
答：this代表所在类的当前对象的引用（地址值），即对象自己的引用；
用于区分成员变量和局部变量
6.什么是构造方法？有几种构造方法？类中会自带构造方法么？
答：用于创建对象；两种构造方法，空参构造和有参构造；类中会自带空参构造
7.可以通过哪两种方式给对象中的属性赋值？
答：new对象的时候传入赋值；或者使用set方法进行赋值

作者: 余建强 时间: 2019-3-5 21:34
1.什么是数组？数组的定义有哪几种格式？
一组类型相同的数据集合,有数据类型[] 数据名称=new 数据类型[]; 数据类型[] 数据名称={};和数据类型[] 数据名称=new 数据类型[]{};三种格式.

2.什么时候使用动态赋值？什么时候使用静态赋值？
当不明确知道数据的大小时使用动态赋值,当明确知道数据大小的时候用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
堆中用于存放new出来的值,栈中用于存放数据类型

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
当数据超出程序员定义的数据长度时,会出现数组越界异常,出现空指针异常是因为没有正确的赋值

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

作者: 黑马六期-董安平 时间: 2019-3-5 21:36
答：数组是一种容器，可以同时存放多个数据值
数组的特点：
1. 数组是一种引用数据类型
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在程序运行期间不可改变
数组有两种常见的格式：
动态初始化（指定长度）
静态初始化（指定内容）

2.什么时候使用动态赋值？什么时候使用静态赋值？
答；如果不确定数组当中的具体内容，使用动态初始化；
否则，已经确定了的具体内容，用静态初始化

3.堆中存放的是什么？栈中存放的是什么？
答：栈（stack）：存放方法中的局部变量。方法的运行一定要在栈当中运行。
局部变量：方法的参数，或者方法{}内部的变量
作用域：一旦超出作用于，离开从栈内存当中消失。
堆（heap）：凡是new出来的东西，都在堆当中

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

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

答;基本数据类型：变量值；
引用数据类型：地址值；

作者: 王冠琦 时间: 2019-3-5 21:36

1.什么是面向对象的思想？
Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，
使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面
向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算
机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去
操作实现。

2.类和对象的关系？
类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实体。

3.成员变量和局部变量的区别？
在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)

作用范围不一样
成员变量：类中
局部变量：方法中

初始化值的不同
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用

在内存中的位置不同
成员变量：堆内存
局部变量：栈内存

生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

4.封装在我们的程序中哪里可以体现的到？为什么要使用封装？
用private来修饰成员变量的时候
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。
封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的
方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

5.什么是this关键字？它有什么用途？
this代表所在类的当前对象的引用（地址值），即对象自己的引用。由于形参变量名与成员变量名重名，导致成员变量名被隐藏，
方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。
使用 this 修饰方法中的变量，解决成员变量被隐藏的问题

6.什么是构造方法？有几种构造方法？类中会自带构造方法么？
当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

无参构造方法
全参构造方法
getter/setter构造方法等等

无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，
一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

7.可以通过哪两种方式给对象中的属性赋值？
可以利用全参数的构造方法对对象进行赋值。
也可以利用通过类创造出来的对象，对对象中的属性进行挨个赋值。

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

作者: 沈松宏 时间: 2019-3-5 21:42
1.什么是数组？数组的定义有哪几种格式？
数组是一种可以存放多个数据的容器；
三种；静态，动态，简版静态

2.什么时候使用动态赋值？什么时候使用静态赋值？
知道长度；知道具体内容
3.堆中存放的是什么？栈中存放的是什么？
new出来的数据；方法的运行和局部变量

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引超过数组得长度；数组必须进行new初始化才能使用其中的元素，如果只赋一个null，没有进行new化，就会发生空指针异常，即忘了new；
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
变量值；地址值

作者: chenopen 时间: 2019-3-5 21:47
陈开明：
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
格式一：数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
格式二：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
格式三：数据类型[] 数组名 = {元素1,元素2,元素3...};

2.什么时候使用动态赋值？什么时候使用静态赋值？
数组内元素值不确定时候用动态赋值；确定时候用静态赋值。

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

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
访问数组中不存在的索引会发生数组越界异常。
空指针异常是数组引用到空地址，导致数组没有实际的地址，产生空指针异常。

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

作者: 徐代成 时间: 2019-3-5 21:56
1.什么是数组？数组的定义有哪几种格式？

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

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

不明确数组具体内容用动态赋值，已经明确具体内容的用静态赋值

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

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

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

当我们的索引值大于或等于我们的数组长度是会发生越界异常
当我们创建数组后没有开辟内存空间就去访问，会发生空指针异常

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

参数为基本数据类型时传递的是参数存储的值;
参数为引用数据类型时传递的是该引用存储的地址值

作者: 林奕全 时间: 2019-3-5 21:58
1.
数组是能同时存储多个数据的一个“杯子”容器。数组有两种定义格式，分别是（动态初始化）格式：数据类型[]方法名 =new 数据类型[数组长度]
和（静态初始化）格式：数据类型[]方法名 =new 数据类型[数组长度]{元素1，元素2，元素3...} 省略格式为：数据类型[]方法名={元素1，元素2，元素3...}
2.
知道具体的数组长度，但是不确定数组内容的时候使用动态赋值。
知道具体的数组内容时，使用静态赋值。
3.
堆中存放的都是new出来的东西，栈中存放的都是运行中的方法和局部变量。
4.
数组越界索引异常的产生是获取到超出内存中存在的元素范围。
数组空指针异常的产生是由于没有给数组提供一个地址值。
5.
参数为基本类型时,传递的是一个数据值；参数为引用类型时,传递的是一个地址值。

作者: 小翔vvvv 时间: 2019-3-6 18:14
叶凌青
1.什么是数组？数组的定义有哪几种格式？
数组概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型

要一致。
动态格式：数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[

长度]
静态格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...}

或数据类型[] 数组名 = {元素1,元素2,元素3...}

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

3.堆中存放的是什么？栈中存放的是什么？
堆中存放存储对象或者数组，new来创建的
栈中存放main方法

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是索引值超出范围而产生的编写错误；
数组空指针异常是将null赋予数组而产生的

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

递的是什么？
数组作为方法参数传递，传递的参数是数组内存的地址。

作者: java基础6期刘伟 时间: 2019-3-10 21:28
1.什么是数组？数组的定义有哪几种格式？
数组是Java中的一种容器，用于存储数据
动态初始化：int[] array = new int[10];

静态初始化:int[] array = new int[]{1,2,3};

静态初始化的省略格式：int[] array = {1,2,3};

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

3.堆中存放的是什么？栈中存放的是什么？
堆：所有new出来的东西都在堆中

栈：方法在栈内存中运行

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

产生：当我们访问的索引值超过数组的最大索引值

解决：修改索引值
产生：引用数据类型没有赋值，或者手动赋值为null

解决：使用对象给引用数据类型进行赋值

5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
基本数据类型作为参数传递，值不会受到影响引用数据类型作为参数传递，传递的是地址值

作者: 黑马林伟明 时间: 2019-3-10 21:31
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

2.什么时候使用动态赋值？什么时候使用静态赋值？
数组长度，元素个数不确定时，用动态赋值
数组里面各个元素都确定时，用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
存储对象或者数组，new出来的都储存在堆内存里
栈中放的是运行的方法，比如main方法等，方法要运行要进栈，方法有后来居上的特点，后面进栈的会出现压栈的情况

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
比如一个数组只有3个元素，数组的索引就是0,1,2，没有3索引，因此我们不能访问数组中不存在的索引，如果访问了就会出现数组的越界异常
arr = null;这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此如果再访问的时候就会出现空指针异常。

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

作者: 钟扬辉 时间: 2019-3-10 21:34
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

2.什么时候使用动态赋值？什么时候使用静态赋值？
数组长度，元素个数不确定时，用动态赋值
数组里面各个元素都确定时，用静态赋值

3.堆中存放的是什么？栈中存放的是什么？
存储对象或者数组，new出来的都储存在堆内存里
栈中放的是运行的方法，比如main方法等，方法要运行要进栈，方法有后来居上的特点，后面进栈的会出现压栈的情况

4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
比如一个数组只有3个元素，数组的索引就是0,1,2，没有3索引，因此我们不能访问数组中不存在的索引，如果访问了就会出现数组的越界异常
arr = null;这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此如果再访问的时候就会出现空指针异常。

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

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

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

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2