转载

【计算机二级Java语言】卷004

选择题

公共知识

【1】下列数据结构中, 属于非线性结构的是()。

〖A〗循环队列

〖B〗带链队列

〖C〗二叉树

〖D〗带链栈

树是简单的非线性结构, 所以二叉树作为树的一种也是一种非线性结构。

【2】下列数据结构中, 能够按照“先进后出”原则存取数据的是()。

〖A〗循环队列

〖B〗栈

〖C〗队列

〖D〗二叉树

栈是按先进后出的原则组织数据的; 队列按先进先出的原则组织数据。

【3】对于循环队列, 下列叙述中正确的是()。

〖A〗队头指针是固定不变的

〖B〗队头指针一定大于队尾指针

〖C〗队头指针一定小于队尾指针

〖D〗队头指针可以大于队尾指针, 也可以小于队尾指针

循环队列的队头指针与队尾指针都不是固定的, 随着入队与出队操作要进行变化。因为是循环利用的队列结构, 所以对头指针有时可能大于队尾指针有时也可能小于队尾指针。

【4】算法的空间复杂度是指()。

〖A〗算法在执行过程中所需要的计算机存储空间

〖B〗算法所处理的数据量

〖C〗算法程序中的语句或指令条数

〖D〗算法在执行过程中所需要的临时工作单元数

算法的空间复杂度是指算法在执行过程中所需要的内存空间。所以选择A。

【5】软件设计中划分模块的一个准则是()。

〖A〗低内聚低耦合

〖B〗高内聚低耦合

〖C〗低内聚高耦合

〖D〗高内聚高耦合

一般较优秀的软件设计, 应尽量做到高内聚, 低耦合, 即减弱模块之间的耦合性和提高模块内的内聚性, 有利于提高模块的独立性。

【6】下列选项中不属于结构化程序设计原则的是()。

〖A〗可封装

〖B〗自顶向下

〖C〗模块化

〖D〗逐步求精

结构化程序设计的思想包括: 自顶向下、逐步求精、模块化、限制使用goto语句, 所以选择A。

【7】软件详细设计生产的图如下:

该图是()。

〖A〗 N - S图

〖B〗 PAD图

〖C〗程序流程图

〖D〗 E - R图

N - S图提出了用方框图来代替传统的程序流程图, 所以A不对。PAD图是问题分析图, 它是继承程序流程图和方框图之后提出的又一种主要用于描述软件详细设计的图形表示工具, 所以B不对。E - R图是数据库中的用于表示E - R模型的图示工具, 所以D不对。根据图中所示表示方法是进行软件详细设计时使用的程序流程图。

【8】数据库管理系统是()。

〖A〗操作系统的一部分

〖B〗在操作系统支持下的系统软件

〖C〗一种编译系统

〖D〗一种操作系统

数据库管理系统是数据库的机构, 它是一种系统软件, 负责数据库中数据组织、数据操纵、数据维护、控制及保护和数据服务等。是一种在操作系统之上的系统软件。

【9】在E - R图中, 用来表示实体联系的图形是()。

〖A〗椭圆形

〖B〗矩形

〖C〗菱形

〖D〗三角形

在E - R图中实体集用矩形表示, 属性用椭圆表示, 联系用菱形表示。

【10】定义学生的关系模式如下:

