黑马程序员技术交流社区
标题: 【厦门JavaEE基础5期-每日总结】 数组 [打印本页]
作者: 厦门校区 时间: 2018-12-4 20:54
标题: 【厦门JavaEE基础5期-每日总结】 数组
-今天我们学习了数组，请根据自己的理解对下列问题进行回答：
今天需要掌握的知识点有：
1.什么是数组？数组的定义有哪几种格式？
2.什么时候使用动态赋值？什么时候使用静态赋值？
3.堆中存放的是什么？栈中存放的是什么？
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
作者: 陈彬 时间: 2018-12-4 21:07
1.什么是数组？数组的定义有哪几种格式？
数组就是存储相同数据类型的集合。数组的定义有两种格式，分为动态的和静态的；
2.什么时候使用动态赋值？什么时候使用静态赋值？
当不清楚数组中的内容时，使用动态赋值，否则可使用静态赋值；
3.堆中存放的是什么？栈中存放的是什么？
堆中放方法中创建（new）出来的对象，栈中放的是函数中定义的一些基本类型的变量和对象的引用变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
当下标超过数组定义的长度时，会发生数组越界。当数组指向一个为NULL的对象时，会发生的错误
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本类型时传递的是对象所指向的数据，当对象为引用数据类型时传递的是对象在内存空间的地址
作者: 李灵杰 时间: 2018-12-4 21:16
1.什么是数组？数组的定义有哪几种格式？
数组array:存储相同类型数据的集合,有静态和动态初始化两种格式;
2.什么时候使用动态赋值？什么时候使用静态赋值？
不确定数组元素个数使用动态,指定长度;确定数组长度使用静态,指定内容;
3.堆中存放的是什么？栈中存放的是什么？
堆heap:存放创建出来的数组; 栈存放的是方法,方法运行进栈，运行完毕出栈
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
访问的索引值超过了数组的最大索引值; 数组的引用指向没有指向内存地址;
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是对象所指向的数据;
参数为引用数据类型的时候，传递的是数组的地址值;
作者: 董志超Eric 时间: 2018-12-4 21:18
1.什么是数组？数组的定义有哪几种格式？答：数组是存放数据的一种工具，定义有 动态初始化，静态初始化标准格式，静态初始化的简化格式。
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：动态赋值是在数组元素具体值得情况下进行使用，静态赋值是在已知数组元素的具体值得情况下使用。
3.堆中存放的是什么？栈中存放的是什么？
答：栈中存放的是局部变量和堆中数据的地址值。堆中存放的是new出来的数据，成员变量的具体值和成员方法的地址值。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答:数组越界异常是因为，索引编号出现问题（超出了数组元素编号）。空指针异常是以为，没有创建数组，没有new。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答: 参数是基本数据类型时，传递的是具体的数据值。 引用数据类型传递的是，数据的地址值。
作者: 许晓明 时间: 2018-12-4 21:18
本帖最后由 许晓明 于 2018-12-4 21:44 编辑
1.什么是数组？数组的定义有哪几种格式？
答：数组是用来存储数据的容器，定义有两种，一种为动态初始化（数据类型[] 数组名称=new 数据类型[数组长度]），一种为静态初始化（数据类型[] 数组名称=new 数据类型[]{ 数组元素 }）
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：当仅知道数组长度不知道数组内元素时，使用动态赋值，当知道数组内的元素时，可用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
答：堆中存放的是：用new创建的对象，栈中存放的是方法运行所需要的内存
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：在程序运行过程中数组索引值超过数组长度长生的。数组名称所指向的地址值为null（空）
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型时传递的是数据值，引用数据类型作为参数传递的是地址
作者: 赖熙蒙 时间: 2018-12-4 21:19
1.数组就是用来存储相同类型数据的区域，且在程序运行中不会改变数据长度。数组的定义包括静态初始化和动态初始化两种。
2.建议在明确数据具体内容的情况下用静态赋值，在不明确数据具体内容只明确数据个数的情况下用动态赋值。
3.堆中存放的是new出来的内容，栈中存放的是方法运行的数据类型、方法名和参数。
4.数据越界异常指的是索引值超过了数据长度。空指针异常指的是数组访问地址值时指向了没有内容的引用类型。
5.参数为基本数据类型的时候，传递的是相同数据类型的数据，参数为引用数据类型的时候，传递的是数据的地址值。
作者: lj478360767 时间: 2018-12-4 21:20
雷均
1.什么是数组？数组的定义有哪几种格式？
数组就是用来存放多个数据的容器，数组的定义有3种形式。动态定义和静态定义以及简化版
2.什么时候使用动态赋值？什么时候使用静态赋值？
知道数组内容时使用静态赋值，不知道数组内容，只知道数组长度时用动态赋值；
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的new产生的内容，栈中存放的是定义的方法名，以及堆中变量的地址值
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常时由于数组的索引值超过了数组的长度；
空指针异常时由于数组存放的地址值为空，什么也没有指向；
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
基本数据类型为参数时，传递的是具体的数值，能够直接使用，
引用类型为参数时，传递的是引用类型变量的地址值；作为返回值返回时，也是返回的地址值
作者: 赵烈刚 时间: 2018-12-4 21:20
1.什么是数组？数组的定义有哪几种格式？
数组是可以存储多个常量一个容器,动态初始化和静态初始化
2.什么时候使用动态赋值？什么时候使用静态赋值？
不知道数组内具体数据的时候用动态赋值,知道数组内具体数据的时候使用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
new出来的东西都在堆中;栈中存放的都是方法的局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组的越界异常是索引值超出了定义的数组的长度;数组内如果没有存放任何数据而被调用的话会报空指针异常
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候传递的是对象指定的数据;参数为引用数据类型的时候传递的是地址值
作者: 林裕凯 时间: 2018-12-4 21:21
1.什么是数组？数组的定义有哪几种格式？
数组就是储存数据长度固定的容器,保证多个数据的数据类型一致.
有动态初始化和静态初始化.
2.什么时候使用动态赋值？什么时候使用静态赋值？
知道数组中具体的内容时使用静态赋值,不知道时使用动态赋值
3.堆中存放的是什么？栈中存放的是什么？
堆存放的都是new出来的.栈存放的都是方法.
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
访问的索引值超过了数组的最大索引值.
数组的引用没有指向内存地址,指向了引用
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候传递的是对象所指向的数据.参数为引用数据类型的时候,传递的是地址值.
作者: 吴洪标 时间: 2018-12-4 21:21
1.什么是数组？数组的定义有哪几种格式？
答：数组是存储多个数据的容器，一个数组中的数据类型是一致的，数组的长度一旦确定则无法改变。
数组定义格式：1.数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[数组的长度];
2.数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[] {元素1, 元素2, ..., 元素n};
3.数组存储的数据类型[] 数组名称 = {元素1, 元素2, ..., 元素n};
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：当要存入数组的所有元素已知时使用静态赋值，否则使用动态赋值。
3.堆中存放的是什么？栈中存放的是什么？
答：堆中存放的是对象或者数组，凡是用了关键字new来创建的都放在堆中；
栈中存放的是变量名称，是方法运行时使用的内存。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：数组越界异常是指当数组的索引值范围超过或等于数组的长度时抛出的异常，此时要将该索引值改回可用范围内；
数组空指针异常是指没有给建立的某个数组变量赋值，导致这个数组变量不能指向某个数组，解决方式是给这个数组变量赋值，或者删除这个数组变量。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候，传递的是数据本身；参数为引用数据类型的时候，传递的是引用对象的地址哈希值。
作者: 洪烁铭 时间: 2018-12-4 21:25
提示: 该帖被管理员或版主屏蔽
作者: 周章强 时间: 2018-12-4 21:26
1.数组是一种引用型数据类型，是用来存储多个数据的集合。
有动态和静态两种，其中静态分为标准格式和省略格式。
2.动态赋值：长度确定，元素不确定时；
静态赋值：元素确定时。
3.堆：new后面的数据都是堆的内容。
栈：变量和方法运行的空间。
4越界异常：索引值超过数组长度
空指针异常：数组没有对应的地址值。
5.参数为基本数据时是 ： 值；
参数为引用数据类型时是：地址值。
作者: 吴少华 时间: 2018-12-4 21:26
1.数组就是装数据的容器，数据的定义2种格式，动态初始化和静态初始化。
2.当知道数组的长度不知道内容时用动态赋值，已知数组内容用静态赋值。
3.堆中存放的是new出来的新对象，栈中存放的是基本类型的数据和数组等引用类型的地址值
4.数据异常就是数据超出了原本循环界定的方位，数组空指针是因为数组所对应的地址值没有所对应的堆内创建的对象。
5参数为基本数据类型的时候，传递的是数据值.参数为引用数据类型的时候，传递的是地址值.
作者: 刘荣城 时间: 2018-12-4 21:32
1.什么是数组？数组的定义有哪几种格式？
数组是可以存放多个，同数据类型的数值，数组有三种格式，
1.数据类型[] 数组名称 = new 数据类型{元素1，元素2.。。。};
2.数据类型[] 数组名称 = new 数据类型【索引值】；
3.数据类型[] 数组名称；
数组名称 = new 数据类型【索引值】；
2.什么时候使用动态赋值？什么时候使用静态赋值？
不知道数组【索引值】的时候用动态赋值，知道数组【索引值】的时候用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放：常量池，static的变量，new出来的对象。
栈中存放：方法中布局变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
当程序编译超过数组【索引值】范围，就会数组越界。
数组已经定义，但没给数组指向数据的时候。就会发生空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
？？？？？？？？
作者: 洪烁铭 时间: 2018-12-4 21:35
本帖最后由 洪烁铭 于 2018-12-4 21:43 编辑
1.数组是用来接收同一数据类型的容器。
特点：程序一旦运行，长度不可改变；储存的数据类型必须统一；数组是引用数据类型。
格式：静态初始化分为两种 1、标准格式： 数据类型[] 数组名称= new 数据类型[] {元素1，元素2，···} 2.省略格式：数据类型[] 数组名称={元素1，元素2，···} 还有动态初始化 格式为： 数据类型[] 数组名称= new 数据类型[数组长度]
2.当不确定数组内容时，就要动态赋值。相反，使用静态赋值。
3.堆当中储存的是new出来的。 栈中执行方法和储存局部变量。
4.当使用的索引值编号超过数所拥有的的索引值。
当变量不再保存地址值时，则数组空指针异常。现在遇到的情况是把null赋值给数组。
5.参数作为基本数据类型时，传递的是值；作为引用数据类型时，传递的是地址值。
作者: 李群英 时间: 2018-12-4 21:37
1.什么是数组？数组的定义有哪几种格式？
数组是储存多个数据的容器，数组长度在程序运行期间固定不变，且数据类型一致。有两种格式：动态初始化；静态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
不知道数组内容，只知道数组长度时用动态赋值；知道数组内容时使用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放数组；栈中存放方法运行。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常索引编号不存在时产生的。数组空指针异常是忘了new造成的。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是数据值。
参数为引用数据类型的时候，传递的是什么地址值。
作者: 李嘉福 时间: 2018-12-4 21:37
1.什么是数组？数组的定义有哪几种格式？数组:是一种容器,可以同时存放多个数据值;
定义格式:动态初始化,静态初始化.
2.什么时候使用动态赋值？什么时候使用静态赋值？
动态赋值:不确定元素具体内容,指定长度的时候;
静态赋值:确定指定内容的时候.
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是凡是new出来的都在堆当中,都有一个地址值;
栈中存放的是方法中的局部变量.
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界:访问数组元素的时候,索引编号并不存在,就会发生数组越界异常;
数组空指针异常:没有给建立的某个数组变量赋值，导致这个数组变量不能指向某个数组.
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
基本数据类型为参数时，传递的是具体的数值，能够直接使用;
引用类型为参数时，传递的是引用类型变量的地址值；作为返回值返回时，也是返回的地址值
作者: 陈益源 时间: 2018-12-4 21:41
本帖最后由 陈益源 于 2018-12-4 21:43 编辑
1.什么是数组？数组的定义有哪几种格式？
数组是一种容器，存储同一种数据类型、固定长度的多个数据
格式：动态，数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
静态，数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[] {元素1，元素2...}
2.什么时候使用动态赋值？什么时候使用静态赋值？
已知数组长度使用动态赋值；
已知数组元素使用静态赋值；
3.堆中存放的是什么？栈中存放的是什么？
堆中存放new新创建的数组；
栈中存放main方法运行、数组的地址值、局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常：索引值超过数组长度
数组空指针：数组存放的地址值为空，无法在堆中找到对应的数组
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值
作者: 黄海兵 时间: 2018-12-4 21:42
1：存储数据的容器，2种 静态和动态
2：知道数组长度用动态 知道数组内元素用静态。
3：堆种存放的是new出来的数据，栈中存放的是局部变量。
4：索引值超过数组的长度，数组的引用没有指向内存地址
5：具体的数据值，地址值。
作者: ab8846254 时间: 2018-12-4 21:45
1.什么是数组？数组的定义有哪几种格式？
答：数组从字面意思上理解是一种数据的组合，是一种容器，我们可以用来盛放我们的数据， 数组的定义有 int[]数组名 = new int[元素个数]；这种定义方式叫做动态定义，还有种静态定义为，int[]数组名称={元素值}；
数组定义可以先指定长度， int[]数组名 = new int[元素个数]；但是此种只要一指定就不能更改长度，也可以先不指定长度我们直接写元素值由系统自动算出数组的长度，格 式为：int[]数组名称={元素值}； 其中[]放在数组名称前和后无影响，但是按照习惯都是在数组名称之前。
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：动态赋值为我们不知道要赋什么值，但是知道有多少个数据的情况，静态赋值为不知道具体元素的个数的时候使用由系统自动算出长度。
3.堆中存放的是什么？栈中存放的是什么？
答：栈中放的我们的数据类型和变量名，堆中放的我们new出来的地址值，之后把堆中的地址值赋值给栈里面的变量，栈中的变量就可以值向堆中的数据。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：数组的索引是从0-数组.length-1；数组越界异常为我们访问了不存在的索引，空指针异常为，数组在内存中栈中指向堆中的地址值断掉了就无法访问了，堆中的数据将会被java虚拟机当做垃圾回收。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候传递的是变量本身的值，参数为引用数据类型的时候传递的是 地址值。
梁超
作者: Java中的莫Q哇啦 时间: 2018-12-4 21:48
1.数组就是一个组合，八几个相同数据类型的数据组合在同一个盒子里面，成为一组数组。2.数组的定义有两种格式：①动态数组格式：数据类型1 [] 数组名称 = new 数据类型1 [数组长度]； ②静态数组格式：数据类型1 [] 数组名称 = new 数据类型1 []{数据1，数据2，...}，其中可省略写为：数据类型1 [] 数组名称 = {数据1，数据2，...}。
3.内存堆中存放的是都是编程定义了new的东西。内存栈中存放的是编程用到的方法，不过有个前提是main方法要先进栈，其他调用的方法才能进栈。
4.数组越界异常是已知这个数组的长度为x，而你却想要这个数组给你个长度为x+1的值，这个时候就会出现越界异常。数组空指针异常是你定义了一个数组，让这个数组等于null：比如String[] str = null，这个数组没法在内存堆中找到自己的位置，你要打印这个数组的地址值时，就会出现空指针异常。
5.1.数组就是一个组合，八几个相同数据类型的数据组合在同一个盒子里面，成为一组数组。2.数组的定义有两种格式：①动态数组格式：数据类型1 [] 数组名称 = new 数据类型1 [数组长度]； ②静态数组格式：数据类型1 [] 数组名称 = new 数据类型1 []{数据1，数据2，...}，其中可省略写为：数据类型1 [] 数组名称 = {数据1，数据2，...}。
3.内存堆中存放的是都是编程定义了new的东西。内存栈中存放的是编程用到的方法，不过有个前提是main方法要先进栈，其他调用的方法才能进栈。
4.数组越界异常是已知这个数组的长度为x，而你却想要这个数组给你个长度为x+1的值，这个时候就会出现越界异常。数组空指针异常是你定义了一个数组，让这个数组等于null：比如String[] str = null，这个数组没法在内存堆中找到自己的位置，你要打印这个数组的地址值时，就会出现空指针异常。
5.参数为基本数据类型的时候，传递的是数据本身。参数为引用数据类型的时候，传递的是堆中的 地址值。
_______________________________________________________________________________________________成成
作者: 杨馥榕 时间: 2018-12-4 21:49
1.什么是数组？数组的定义有哪几种格式？
答：数组我们假拟一个容器，容器里装着数值；
两种格式：1.一个是动态格式
2.一个是静态格式。
2.什么时候使用动态赋值？什么时候使用静态赋值？
答：有数值，但不确定长度用静态；确定元素的长度则用动态。
3.堆中存放的是什么？栈中存放的是什么？
答：堆中存放索引值和内存地址；
栈中存放寄存器里的main的方法和数组；
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
答：在已经固定好的数组中，超出索引值数，我们叫做数组越界异常；
没有内存地址，却运用了引用，叫做空指针；
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
答：参数为基本数据类型的时候，传递的是数据本身，
参数为引用数据类型的时候，传递的是引用对象的地址哈希值。
作者: Java中的莫Q哇啦 时间: 2018-12-4 21:50
1.数组就是一个组合，八几个相同数据类型的数据组合在同一个盒子里面，成为一组数组。2.数组的定义有两种格式：①动态数组格式：数据类型1 [] 数组名称 = new 数据类型1 [数组长度]； ②静态数组格式：数据类型1 [] 数组名称 = new 数据类型1 []{数据1，数据2，...}，其中可省略写为：数据类型1 [] 数组名称 = {数据1，数据2，...}。
3.内存堆中存放的是都是编程定义了new的东西。内存栈中存放的是编程用到的方法，不过有个前提是main方法要先进栈，其他调用的方法才能进栈。
4.数组越界异常是已知这个数组的长度为x，而你却想要这个数组给你个长度为x+1的值，这个时候就会出现越界异常。数组空指针异常是你定义了一个数组，让这个数组等于null：比如String[] str = null，这个数组没法在内存堆中找到自己的位置，你要打印这个数组的地址值时，就会出现空指针异常。
5.参数为基本数据类型的时候，传递的是数据本身。参数为引用数据类型的时候，传递的是堆中的 地址值。
——————————————————————————————————成成
作者: 黄毅 时间: 2018-12-4 21:51
1.什么是数组？数组的定义有哪几种格式？
数组时用来存储同类型数据元素，
格式：数据类型[] 数组名 = new 数据类型[]{元素};
2.什么时候使用动态赋值？什么时候使用静态赋值？
存放指定内容时用静态赋值；直到长度不知道存放内容时用动态赋值
3.堆中存放的是什么？栈中存放的是什么？
new出来的东西放在堆中；栈中存放方法
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引值超过了数组最大索引值；数组没有引用地址值。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
基本数据类型传值；引用数据类型传地址值
作者: 杨鑫棋 时间: 2018-12-4 21:55
1.什么是数组？数组的定义有哪几种格式？
数组就是用来存放相同数据类型的集合，数组的定义格式分为动态初始化和静态初始化两种。
2.什么时候使用动态赋值？什么时候使用静态赋值？
不知道数组内容的时候使用动态赋值，知道内容的用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是new出来的数据。栈是方法运行时使用的内存。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常就是访问了超过索引值的内容，即不存在的内容。空指针异常值数组的地址值为空，无法操作数组。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
数据值，地址值。
作者: Chidori 时间: 2018-12-4 21:57
今天需要掌握的知识点有：
1.什么是数组？数组的定义有哪几种格式？
答：数组就是存储数据长度的容器。定义格式：1.数组存储的数据类型[] 数组名字=new 数组存储的数据类型[长度]；
2.数据类型[] 数组名=new 数据类型[]{元素1，元素2，...};
3数据类型[] 数组名={元素1，元素2，...};
2.什么时候使用动态赋值？什么时候使用静态赋值？
给出具体元素的使用用静态赋值，只知道元素长度的情况下用动态赋值。
3.堆中存放的是什么？栈中存放的是什么？
凡是new出来的，都在堆中，栈中存放的是运行时使用的内存，比如main方法。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界指的是索引值超出了数组所储存的元素长度。
空指针异常指的是数组访问地址值时指向了没有内容的引用类型。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本类型的时候传递的是具体的数值，参数为引用类型时，传递的是地址值
作者: zhuyiming 时间: 2018-12-4 23:06
1.什么是数组？数组的定义有哪几种格式？
数组就是存储一堆一样数据类型的盒子。
三种格式。动态初始化，静态初始化，和两个初始化的省略版本
静态初始化的省略版本不能分为两个步骤， 动态却可以分为两个步骤
2.什么时候使用动态赋值？什么时候使用静态赋值？
当不知道数组的内容是使用动态初始化，
当知道 数组的内容时推荐使用静态初始化
3.堆中存放的是什么？栈中存放的是什么？
堆中存放new出来的东西
栈中存放的是方法中的局部变量，
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
索引时超出了内容的元素时就发生了，，数组越界异常
数组空指针是指给数组赋值了，null 所以，数组不能储存数组的内存地址
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
基本类型传递的是数据值
引用类型传递的是内存地址
作者: 苏阿合 时间: 2018-12-4 23:33
1.什么是数组？数组的定义有哪几种格式？
数组是用来存储统一类型的数据的容器。数组定义有三种格式，动态初始化：数据类型[ ] 数组名 = new 数据类型[数组长度]、
标准式静态初始化数据类型:[ ] 数组名 = new 数据类型[]{元素1，元素2....)和省略式静态初始化:数据类型[ ] 数组名 ={元素1，元素2....}。
2.什么时候使用动态赋值？什么时候使用静态赋值？
如果是只给定数组长度，没有给定数组的具体内容时用动态赋值。
如果是给具体内容时，使用静态赋值比较方便，
3.堆中存放的是什么？栈中存放的是什么？
堆内存中存放的new出来的数组或对象和成员变量，栈中存放时局部方法和局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
使用数组索引超过创建的数组长度就会产生数组越界异常；当定义的数组或对象为空，数组索引指向了没有对应的数组的索引的数值，就会造成空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候传递是对应数据值，参数为引用数据类型的时候传递的是对应的引用类型的地址值。
作者: 黄嘉宏 时间: 2018-12-5 00:17
1.什么是数组？数组的定义有哪几种格式？
数组就是存储数据长度固定的容器。动态初始化和静态初始化。
2.什么时候使用动态赋值？什么时候使用静态赋值？
不清楚数据时用动态赋值，知道数据时用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放存储对象或者数。栈中存放的是方法。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是访问数组中不存在的索引。数组空指针异常，变量赋值为空值，不允许再操作数组。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是指向的数据。
数组作为方法参数传递，传递的参数是数组内存的地址
作者: 李柏刚 时间: 2018-12-5 00:17
1.什么是数组？数组的定义有哪几种格式？
数组：就是保存一串引用数据类型或基本数据类型的的一个盒子，也可以为空。并且长度固定，数据类型固定。
定义的格式：动态数组，静态数组。
2.什么时候使用动态赋值？什么时候使用静态赋值？
数组元素不确定的情况下，使用动态赋值。指定长度。
数组元素确定的情况下，使用静态赋值。指定元素，当然也包括了长度。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是数组中每个索引对应的元素值。
栈中存放着创建的数组容器名称，有对应的地址值。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常：调取索引对应的元素，超出了数组索引的最大值。
数组空指针异常：数值无内容。还继续调用。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型：传递的是基本数据类型。
参数为引用数据类型：传递的是引用数据类型。
作者: 续扬 时间: 2018-12-5 01:14
1.什么是数组？数组的定义有哪几种格式？
是一种容器可以存放多个数值
有静态和动态两种格式
数据类型[] 数据名 =new 数据类型 []{元素1，元素2...}
数据类型[] 数据名 =new 数据类型 [数据长度]
2.什么时候使用动态赋值？什么时候使用静态赋值
不知道数组元素时使用动态赋值。
明确数组元素用静态赋值
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的时new出来的地址值
栈中存放的是方法的运行
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常是因为超过了数组的索引值
空指针是因为数组内没有地址值而被虚拟机回收
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么
基本的时候传递的是数值本身。
引用的时候传递的是地址值。
作者: 陈基林 时间: 2018-12-5 13:01
1.什么是数组？数组的定义有哪几种格式？
2.什么时候使用动态赋值？什么时候使用静态赋值？
3.堆中存放的是什么？栈中存放的是什么？
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
作者: 陈基林 时间: 2018-12-5 13:17
1.什么是数组？数组的定义有哪几种格式？
数组就是很多数据的集合，定有的格式有三种，动态方式，静态方式以及静态的省略模式。
2.什么时候使用动态赋值？什么时候使用静态赋值？知道数组长度但是不知道数组内容的时候使用动态赋值；知道数组内的具体内容时用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
程序中new出来的对象存放在堆中，栈中存放的是方法中的局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
利用索引值访问数组当索引值超出数组本身的长度时，这时候没有数据能给访问就会报错，即数组越界异常。访问被赋值为null的数组时会发生空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
作为基本数据类型的时候传递的是数据结果，作为引用数据类型的时候传递的也是地址值。
作者: 林文悦 时间: 2018-12-5 13:47
1.什么是数组？数组的定义有哪几种格式？
数组是存储多个数据的容器，一个数组中的数据类型是一致的，数组的长度一旦确定则无法改变。
数组定义格式：1.数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[数组的长度];
2.数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[] {元素1, 元素2, ..., 元素n};
3.数组存储的数据类型[] 数组名称 = {元素1, 元素2, ..., 元素n};
2.什么时候使用动态赋值？什么时候使用静态赋值？
当数组要存入的内容时已知确定时用静态赋值，否则用动态。
3.堆中存放的是什么？栈中存放的是什么？
new出来的对象或者数组。
栈中存放的是变量名称，是方法运行时使用的内存。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
数组越界异常是指当数组的索引值范围超过或等于数组的长度时抛出的异常；
数组空指针异常是指没有给建立的某个数组变量赋值，导致这个数组变量不能指向某个数组
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是数组本身的数据值。参数为引用数据类型的时候，传递的是地址哈希值
作者: 苏阿合 时间: 2018-12-5 15:32
1.什么是数组？数组的定义有哪几种格式？
数组是用来存储统一类型的数据的容器，数组定义有三种格式，动态初始化：数据类型[] 数组名 = new 数据类型[数组长度]、
标准式静态初始化数据类型:[] 数组名 = new 数据类型[]{元素1，元素2....)和省略式静态初始化:数据类型[] 数组名 ={元素1，元素2....}
2.什么时候使用动态赋值？什么时候使用静态赋值？
如果是只给定数组长度，没有给定具体数组的内容时用动态赋值。
如果是给具体内容时，使用静态赋值比较方便，
3.堆中存放的是什么？栈中存放的是什么？
堆内存中存放的new出来的数组或对象和成员变量，栈中存放时局部方法和局部变量
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
使用数组索引超过创建的数组长度就会产生数组越界异常；当定义的数组或对象为空，数组索引指向了没有对应的数组的索引的数值，就会造成空指针异常。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候传递是对应数据值，参数为引用数据类型的时候传递的是对应引用类型的地址值。
作者: 苏志祥 时间: 2018-12-5 16:24
本帖最后由 苏志祥 于 2018-12-5 16:25 编辑
1.什么是数组？数组的定义有哪几种格式？
数组是存放同一种数据类型的容器。
两种定义格式：动态和静态，静态又细分出一种简写格式。
动态格式：数据类型[] 数组名称 = new 数据类型[数组长度]；
静态格式：数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，。。。}；
静态的简写格式：数据类型[] 数组名称 = {元素1，元素2，。。。}；
2.什么时候使用动态赋值？什么时候使用静态赋值？
当不确定数组内容时，使用动态赋值；反之，使用静态赋值。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放的是对象或者实体。栈中存放的是局部变量，包括方法中的局部变量。
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常：数组的索引值超过了相应数组的角标值。
空指针异常：数组被赋值为null时发生。
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什么？
参数为基本数据类型的时候，传递的是相对应的实际参数。
参数为引用数据类型的时候，传递的是相对应引用数据的地址值
作者: 陈佳鹏 时间: 2018-12-5 18:26
1.数组就是存储固定长度的相同数据类型的容器。数组有静态初始化和动态初始化两种格式。
2.只知道数组长度的时候使用动态赋值，知道数组中具体元素时使用静态初始化。
3.堆中存放new创建出来的东西，栈中存放方法，方法要执行就要进栈。
4.越界异常：执行程序时使用数组是，程序中的数组索引值超过了数组的长度-1，就会产生越界异常。数组名称指向的是地址是null时会产生空指针异常。
5.参数是基本数据类型型传递的是参数的值，为引用数据类型时传递的是地址值。
作者: 王宏 时间: 2018-12-5 21:05
1.什么是数组？数组的定义有哪几种格式？
数组就是保存很多数据的一个容器，数组的定义有两种，一种是动态定义，和静态定义
2.什么时候使用动态赋值？什么时候使用静态赋值？
动态赋值是在知道数组长度时候定义的，静态赋值是知道具体有哪些元素，可以写在方括号中的。
3.堆中存放的是什么？栈中存放的是什么？
堆中存放new出来的东西，栈中存放数据类型和变量名
4.数组越界异常是怎么产生的？数组空指针异常是怎么产生的？
越界异常是索引值超过数组长度，数组空指针是数组存放的地址值为空，无法在堆中找到对应的数组
5.参数为基本数据类型的时候，传递的是什么？参数为引用数据类型的时候，传递的是什
当参数为基本数据类型时传变量本身的值，当参数为引用数据类型时，传参数的地址
作者: 赵烈刚 时间: 2018-12-21 14:15
好的,亲
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |