选择习题集3

一、
1、如果希望监听TCP端口9000，服务器端应该怎样创建socket? B
A：new Socket(“localhost”,9000);
B：new ServerSocket(9000);
C：new Socket(9000);
D：new ServerSocket(“localhost”,9000);

ServerSocket(int port)：服务器绑定端口号，调accept()监听等待客户端连接，它返回一个连接队列中的一个socket。
Socket(InetAddress address , int port)是创建客户端连接主机的socket流，InetAddress是用来记录主机的类，port指定端口

2、jre 判断程序是否执行结束的标准是A
A：所有的前台线程执行完毕
B：所有的后台线程执行完毕：
C：所有的线程执行完毕
D：和以上都无关

后台线程就是守护线程，前台线程就是用户线程。
守护线程：是指在程序运行时在后台提供一种通用服务的线程，这种线程并不是必须的。同时守护线程的线程优先级都很低的。JVM中的GC线程就是一个守护线程，只要JVM启动，GC线程就启动了。
用户线程和守护线程几乎没有什么区别，唯一的区别就在于，如果用户线程都已经退出了，只剩下了守护线程，那么JVM直接就退出了。

3、如下语句通过算术运算和逻辑运算之后i和 j的结果是D

int i=0;
int j=0;
if((++i>0)||(++j>0)){
//打印出i和j的值。
}

A：i=0;j=0
B：i=1;j=1
C：i=0;j=1
D：i=1;j=0

|| 与 && 都是短路功能：
前者，表达式一为真，表达式二不执行。
后者，表达式一位假，表达式二不执行。

4、instanceof运算符能够用来判断一个对象是否为:C
A：一个类的实例
B：一个实现指定接口的类的实例
C：全部正确
D：一个子类的实例

instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

二、
1、以下叙述正确的是
A：实例方法可直接调用超类的实例方法
B：实例方法可直接调用超类的类方法、
C：实例方法可直接调用子类的实例方法
D： 实例方法可直接调用本类的实例方法

A：实例方法可以调用父类的实例方法，但是需要注意修饰符。如果父类中的方法被private修饰，子类也就无法继承和访问了。
B、同样存在修饰符的问题/
C、父类访问子类，需要new一个对象才可以访问，不可以直接访问。

2、变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（）

0x7FFFFFFFFFFFFFFF+1=0X8000000000000000
a-b=0Xf000000000000000-0X8000000000000000+1
=0X7000000000000001
=16^(15*7+16)+1
=2^607+1

3、以下代码在编译和运行过程中会出现什么情况 A

public class TestDemo{ 
	private int count;
	public static void main(String[] args) {
		TestDemo test=new TestDemo(88); 
		System.out.println(test.count); 
	} 
	TestDemo(int a) { 
		count=a; 
	}
}

A：编译运行通过，输出结果是88
B：编译时错误，count变量定义的是私有变量
C：编译时错误，System.out.println方法被调用时test没有被初始化
D：编译和执行时没有输出结果

构造函数中的count=a相当于this.count=a,this可以省略
count的修饰符是private，在main方法中可以访问。

4、以下程序执行的结果是：C

class X{
	Y y=new Y();
	public X(){
		System.out.print("X");
	}
}
class Y{
	public Y(){
		System.out.print("Y");
	}
}
public class Z extends X{
	Y y=new Y();
	public Z(){
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z();
	}
}

A：ZYXX
B：ZYXY
C：YXYZ
D：XYZX

初始化的过程：
初始化父类中的静态成员变量和静态代码块
初始化子类中的静态成员变量和静态代码块
初始化父类的普通成员变量和代码块，再执行父类的构造方法
初始化子类的普通成员变量和代码块，再执行子类的构造方法

三、
1、考虑下面这个简单的例子，让我们看看reflection是如何工作的。

import java.lang.reflect.*;
public class DumpMethods {
	public static void main(String args[]) {
		try {
			Class c = Class.forName(args[0]);
			Method m[] = c.getDeclaredMethods();
			for (int i = 0; i < m.length; i++)
			System.out.println(m[i].toString());
		} catch (Throwable e) {
			System.err.println(e);
		}
	}
}

其中"c.getDeclaredMethods"的作用是: D
A：取得类的公有方法对象
B：取得类的所有公有方法名称
C：取得类的所有方法对象
D：以上选项都不正确

c.getDeclaredMethods获取该类中定义的所有方法的列表

2、java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。 B
A：8
B：16
C：32
D：64

每个字符占2个字节，也就是16个比特位

3、有如下4条语句：

Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

以下输出结果为false的是: C
A：System.out.println(i01i02);
B：System.out.println(i01i03);
C：System.out.println(i03i04);
D：System.out.println(i02i04);

解析

4、以下关于java封装的描述中，正确的是：
A：封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
B：封装的意义不大，因此在编码中尽量不要使用
C：如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用
D：只能对一个类中的方法进行封装，不能对属性进行封装

封装主要是隐藏内部代码
继承主要是复用现有代码
多态主要是改写对象行为

四、
1、用不带头结点的单链表存储队列,其队头指针指向队头结点,队尾指针指向队尾结点,则在进行出队操作时C
A：仅修改队头指针
B：仅修改队尾指针
C：队头、队尾指针都可能要修改
D：队头、队尾指针都要修改

当队列中只剩最后一个元素时，删除此元素需要将队列置空，就需要队头、队尾都改变。

2、假设你只有100Mb的内存，需要对1Gb的数据进行排序，最合适的算法是A
A：归并排序
B：插入排序
C：快速排序
D：冒泡排序

内存只有100MB，而数据却有1GB，所以肯定没办法一次性放入到内存中进行排序。只能用外部排序，而外排序通常使用多路归并排序。即将原文件分解成多个能够一次性装入内存的部分，分别把每一部分调入内存中进行排序，然后对已经排序的子文件进行多路归并排序。

五、
1、某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为B
A：不存在这样的二叉树
B：200
C：198
D：199

根据二叉树的基本性质，对任何一颗二叉树，度为0的节点（即叶子节点）总是比度为2的节点多一个

2、解决散列法中出现冲突问题常采用的方法是D
A：数字分析法、除余法、平方取中法
B：数字分析法、除余法、线性探测法
C：数字分析法、线性探测法、多重散列法
D：线性探测法、多重散列法、链地址法

哈希函数的构造方法：数字分析法、平方取中法、除留取余法、分段叠加法
处理冲突的方法：开放地址法（包括线性探测法、二次探测法、伪随机探测法）、链地址法、多重散列法

3、设无向图的顶点个数为n，则该图最多有（ ）条边。B
A：n-1
B：n(n-1)/2
C：n2
D：n(n+1)/2

连通图，最少有N-1条边，最多有N(N-1)/2条边。