S(S#, Sn, Sex, Age, D#, Da)(其属性分别为学号、姓名、性别、年龄、所属学院、院长)

该关系的范式最高是()。

〖A〗 1NF

〖B〗 2NF

〖C〗 3NF

〖D〗 BCNF

关系数据库中的关系是要满足一定要求的, 满足不同程度要求的为不同的范式。满足最低要求的叫第一范式, 简称1NF。在满足第一范式的基础上, 进一步满足更多要求规范则是第二范式。然后在满足第二范式的基础上, 还可以再满足第三范式, 以此类推。对于关系模式, 若其中的每个属性都已不能再分为简单项, 则它属于第一范式。若某个关系R为第一范式, 并且R中每一个非主属性完全依赖于R的某个候选键, 则称其为第二范式。第二范式消除了非主属性对主键的部分依赖。如果关系R是第二范式, 并且每个非主属性都不传递依赖于R的候选键, 则称R为第三范式。(传递依赖: 在关系模式中, 如果Y→X, X→A, 且X不决定Y和A不属于X, 那么Y→A是传递依赖。)本题中, 关系S满足第一范式和第二范式, 但是S#→D#, D#→Da, 存在传递依赖, 因此不满足第三范式。该关系的范式最高是2NF。

专业知识

【11】 Java程序的并发机制是

〖A〗多线程

〖B〗多接口

〖C〗多平台

〖D〗多态性

多线程是Java程序的并发机制, 它能同步共享数据、处理不同的事件。本题答案为A选项。

【12】下列变量名的定义中, 符合Java命名约定的是

〖A〗 fieldName

〖B〗 _num

〖C〗 Intnum

〖D〗 $number

变量名以字母、下划线或者美元符$开头, 不能以数字开头, 后面跟字母、下划线、美元符、数字, 变量名对大小写敏感。Java命名约定的是按照驼峰式写法, 除第一个单词外, 其余每个单词首字母大写。本题答案为A选项。

【13】 Java中定义常量的关键字是

〖A〗 const

〖B〗 final

〖C〗 finally

〖D〗 native

final关键字是定义常量变量的保留字, 说明该变量赋值以后永不改变, 变量初值是该变量的默认值。本题答案为B选项。

【14】下列选项中, 类型为int的表达式是

〖A〗 "abc" + "efg"

〖B〗 "abc" + 'efg'

〖C〗 'a' + 'b'

〖D〗 3 + '45'

选项A、B中的“+”是字符串拼接操作。选项D中’45’不能表示字符, 字符中只能有一个字符; 选项C是两个字符相加, 也就是两个字符对应的ASCII码值相加, 结果为int型。本题答案为C选项。

【15】下列程序的运行结果是

public class Test {
    public static void main(String[] args) {
        int i = 0;
        System.out.println(i == 1 ? 2 : 3);
    }
}

〖A〗 0

〖B〗 1

〖C〗 2

〖D〗 3

本题考查条件表达式。条件表达式为: 布尔表达式 ? 值1: 值2; 当布尔表达式为true时, 表达式的结果为值1, 布尔表达式为false时, 条件表达式的值为值2; 本题布尔表达式为false, 结果为3。本题答案为D选项。

【16】下列程序的运行结果是

public class Test {
    public static void main(String[] args) {
        int i = 6, j = 5;
        boolean w = i % 4 > j;
        System.out.println(w);
    }
}

〖A〗 0

〖B〗 1

〖C〗 true

〖D〗 false

求余运算符“%”, “6 % 4”结果为2, “2 > j”的值为false。w的值为false。本题答案为D选项。

【17】下列程序的运行结果是

public class Test {
    public static void main(String[] args) {
        int a = 2, b = 3, c = 5;
        System.out.println(a ++ * b + --c);
    }
}

〖A〗 10

〖B〗 11

〖C〗 12

〖D〗 13

本题考查算术运算符的应用。后置“++”表示先参与运算再自身 + 1; 前置“--”表示先自身 - 1再参与运算。“a ++ * b + --c = 2 * 3 + 4 = 10”, 程序输出打印10。本题答案为A选项。

【18】下列程序的运行结果是

public class Test {
    public static void main(String[] args) {
        int x = 5;
        change(x);
        System.out.print("  " + x);
    }
    static void change(int x) {
        x = x * 10;
        System.out.print("  " + x);
    }
}

〖A〗 50 50

〖B〗 50 5

〖C〗 5 50

〖D〗 5 5

main函数中调用了change()方法, 在change()方法中形参x的值为10并打印输出。因为形参x是局部变量, 方法执行后释放变量。接着执行main()方法中的打印输出语句, 此时输出main()方法中的局部变量x, 它的值为5。本题答案为B选项。

【19】下列程序的运行结果是

public class Test {
    public static void main(String[] args) {
        int n = 65;
        n = n / 10;
        switch (n) {
            case 6:
            System.out.print("C");
            case 5:
            System.out.print("D");
        }
    }
}

〖A〗 C

〖B〗 D

〖C〗 CD

〖D〗 DC

运算符“/”两边的运算对象都是整型时, 运算的结果为整型, 则“n / 10”的结果为6。匹配case值输出C, case中如果没有break关键字, 会进行渗透操作, 一直执行下去, 直到结束。程序输出“CD”。本题答案为C选项。

【20】下列程序的运行结果是

public class Test {
    public static void main(String[] args) {
        int s = 0;
        for (int i = 1; i <= 10; i++)
        for (int j = 1; j <= 5 ; j++) {
            if (j % 3 == 0)
            break ;
            s = s + j;
        }
        System.out.println(s);
    }
}

〖A〗 10

〖B〗 15

〖C〗 30

〖D〗 150

本题考查for循环嵌套的应用, 运算符“%”位取余操作。内循环中, j = 3时, if条件满足执行break语句, 跳出内循环, 执行“s = s + j”。外循环一个共执行10次, 也就是累加3, 累计加了10次, 所以程序最终输出30。本题答案为C选项。

【21】下列程序的运行结果是

public class Person {
    static int[] arr = new int[10];
    public static void main(String[] args) {
        System.out.println(arr[9]);
    }
}

〖A〗编译时将产生错误

〖B〗编译时正确, 运行时将产生错误

〖C〗输出0

〖D〗输出空

数组没有进行初始化操作时, 元素按默认值存储。整数类型默认值为0, 浮点类型默认值为0.0, 引用类型默认值为null, 字符类型默认值为/u0000。本题的数组类型为int类型, 默认值为0。本题答案为C选项。

【22】 Object类中的方法 public int hashCode(), 在其子类中覆盖该方法时, 其方法修饰符可以是

〖A〗 protected

〖B〗 public

〖C〗 private

〖D〗 default

子类覆写父类的方法时, 重写方法不能比被重写方法有更严格的访问级别。父类的修饰符为public, 子类重写此方法时, 修饰符也为public。本题答案为B选项。

【23】 Java程序默认引用的包是

〖A〗 java.text

〖B〗 java.awt

〖C〗 java.lang

〖D〗 java.util

java.lang包提供Java编程语言进行程序设计的基础类。java. lang包是编译器自动导入的。本题答案为C选项。

【24】下列叙述中, 错误的是

〖A〗内部类的名称与定义它的类的名称可以相同

〖B〗内部类可用abstract修饰

〖C〗内部类可作为其他类的成员

〖D〗内部类可访问它所在类的成员

把类定义在另一个类的内部, 该类就被称为内部类。内部类的类名不能与定义它的类的名称相同。本题答案为A选项。

【25】在方法内部使用, 代表对当前对象自身引用的关键字是

〖A〗 super

〖B〗 This

〖C〗 Super

〖D〗 this

super关键字为实现对父类变量的访问和对父类方法的调用。对当前对象自身的引用应使用this关键字。本题答案为D选项。

【26】下列程序的运行结果是

public class Test {
    private String[] data = {"10", "10.5"};
    public void fun() {
        double s = 0;
        for (int i = 0; i < 3; i++) {
            try {
                s = s + Integer.parseInt(data[i]);
                } catch(Exception e) {
                System.out.print("error1: " + data[i]);
            }
        }
    }
    public static void main(String[] args) {
        try {
            Test d = new Test();
            d.fun();
            } catch(Exception e) {
            System.out.println(" error2");
        }
    }
}

〖A〗 error1: 10.5

〖B〗 error2

〖C〗 error1: 10.5 error2

〖D〗 error1: error2

程序中定义了数组data长度为2, 访问数组元素的下标为0~1。在fun()函数中, for循环的i变量值从0到2, 当i = 2时, 访问数组越界, 报数组越界异常。执行catch语句捕获异常, 此时输出“error: 10.5”。在catch语句中执行了data[i], 仍然抛出异常, 此时捕获异常的语句是main()函数的catch语句, 输出“error2”。本题答案为C选项。

【27】下列能表示字符串s1长度的是

〖A〗 s1.length

〖B〗 s1.length()

〖C〗 s1.size

〖D〗 s1.size()

java中表示字符串长度的方法是length()方法。本题答案为B选项。

【28】阅读下面求质数的程序, 在下划线处应填入的选项是

import java.lang.Math.*;
public class MorePrimesTest {
    public static void main(String[] args) {
        long[] primes = new long[20];
        primes[0] = 2L;
        primes[1] = 3L;
        long number = 5L;
        outer:
        for (int count = 2 ; count < primes.length; number += 2L) {
            long limit = (long) Math.ceil(Math.sqrt((double) number));
            for (int i = 1; i < count && primes[i] <= limit; i++) {
                if (number_____ primes[i] == 0L) {
                    continue outer;
                }
            }
            primes[count++] = number;
        }
        for (int j = 0; j < primes.length; j++) {
            long n = primes[j];
            System.out.println(n);
        }
    }
}

〖A〗 &

〖B〗 *

〖C〗 /

〖D〗 %

本题是求从2开始的20个质数, 存放于数组primes中, 并打印这个数组。质数是指在大于1的自然数中, 除了1和它本身以外不再有其他因数的自然数。判断number是不是质数, 将number与primes[i]求余, 如果能整除, 表示不是质数, 在判断一下个数。所以下划线初填写求余符号“%”。本题答案为D选项。

【29】已知zipname是一个压缩文件名。则zipname 在下列代码中出现的正确位置是

ZipInputStream zin = new ZipInputStream(new FileInputStream(①));
ZipEntry entry;
while ((entry = zin.getNextEntry(②)) != null) {
    fileCombo.addItem(entry.getName(③));
    zin.closeEntry(④);
}
zin.close();

〖A〗 ①

〖B〗 ②

〖C〗 ③

〖D〗 ④

ZipInputStream类的构造函数为, DataInputStream(InputStream in), 需要构造一个输入流对象作为构造函数的参数。new FileInputStream()需要穿输入文件名, 生成输入流对象。本题答案为A选项。

【30】 Java中类ObjectOutputStream支持对象的写操作, 这是一种字节流, 它的直接父类是

〖A〗 Writer

〖B〗 DataOutput

〖C〗 OutputStream

〖D〗 D1.ObjectOutput

ObjectOutputStream是字节流, 所有的字节输出流都是OutputStream抽象类的子类。ObjectOutputStream既继承了OutputStream抽象类, 又实现了ObjectOutput接口, Java用接口技术代替双重继承。本题答案为C选项。

【31】阅读下列程序

import java.io.*;
public class ByteStreamTest {
    public static void main(String[] a) {
        int [] myArray = { 10, 20, 30, 40 };
        try {
            DataOutputStream dos = new DataOutputStream(new __________("ints.dat"));
            for (int i = 0; i < myArray.length; i++)
            dos.writeInt(myArray[i]);
            dos.close();
            System.out.println("Have written binary file ints.dat");
        }
        catch(IOException ioe) {
            System.out.println("IO Exception");
        }
    }
}

为保证程序正确运行, 在程序中下划线处应填入的代码是

〖A〗 FileOutputStream

〖B〗 ByteArrayOutputStream

〖C〗 BufferedOutputStream

〖D〗 FileWriter

二进制文件可作为类FileOutputStream构造方法的参数, 而FileOutputStream对象作为DataOutputStream的构造方法的参数实现DataOutputStream类。本程序中, “ints.dat”文件作为FileOutputStream对象构造方法的参数, 然后FileOutputStream对象作为字节输出流的形参。本题答案为A选项。

【32】下列代码将对象写入的设备是

ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
out.writeObject(this);
out.close();

〖A〗网络

〖B〗屏幕

〖C〗硬盘

〖D〗内存

ObjectOutputStream类的构造方法是ObjectOutputStream(OutputStream out)。Java中的二进制流全都写入到内存中。本题答案为D选项。

【33】用鼠标点击菜单项(MenuItem)产生的事件是

〖A〗 MenuEvent

〖B〗 ActionEvent

〖C〗 KeyEvent

〖D〗 MouseEvent

ActionEvent是组件事件, 当特定于组件的动作(比如被按下)发生时, 由组件(比如Button)生成此高级别事件。事件被传递给每一个ActionListener对象, 这些对象是使用组件的addActionListener方法注册的, 用以接收这类事件。本题答案为B选项。

【34】下列不属于Swing的构件是

〖A〗 JButton

〖B〗 JLabel

〖C〗 JFrame

〖D〗 JPane

Swing构件中JButton是按钮构件, JLabel为标签构件, JFrame为顶层窗体容器构件。中间容器面板应为JPanel, 而不是JPane。本题答案为D选项。

【35】下列为窗口事件的是

〖A〗 MouseEvent

〖B〗 WindowEvent

〖C〗 ActionEvent

〖D〗 KeyEvent

“WindowEvent”属于窗口事件。本题答案为B选项。

【36】下列有关Java线程的说法中, 正确的是

〖A〗 Java中的线程模型包括虚拟的CPU和程序代码两部分

〖B〗 Java中, 程序的一次执行对应一个线程

〖C〗线程创建后需要通过调用start()方法启动运行

〖D〗只有Java能够支持基于多线程的并发程序设计

Java中的线程模型包括虚拟的CPU、程序代码以及代码操作的数据三部分, 选项A错误; java中可以一次执行多个线程, 线程并发执行, 选项B错误; 线程启动只有start()方法, 选项C正确; 不光只有java支持多线程并发设计, C语言, C++语言都支持。本题答案为C选项。

【37】关于下列代码编译或执行结果的描述中, 正确的是

public class Test {
    public static void main(String[] args) {
        TestThread pm1 = new TestThread("One");
        pm1.start();
        TestThread pm2 = new TestThread("Two");
        pm2.start();
    }
}
class TestThread extends Thread {
    private String sTname = "";
    TestThread(String s) {
        sTname = s;
    }
    public void run() {
        for (int i = 0; i < 2 ; i++) {
            try {
                sleep(1000);
            }
            catch(InterruptedException e) { }
            System.out.print(sTname + " ");
        }
    }
}

〖A〗不能通过编译, TestThread类中不能定义变量和构造方法

〖B〗只可能输出 One One Two Two

〖C〗只可能输出 Two One One Two

〖D〗 Two One One Two和One One Two Two都有可能

启动两个线程, 线程之间没有进行同步, 所以B和C均有可能。选项D正确。本题答案为D选项。

【38】可以使当前同优先级线程重新获得运行机会的方法是

〖A〗 yield()

〖B〗 join()

〖C〗 sleep()

〖D〗 interrupt()

本题考查线程的基本控制。Thread类提供的基本线程控制方法包括: sleep(): 使比其低的优先级线程运行, 可以让一个线程暂停运行一段固定的时间; yield(): 使具有与当前线程相同优先级的线程有运行的机会; join(): 使当前线程暂停执行, 等待调用该方法的线程结束后, 再恢复执行; interrupt(): 中断线程的阻塞状态, 并且线程接收到InterruptException异常。根据上述介绍可知, 只有yield()方法可以使当前同级线程重新获得运行机会。本题答案为A选项。

【39】下列叙述中, 错误的是

〖A〗 Java中没有检测和避免死锁的专门机制

〖B〗程序中多个线程互相等待对方持有的锁, 可能形成死锁

〖C〗 Java程序员可以预先定义和执行一定的加锁策略, 以避免发生死锁

〖D〗为避免死锁, Java程序中可先定义获得锁的顺序, 解锁是按加锁的正序释放

本题考查Java线程的同步机制。如果程序中多个线程互相等待对方持有的锁, 而在得到对方锁之前都不会释放自己的锁, 这就造成了都想得到资源而又都得不到, 线程小能继续运行, 这就是死锁。Java中没有检测与避免死锁的专门机制, 因此完全由程序进行控制, 防止死锁的发生。应用程序可以采用的一般做法是: 如果程序要访问多个共享数据, 则要首先从全局考虑定义一个获得锁的顺序, 并且在整个程序中都遵守这个顺序。释放锁时, 要按照加锁的反序释放。本题答案为D选项。

【40】当一个Applet被加载, 后续对Applet 生命周期方法的调用中, 可能存在的次序是

〖A〗 start(), stop(), init(), destroy()

〖B〗 init(), start(), stop(), start(), stop(), destroy()

〖C〗 start(), init(), stop(), destroy()

〖D〗 init(), start(), destroy(), stop()

init()方法一般用来完成所有必需的初始化操作; start()是在初始化之后Applet被加载时调用; stop()在Applet停止执行时调用, destory()是Applet从系统中撤出时调用。选项B正确, 本题答案为B。

原文 http://www.cnblogs.com/mjios/p/12454921.html

正文到此结束