单选题在Java语言中，在程序运行时会自动检查数组的下标是否越界，如果越界，会抛掷下面的（）异常。A NullpointerExceptionB ArithmeticExceptioinC ArrayIndexOutOfBoundsExceptionD SecurityManager

题目

单选题

在Java语言中，在程序运行时会自动检查数组的下标是否越界，如果越界，会抛掷下面的（）异常。

NullpointerException

ArithmeticExceptioin

ArrayIndexOutOfBoundsException

SecurityManager

如果没有搜索结果或未解决您的问题，请直接联系老师获取答案。

相似问题和答案

第1题：

在Java语言中,在程序运行时会自动检查数组的下标是否越界,如果越界,会抛掷下面的()异常。

A.NullpointerException

B.ArithmeticExceptioin

C.ArrayIndexOutOfBoundsException

D.SecurityManager

参考答案：C

第2题：

对高级语言源程序进行编译时，可发现源程序中的(21)错误。

A．堆栈溢出

B．变量未定义

C．指针异常

D．数组元素下标越界

正确答案：B
解析：本题考查编译过程基本知识。高级语言源程序中的错误分为两类：语法错误和语义错误，其中语义错误又可分为静态语义错误和动态语义错误。语法错误指语言结构上的错误，静态语义错误指编译时就能发现的程序含义上的错误，动态语义错误只有在程序运行时才能表现出来。堆栈溢出、指针异常和数组元素下标越界都是程序运行中才能出现的问题，而遵循先声明后引用原则的程序语言必须先定义变量，然后才能使用，否则编译器会在语法分析阶段指出变量未定义错误。

第3题：

下列常见的系统定义的异常中,() 是数组下标越界异常。

A.ArithmeticException

B.IOException

C.ArrayIndexOutOfBoundsException

D.NullPointerException

参考答案：C

第4题：

以下程序执行的结果是什么？（）int[]myArray=newint[3]；try{for（inti=0；i<=myArray.length；i++）{myArray[i]=i*3；System.out.println（"myArray数组的第"+i+"个元素的值是："+myArray[i]）；}}catch（ArrayIndexOurOfBoubsExceptione）{System.out.println（"数组下标越界"）；}

A.程序执行，屏幕上显示“数组下标越界”

B.程序出现异常，屏幕上提示出现数组下标越界异常

C.程序正常执行结束，屏幕上显示数组中每个元素的值

D.程序编译出错

参考答案：A

第5题：

阅读以下程序说明和C++程序，将程序段中(1)～(5)空缺处的语句填写完整。

[说明]

C++语言本身不提供对数组下标越界的判断。为了解决这一问题，在以下[C++程序]中定义了相应的类模板，使得对于任意类型的二维数组，可以在访问数组元素的同时，对行下标和列下标进行越界判断，并给出相应的提示信息。

[C++程序]

include ＜iostream.h＞

template ＜class T＞ class Array;

template ＜Class T＞ class ArrayBody {

friend (1);

T* tpBody;

int iRows,iColumns, iCurrentRow;

ArrayBody(int IRsz, int iCsz) {

tpBody =(2);

iRows = iRsz;

iColumns = iCsz;

iCurrentRow = -1;

}

Public:

T& operator[] (int j) {

bool row_error, column_error;

row_error = column_error =false;

try {

if (iCurrentRow ＜ 0 || iCurrentRow ＞= iRows)

row_error = true;

if (j＜0 || j＞= iColumns)

column_error = true;

if (row_error == true || column_error == true)

(3);

}

catch(char){

if (row_error == true)

cerr ＜＜ "行下标越界[" ＜＜ iCurrentRow ＜＜ "]";

if (column_error = true)

cerr ＜＜ "列下标越界[" ＜＜ j ＜＜ "]";

cout ＜＜ "\n";

}

return tpBody[iCurrentRow * iColumns + j];

}

～Arraygody(){delete[]tpBody;}

};

template ＜class T＞ class Array {

ArrayBody＜T＞ tBody;

Public;

ArrayBody＜T＞ & operator[] (int i) {

(4);

return tBody;

}

Array(int iRsz, int iCsz) :(5) { }

};

void main()

{

Array＜int＞ a1(10,20);

Array＜double＞ a2(3,5);

int b1;

double b2;

b1 = a1[-5][10]; //有越界提示：行下标越界[-5]

b1 = a1[10][15]; //有越界提示：行下标越界[10]

b1 = a1[1][4]; //没有越界提示

b2 = a2[2][6]; //有越界提示：列下标越界[6]

b2 = a2[10][20]; //有越界提示：行下标越界[10]列下标越界[20]

b2 = a2[1][4]; //没有越界提示

}

正确答案：这是一道要求读者掌握类模板和友元的使用方法的程序设计题。本题的解答思路如下。模板可以实现逻辑相同、数据类型不同的程序代码的复制模板机制可以减轻编程和维护的工作量和难度。模板可以分为函数模板和类模板。类模板的一般定义形式为： template类型形参表＞class类名{类声明体} 在所有出现类模板的地方不能直接用类名表示需要加上类型形参表＞。友元是一种定义在类外部的普通函数或类但它需要在类体内进行说明。为了与该类的成员函数加以区别说明时在前面加上关键字friend。友元不是成员函数但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率但是它破坏了类的封装性和隐藏性使得非成员函数可以访问类的私有成员。友元可以是一个函数该函数被称为友元函数。友元也可以是一个类该类被称为友元类。本试题中(1)空缺处的前面是友元关键字friend但程序中没有独立的函数所以只能是另一个模板类Array即(1)空缺处所填写的内容是“class ArrayT＞”。在类模板ArrayBody的定义中声明了成员变量“T tpBody”且在析构函数中有“delete[]tpBody；”。由于在C++中delete总是和new成对出现的因此(2)空缺处应该使用new对tpBody进行初始化。通过程序中“return tpBody[iCurrentRow*iColumns+i];”语句可知该题中采用的是以一维数组来模拟二维数组的创建。在构造函数有两个参数分别为行数和列数。因此(2)空缺处所填写的内容是“new T[iRsz*iCsz]”。 (3)空缺处所在的语句前后有try{...}和catch{...}语句序列这是C++中典型的异常处理搭配语句。因为(3)空缺处所在的语句前面已进行了如下处理当有行下标越界时置row_error=true；当有列下标越界时置column_error=true。(3)空缺处前面的判断是“row_error==true||column_error==tree”即只要有行下标越界或是列下标越界就执行(3)空缺处的语句。而错误处理语句已放在catch中予以处理。catch是当正常程序段发生异常时才执行的并且程序中指明了是catch(char)所以只要在(3)空缺处抛出一个catch异常即可进行错误处理。故(3)空缺处所填写的语句是“throw'e'”其中throw之后可以填写任意的字符常数。对于Array类中的(4)、(5)空缺处所填写的内容。首先看(5)空缺处该空缺处显然是进行变量赋初值等相关的初始化工作。而Array类只有一个成员变量tBody且tBody是ArrayBody类型的ArrayBody的构造函数需要传递两个参数分别代表数组的行和列因此(5)空缺处应填入“tBody(iRsziCsz)”。通过main函数中对a1和a2的实例化就可大致了解整个程序。在main函数中实例化Array而在类 Array的构造函数对tBody这个变量进行实例化。此时就以一维数组的形式创建了二维数组。在类Array中[]运算符重载函数中返回了一个ArrayBody类而在ArrayBody也存在着[]运算符重载函数并且在ArrayBody的重载函数中对行下标和列下标同时进行了检查且返回了一个T类型。对Arrayint＞来说就是返回了int即数组的一个元素。通过对类ArrayBody的观察发现在整个ArrayBody中并没有任何地方对iCurrentRow进行赋值而在ArrayBody的[]运算符重载中却利用其对数组行下标进行判断而数组的行下标只在Array的[]运算符重载中出现那(4)空缺处就应该是对类ArrayBody 的成员变量iCurrentRow进行赋值本题的该空缺处所填入的内容是“tBody.iCurrentRow=i”。
这是一道要求读者掌握类模板和友元的使用方法的程序设计题。本题的解答思路如下。模板可以实现逻辑相同、数据类型不同的程序代码的复制，模板机制可以减轻编程和维护的工作量和难度。模板可以分为函数模板和类模板。类模板的一般定义形式为： template类型形参表＞class类名{类声明体} 在所有出现类模板的地方不能直接用类名表示，需要加上类型形参表＞。友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明。为了与该类的成员函数加以区别，说明时在前面加上关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率，但是它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。友元可以是一个函数，该函数被称为友元函数。友元也可以是一个类，该类被称为友元类。本试题中，(1)空缺处的前面是友元关键字friend，但程序中没有独立的函数，所以只能是另一个模板类Array，即(1)空缺处所填写的内容是“class ArrayT＞”。在类模板ArrayBody的定义中，声明了成员变量“T tpBody”，且在析构函数中有“delete[]tpBody；”。由于在C++中，delete总是和new成对出现的，因此(2)空缺处应该使用new对tpBody进行初始化。通过程序中“return tpBody[iCurrentRow*iColumns+i];”语句可知，该题中采用的是以一维数组来模拟二维数组的创建。在构造函数有两个参数，分别为行数和列数。因此(2)空缺处所填写的内容是“new T[iRsz*iCsz]”。 (3)空缺处所在的语句前后有try{...}和catch{...}语句序列，这是C++中典型的异常处理搭配语句。因为(3)空缺处所在的语句前面已进行了如下处理，当有行下标越界时，置row_error=true；当有列下标越界时，置column_error=true。(3)空缺处前面的判断是“row_error==true||column_error==tree”，即只要有行下标越界或是列下标越界就执行(3)空缺处的语句。而错误处理语句已放在catch中予以处理。catch是当正常程序段发生异常时才执行的，并且程序中指明了是catch(char)，所以只要在(3)空缺处抛出一个catch异常，即可进行错误处理。故(3)空缺处所填写的语句是“throw，'e'”，其中throw之后可以填写任意的字符常数。对于Array类中的(4)、(5)空缺处所填写的内容。首先看(5)空缺处，该空缺处显然是进行变量赋初值等相关的初始化工作。而Array类只有一个成员变量tBody，且tBody是ArrayBody类型的ArrayBody的构造函数需要传递两个参数，分别代表数组的行和列，因此(5)空缺处应填入“tBody(iRsz，iCsz)”。通过main函数中对a1和a2的实例化，就可大致了解整个程序。在main函数中实例化Array，而在类 Array的构造函数对tBody这个变量进行实例化。此时就以一维数组的形式创建了二维数组。在类Array中[]运算符重载函数中返回了一个ArrayBody类，而在ArrayBody也存在着[]运算符重载函数，并且在ArrayBody的重载函数中对行下标和列下标同时进行了检查，且返回了一个T类型。对Arrayint＞来说，就是返回了int，即数组的一个元素。通过对类ArrayBody的观察发现，在整个ArrayBody中并没有任何地方对iCurrentRow进行赋值，而在ArrayBody的[]运算符重载中却利用其对数组行下标进行判断，而数组的行下标只在Array的[]运算符重载中出现，那(4)空缺处就应该是对类ArrayBody 的成员变量iCurrentRow进行赋值，本题的该空缺处所填入的内容是“tBody.iCurrentRow=i”。

第6题：

●对高级语言源程序进行编译时，可发现源程序中的(8)错误。

(8)A．堆栈溢出

B．变量未定义

C．指针异常

D．数组元素下标越界

正确答案：B

第7题：

试题（21）

对高级语言源程序进行编译时，可发现源程序中的（21）错误。

（21）

A. 堆栈溢出

B. 变量未定义

C. 指针异常

D. 数组元素下标越界

正确答案：B

试题（21）分析
本题考查编译过程基本知识。
高级语言源程序中的错误分为两类：语法错误和语义错误，其中语义错误又可分为静态语义错误和动态语义错误。语法错误指语言结构上的错误，静态语义错误指编译时就能发现的程序含义上的错误，动态语义错误只有在程序运行时才能表现出来。堆栈溢出、指针异常和数组元素下标越界都是程序运行中才能出现的问题，而遵循先声明后引用原则的程序语言必须先定义变量，然后才能使用，否则编译器会在语法分析阶段指出变量未定义错误。
参考答案
(21）B

第8题：

研究下面的Java代码：publicclasstestException{publicstaticvoidmain（Stringargs[]）{inta[]={0，1，2，3，4}；intsum=0；try{for（inti=1；i<6；i++）sum=sum+a[i]；System.out.println（"sum="+sum）；}catch（ArrayIndexOutOfBoundsException）{System.out.println（"数组越界"）；}finally{System.out.println（"程序结束"）；}}}输出结果将是（）。

A.10数组越界程序结束

B.10程序结束

C.数组越界程序结束

D.程序结束

参考答案：C

第9题：

阅读下列C++程序和程序说明，将应填入(n)处的字句写在对应栏内。

【说明】

C++语言本身不提供对数组下标越界的判断。为了解决这一问题，在程序6中定义了相应的类模板，使得对厂任意类型的二维数组，可以在访问数组元素的同时，对行下标和列下标进行越界判断，并给出相应的提示信息。

include＜iostream.h＞

template ＜class T＞ class Array;

template ＜class T＞ class ArrayBody {

friend (1)

T* tpBody;

int iRows, iColumns, iCurrentRow;

ArrayBody (int iRsz, int iCsz) {

tpBody =(2)

iRows = iRsz; iColumns =iCsz; iCurrentRow =-1;

}

public:

T& operator[] (int j) {

bool row_error, column_error;

row_error=column_error=false;

try{

if (iCurrentRow ＜ 0 || iCurrentRow ＞=iRows)

row_error=true;

if (j ＜ 0 || j ＞=iColumns)

column_error=true;

if ( row_error==true || column_error == true)

(3)

}

catch (char) {

if (row_error==true)

cerr ＜＜ "行下标越界[" ＜＜ iCurrentRow ＜＜ "] ";

if (column_error== true )

cerr ＜＜ "列下标越界[" ＜＜j ＜＜ "]";

cout ＜＜ "\n";

}

return tpBody[iCurrentRow * iColumns +j];

};

～ArrayBody ( ) { delete[] tpBody; }

};

template ＜class T＞ class Array {

ArrayBody＜T＞ tBody;

public:

ArrayBody＜T＞ & operator[] (int i) {

(4)

return tBody;

}

Array (int iRsz, int iCsz) :(5) {}

};

void main()

{ Array＜int＞a1(10，20)；

Array＜double＞a2(3，5)；

int b1；

double b2；

b1=a1[-5][10]； //有越界提示：行下标越界[-5]

b1=a1[10][15]； //有越界提示：行下标越界[10]

b1=a1[1][4]； //没有越界提示

b2=a2[2][6]； //有越界提示：列下标越界[6]

b2=s2[10][20]； //有越界提示：行下标越界[10]列下标越界[20]

b2=a2[1][4]； //没有越界提示

}

正确答案：(1)class ArrayT＞ (2)new T[iRsz*iCsz] (3)throw 'e' (注：throw后可以填写任意的字符常数) (4)tBody.iCurrentRow=i (5)tBody (iRsziCsz)
(1)class ArrayT＞ (2)new T[iRsz*iCsz] (3)throw 'e' (注：throw后可以填写任意的字符常数) (4)tBody.iCurrentRow=i (5)tBody (iRsz,iCsz) 解析：(1)的前面是友元关键词friend，但在程序中，没有独立的函数，所以只能是另一个模板类Array，所以(1)应填写class ArrayT＞。
在类模板ArrayBody的定义中，声明了成员变量T tpBody，且在析构函数中有delete []tpBody，由于在C++中，delete总是和new成对出现的，所以(2)应该使用new对tpBody进行初始化。通过程序中return tpBody[iCurrentRow * iColumns+j]行，可以发现该题中采用的是以一维数组来模拟二维数组的创建。在构造函数有两个参数，分别为行数和列数．所以(2)应填写new T[iRsz * iCsz]。
(3)的前后有try{…}和catch{…}语句序列，这是C料中典型的异常处理搭配语句。由于(3)前面已作处理，当有行下标越界时，置row error=true；当有列下标越界时，置 col error=true。且(3)前面的判断是“row error==true||column error＝true”，也就是说只要有行下标越界或是列下标越界就执行(3)。错误处理语句写好放在catch中，catch是当正常程序段发生异常时才执行的，并且这里指明了是catch(char)，所以只要在(3)抛出一个char异常，即可进行错误处理。所以(3)应填：throw 'e'(这里可以是任何字符)。
再来看Array类中的两个空。首先看(5)，这显然是做一些初始化工作，给其成员变量赋初值，而Array类只有一个成员变量tBody，且tBody是ArrayBody类型的，ArrayBody的构造函数需要传递两个参数，分别代表数组的行和列。因此，(5)应填写tBody (iRsz， iCsz)。
main中实例化Array，而在类Array的构造函数对tBody这个变量进行实例化，这时就以一维数组的形式创建了二维数组。在类Array中口运算符重载函数中返回了一个ArrayBody类，而在ArrayBody也存在着[]运算符重载函数，并且在ArrayBody的重载函数中对行下标和列下标同时进行了检查，且返回了一个T类型，对Arrayint＞来说就是返回了int，也就是数组的一个元素。那么通过对类ArrayBody的观察，发现在整个 ArrayBody中并没有任何地方对iCurrentRow进行赋值，而在ArrayBody的[]运算符重载中却利用其对数组行下标进行判断，而数组的行下标只在Array的口运算符重载中出现，那么 (4)就应该是对类ArrayBody的成员变量iCurrentRow进行赋值，所以(4)应填入 tBody.iCurrentRow=i。

第10题：

阅读下列说明和C++程序，将应填入(n)处的字句写在对应栏内。

【程序1说明】

程序1中定义了数组的类模板，该模板使得对于任意类型的二维数组，可以在访问数组元素的同时，对行下标和列下标进行越界判断，并给出相应的提示信息(C++语言本身不提供对下标越界的判断)。

【程序1】

include ＜ iostream. h ＞

template ＜ class T ＞ class Array2D;

template ＜ class T ＞ class Array2DBody {

friend (1);

T * tempBody;

int iRows, iColumns, iCurrentRow;

Array2DBody(int Rows,int Cols) {

tempBody =(2);

iRows = Rows;

iColumns = Cols;

iCurrentRow = -1;

}

public:

T& operator[ ] (int j){

bool row_ error, column_ error;

row_ error = column_ error = false;

try {

if ( iCurrentRow ＜ 0｜｜iCurrentRow ＞ = iRows)

row_ error = true;

if( j ＜ 0｜｜j ＞ = iColumns)

column_error = true;

if( row_error = = true [ [ column_ error = = true)

(3);

}

catch(char) {

if (row_error = = true)

cerr ＜＜ "行下标越界"[" ＜＜ iCurrentRow ＜＜ "]";

if( colmnn_error = = true)

cerr＜＜"列下标越界[" ＜＜j＜＜"]";

cout ＜＜ "\n";

}

return tempBody[ iCurrentRow * iColumns + j ];

}

~ Array2 DBody ( ) { delete [ ] tempBody; } }; template ＜ class T ＞ class Array2D {

Array2DBody ＜ T ＞ tBody;

public:

Array2DBody ＜ T ＞ & operalor[ ] (int i) {

tBody, iCurreutRow = i;

(4);

Array2D(int Rows,int Cols): (5) {} };

void main( )

{

Array2D ＜int＞ al ( 10,20 );

Array2D ＜double＞ a2(3,5);

int bl;

double b2;

b1=a1[-5][10]；//有越界提示：行下标越界[-5]

b1=a1[10][15]；//有越界提示：行下标越界[10]

b1=a1[1][4]；//没有越界提示

b2=a2[2][6]；//有越界提示：列下标越界[6]

b2=a2[10][20]；//有越界提示：行下标越界[10]列下标越界[20]

b2=a2[1][4]；//没有越界提示

}

正确答案：(1)class Anay2D T＞
(1)class Anay2D T＞解析：此处应当是类的友元类或者友元函数，程序中只有一个模板类，即Array2DT＞。

单选题在Java语言中，在程序运行时会自动检查数组的下标是否越界，如果越界，会抛掷下面的（）异常。A NullpointerExceptionB ArithmeticExceptioinC ArrayIndexOutOfBoundsExceptionD SecurityManager

题目

相似问题和答案

更多相关问题

相关内容