Java程序员入职测试题及答案

注意：

考试时间：150分钟

请将答案写在答题纸上

本试卷共计10题。

1下列哪些方法互为重载方法，哪些方法是覆盖方法。答案用号码标识：4分

public class A {

①public static void method(String str){};

②protected int method(int i){return 0;};

③private void method(String str, int i) {};

④public int method(){return 0;};

⑤void method(A a){};

}

class B extends A {

⑥public static void method(String str) {};

⑦public int method(int i) {return 0;};

⑧public void method(String str,int i) {};

⑨int method() {return 0;};

⑩public method(A a) {};

}

2下列说法正确的打√，错误的打×。每题0.25分，计15分。

1. java源程序编译为字节码，存放在.class文件中，JVM装载类解释执行。
2. 面向对象的三个特点是：封装、继承和多态。
3. 构造函数是在对象被创建后，new运算符完成之前被调用的。
4. 接口可以继承。一个接口可以被多个不同的类来实现。一个类可以实现多个接口。
5. Java定义了两种类型的流：字节流和字符流。缓冲字节流和字符流可提高I/O性能。
6. Java IO类的设计中，采用了油漆工设计模式，避免了类的层次结构过于复杂。
7. 在委托事件模型中，源生成事件并把它发送给一个或多个监听器，每个监听器必须向事件源注册。
8. Java从语言级提供了对线程同步的支持。Java中每个对象都有一个用来同步的监控器。
9. String 对象的字符串不能被修改，而StringBuffer对象的字符串则可以被修改。
10. -39右移3位的值为-5。
11. 当程序产生异常时，如果不在程序中try/catch，那么程序可能会中止运行而退出。
12. jsp运行在web容器中，javascript运行在浏览器中，servlet运行在web容器中，ejb运行在ejb容器中，容器运行在虚拟机中。
13. jsp经过编译后生成servlet，编译是由容器完成的。
14. servlet的实例变量由所有session共享。servlet context里的变量由所有servlet共享。
15. servlet是应用服务器的扩展，它由应用服务器动态加载，调用和销毁。
16. servlet在多线程模式下运行时，之所以不在doGet()，doPost()方法前加synchronized，原因是为了提高性能。但前提是在servlet中只能存放只读的实例变量，而将那些可能被修改的变量放到方法中。
17. hibernate和entity bean实现ORM功能。类之间一对一或一对多的关联关系映射成表之间的外键关系；类之间的多对多的关联关系映射成关联表和被关联表之间的外键关系。
18. EJB一般包括远程接口、Home接口、Bean类和其它工具类，以及部署描述文件。实体Bean还可能包括主键类。
19. jdbc的事务必须在一个数据库连接上完成。编程时必须去掉数据库的自动提交功能。当成功后调用commit，当失败后调用rollback。
20. struts是一个mvc的架构，实现了界面和业务逻辑的分离，其控制中心是servlet。
21. j2ee应用程序可以被打包成ear文件，该文件中可以包含多个web 模块和ejb模块。
22. 使用weblogic时，必须配置一个server和domain。这样的server和domain可以有多个。
23. 实体Bean经常被会话Bean包装而不向外暴露，这种设计方式叫做外观模式。
24. 客户端通过JNDI名称来引用数据源、EJB。JNDI 是Java Naming and Directory Interface的缩写。
25. 在CMP实现中，当定义主键类时，必须实现hashCode和equals方法。
26. 在CMR实现中，必须在ejb-jar.xml文件中定义实体Bean之间的关系，在weblogic-cmp-rdbms.xml文件中定义表之间关系。
27. <jsp:forward page=””/>不能转到应用程序以外的页面，而sendDirect() 则可以。
28. 在jsp中，尽量不要嵌套java代码，可以用JSTL,自定义标签库，javaBean和el来代替。
29. struts的ActionForm可以对应多个JSP，同时也可以对应多个Action。
30. struts的model层可以通过javaBean、ejb和hibernate去访问数据库。
31. hibernate可以把一个简单的java类和数据库表建立映射，而ejb则不行。
32. hibernate的每个线程有一个Session对象，该对象放在线程的局部变量中。Session中封装了对数据库的操作。
33. 软件开发流程一般包括需求收集、分析、设计、实现、测试和部署。CMM和RUP都是常用的软件开发过程控制方法。
34. 在多层结构中，调用层和被调用层之间最好采用接口来调用。因为接口使层间耦合最小。
35. UML是统一建模语言，其中类图用来描述系统中类的结构以及类之间的关系；活动图用来描述用例的事件流。顺序图用来描述用例中一个事件流的实现。
36. 可以给JVM设置一些参数，如Xmx256m表示JVM的最大可用内存。
37. 采用工厂模式生成对象实例可以使调用方不必了解被生成对象的类的层次。即使类的层次发生变化，调用方也不用修改代码。
38. 在嵌套循环中，break从最近的一层循环退出到外面的一层循环。而 continue则继续最近的一层循环的下一次循环。
39. 数据库的主键和外键都分别是表的一种约束。当删除主键表中的记录时，要么首先删除外键表中的关联记录，要么主键和外键表中的记录一起删掉。
40. 在面向对象的分析中，类之间的关系有关联、聚合、组合、继承、依赖，其中继承的耦合性最强，依赖的耦合关系最弱。
41. 在windows下开发的java程序，如果要在linux/unix下运行，必须重新编译一遍。
42. Java是一种强类型语言，即每个变量和表达式都有一个确定的类型；在给变量赋值时必须经过类型兼容性检查。类型转换错误是一种运行时错误。
43. Java中一个超类可以有多个子类，一个子类可以从多个超类继承。
44. EJB包括会话Bean、实体Bean和消息驱动Bean。会话Bean包括有状态和无状态，实体Bean包括CMP和BMP。实体Bean和有状态会话Bean可能被池化。
45. Http和TCP协议一样是有状态的协议。HTML常用来显示数据，而XML则通常用来存储数据。
46. 数据库连接池允许有最大连接数和最小连接数，为提高性能，不要把两者设为相等。
47. 数据库中的两张表之间的关系为多对多时，必须生成一张中间表。java中的两个类之间的关联关系为多对多时也必须生成一个关联类。
48. 会话跟踪中的URL重写表示在原来的URL后加上Cookie的名称/值对。会话跟踪中的session方法与cookie无关。
49. Hibernate可以映射类的层次关系，而ejb不可以。
50. 在EJB CMR设计中，实体Bean间的关联字段不能暴露给客户端。同样Hibernate也不可以将类之间的关联字段暴露给客户端。
51. 在java中不存在内存泄漏的问题。因为java虚拟机自动回收垃圾。
52. java类的类变量和实例变量位于内存的堆中，局部变量位于栈中，方法位于方法区中。
53. oracle的数据类型包括integer、char、varchar2、long、blob和clob等。
54. j2ee的多层结构特别适用于以数据为中心的系统，此时业务逻辑封装在存储过程中。
55. 使用DriverManager连接数据库比使用数据库连接池更能提高系统性能，因为DriverManager的getConnection()方法是线程安全的。
56. 当从web浏览器向web服务器请求jsp页面时，web服务器通过Http协议将jsp返回到web浏览器执行。
57. 定义：String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么，s1==s2；s3 == s4；s1.equals(s3);
58. 在集合框架中，如果要访问ArrayList中的第n个元素，可以采用Iterator和get()两种方法，前者的效率更高。
59. javascript可以用来在jsp中验证数据输入的正确有效性。在一个jsp中只能有一个Form，可以使用javascript来提交jsp。
60. 在面向对象的分析中，类中的方法应该高内聚，包中的类应该松耦合，包之间也应该松耦合。

3 在下划线位置填上合适的代码，并且写出程序输出的结果。2 x 6= 12分

public class ObjectArray {

public static void main(String args[]) {

Person personList[] = new Person[4];

for (int i = 0; i < personList.length; i++) {

_ ①__

personList[i].setId(“id ” + i);

personList[i].setName(“name ” + i);

__②__

for (int j=0; j < 2;j++){

Person kid = new Person();

kid.setId(“kid id” + j);

kid.setName(“kid name” + j);

__③__

personList[i].getKids().add(kid);

}

_④___

personList[i].getMother().setId(“mother id”);

personList[i].getMother().setName(“mother name”);

_⑤___

personList[i].getMother().getKids().add(__⑥___);

}

}

}

class Person {

private String id;

private String name;

HashSet kids;//子女

Person mother;//母亲

// setter 和 getter 方法省略。

}

4 下面的程序只允许产生一个A的实例，分析代码并填空。1×4=4分

public class A {

protected static int i = 10;

protected static String s = “”;

private static A a;

//写出A的构造函数

__①_

 

public static void main(String[] args) {

A a = null;

System.out.println(a.i); //输出结果：__②__

a = A.getInstance();

System.out.println(a.s); //输出结果：__③__

}

 

// 写出方法getInstance()的定义。

__④__

 

static {

i += 10;

s += 10;

a = new A();

}

}

5 下面的代码中，A和B位于同一包中。而C则在另一个包中。1X8 = 8分

package j2setest.access;

import j2setest.access.access1.*;

 

public class A extends B{

public byte i = 1;

public A() {

}

public void test() {System.out.println(“In A”);}

public static void main(String args[]) {

A a = new A(); // a包含哪些实例变量: __①__

// a能访问哪些实例变量: __②__

C c = new C(); // c包含哪些实例变量:____③__

// c能访问哪些实例变量: __④__

B b = new A();

A a1 = (A)b; // 此句强制转化是否正确？__⑤__

C c2 = (C)a; // 此句强制转化是否正确？___⑥__

b.test(); // 打印结果：______________⑦__

System.out.println(b.i); //打印结果：________⑧__

}

}

 

class B {

public int i = 5;

private String s;

protected double d;

B b;

public void test(){System.out.println(“In B”);}

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////

package j2setest.access.access1;

import j2setest.access.*;

 

public class C extends A{

public C() {

}

public void test() {System.out.println(“In C”);};

}

6 下面是一个自行设计的线程安全的链表，链表长度不超过MAX_LENGTH。请填空。1X10=10分

public class MyList {

private Element head=null;

private Element tail = null;

private int length=0;

private static final int MAX_LENGTH = 1024;

 

class Element {

Object data;

__①__;

Element(Object data) {

this.data = data;

}

}

 

synchronized public void addElement(Object d)

{

Element e = new Element(d);

if (length == 0) {

__②___;

__③___;

}

else {

__④___ {

wait();

}

e.next = null;

tail.next = e;

tail = e;

}

length++;

_⑤_

}

 

synchronized public Object removeElement() {

Object obj;

while (length == 0 ) {

     __⑥___;

}

else if (length == 1) {

obj = head.data;

head = tail = null;

 

}

else {

___⑦__;

____⑧___;

 

}

length–;

notifyAll();

return obj;

}

 

synchronized public Object get(int index) {

Element ptr = head;

int sequence = 0;

 

_⑨____ {

wait();

}

while (ptr != null) {

if (sequence == index) {

__⑩_;

return ptr.data;

}

ptr = ptr.next;

sequence++;

}

notfiyAll();

return null;

}

 

}

7 将任意一个jsp,如login.jsp，query.jsp提交到MyServlet，MyServlet处理后分别转到loginAck.jsp和queryAck.jsp。 下面是代码片段，请填空。（0.5 X 10 = 5分）

web.xml:

<servlet>

<servlet-name>__①_______</servlet-name>

<servlet-class>net.umltech.train.java.test.MyServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>__②________</servlet-name>

<url-pattern>____③_______</url-pattern>

</servlet-mapping>

 

login.jsp:

<form action=”___④________”>

</form>

 

query.jsp:

<form action=”__⑤_______”>

</form>

 

MyServlet.java:

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

____⑥___);

if (url.equals(“/login.do”)) {

___⑦__

___⑧___

}

else if (url.equals(“/query.do”)) {

___⑨___

___⑩___

}

}

8. 用struts实现用户登录的功能。请填空。每空1分，计15分

login.jsp:

<form action = “__①__”>

</form>

 

struts-config.xml:

<form-beans>

<form-bean name=”__②___” type=”net.umltech.train.form.LoginForm” />

</form-beans>

<action-mappings>

<action input=”/login.jsp” name=”__③__” path=”/loginAction” scope=”session” type=”net.umltech.train.action.LoginAction”>

<forward name=”success” path=”/success.jsp” />

</action>

</action-mappings>

 

User.java:

public class User{

private String userId;

private String userName;

private Set groups = new HashSet();

//getter,setter method are omitted.

}

Group.java:

public class Group{

private String groupId;

private String groupName;

private Set rights = new HashSet();

// getter,setter method are omitted.

boolean equals(Group group) {

__④__

}

}

 

Right.java:

public class Right{

private String rightId;

private String rightName;

}

写出数据库中和User,Group,Right类分别对应的users,groups和rights表的定义：___⑤____

LoginAction.java:

public class LoginAction extends Action {

public ActionForward execute(ActionMapping actionMapping, ActionForm actionForm, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {

try {

User user = findByUserName(actionForm.getUserName());

httpServletRequest.getSession.setAttribute(“user_right”,user);

} catch(Exception e) {}

return actionMapping.findForward(“success”);

}

 

public User findByUserName(String userName) throws Exception{

String mysql =

“select users.USER_ID,groups.GROUP_ID,groups.NAME,rights.RIGHT_ID,rights.NAME

from users,user_group,groups,group_right,rights where users.NAME = ?

and users.USER_ID = user_group.USER_ID

and user_group.GROUP_ID = groups.GROUP_ID

and groups.GROUP_ID = group_right.GROUP_ID

and group_right.RIGHT_ID = rights.RIGHT_ID”;

PreparedStatement pstmt = connection.PrepareStatement(mysql);

pstmt.setString(1,userName);

ResultSet rs = pstmt.executeQuery();

User user = new User();

while(rs.next()) {

String userId = rs.getString(1);

String groupId = rs.getString(2)

String groupName =rs.getString(3);

String rightId = rs.getString(4);

String rightName = rs.getString(5);

 

Group group = new Group();

group.setGroupId(groupId);

group.setGroupName(groupName);

 

Set groups = user.getGroups();

iterator iter = groups.iterator();

boolean found = false;

while(iter.hasNext()) {

Group theGroup = (Group)iter.next();

if (theGroup.equals(group)) {

     ____⑥___

     found=true;

     break;

     }

}

if (__⑦____) {

groups.add(group);

}

 

Right right = new Right();

right.setRightId(rightId);

right.setRightName(rightName);

_____⑧_______

} // while(rs.next())

__⑨___

__⑩___

connection.close();

return user;

}// findByUsername

}

 

success.jsp:将用户的组权限的名称显示出来：

<c:forEach var=”__⑾___” items=”____⑿____”>

<c:forEach var=”__⒀____” items=”___⒁____”>

<c:out value=”___⒂____” /><br />

</c:forEach>

</c:forEach>

9 仔细分析下面的代码，然后填空。每空1分，计24分。

程序说明：类DynArray实现了一个动态数组。当数组的空间不够时动态分配空间。

public class DynArray {

private Object[] array;

private int index;

public DynArray() {

array = new Object[16];

index = -1;

}

// 向动态数组中添加一个对象obj。如果空间不够，重新分配空间。

public void add(Object obj) {

if (index == array.length -1) {

_⑴_

_⑵_

_⑶_

}

array[++index] = obj;

}

//从数组中删除一个指定对象。

public void remove(Object obj) {

if (index < 0) {

return;

}

for (int i = 0; i <= index; i++) {

if (array[i].equals(obj)) {

for (int j = i; j < index; j++) {

__⑷__

}

break;

}

}

index–;

}

//返回指定索引处的对象。

public Object getAt(int index) {

return array[index];

}

//返回当前数组的元素个数。

public int size() {

return index + 1;

}

}

//接口MySet定义一个集合操作

import java.util.Iterator;

public interface MySet {

public boolean put(Object obj);

public boolean remove(Object obj);

public Iterator iter();

public boolean contains(Object obj);

}

//类MyHashSet采用哈希表来存储集合元素

public class MyHashSet implements MySet {

private DynArray[] container;

private int count;

 

public MyHashSet() {

count = 0;

container = new DynArray[16];

}

//向集合中添加一个元素，但不允许重复元素，否则返回false。成功则返回true;

public boolean put(Object obj) {

if (contains(obj)) {

return false;

}

int hashCode = Math.abs(obj.hashCode());

int pos = _____⑸______;

if (container[pos] == null) {

______⑹_____;

}

______⑺____;

count++;

return true;

}

//从集合中删除一个元素，当集合中没有该元素时返回false。成功删除返回true;

public boolean remove(Object obj) {

if (!contains(obj)) {

return false;

}

int hashCode = Math.abs(obj.hashCode());

int pos = hashCode % container.length;

_____⑻____;

count–;

return true;

}

// 返回一个集合的迭代器

public Iterator iter() {

____⑼_____

}

// 判断集合中是否包括指定的元素。

public boolean contains(Object obj) {

Iterator iter = new MyIterator();

while (iter.hasNext()) {

Object theObj = iter.next();

if (theObj.equals(obj)) {

return true;

}

}

return false;

}

//一个实现标准Iterator接口的内部类。

class MyIterator implements Iterator {

private int containerIndex = 0;

private int iterCount = 0;

private int arrayIndex = 0;

 

public void remove() {

}

 

public boolean hasNext() {

if (___⑽______) {

return true;

}

else {

return false;

}

}

 

public Object next() {

Object obj = null;

while (containerIndex < container.length) {

if (container[containerIndex] == null) {

containerIndex++;

continue;

}

if (arrayIndex < container[containerIndex].size()) {

obj = ______⑾_________

arrayIndex++;

iterCount++;

break;

}

else {

containerIndex++;

arrayIndex = 0;

___⑿______

}

}

return obj;

}

}

}

10 根据UML类图的定义和关系，用java语言来实现。3分

 

说明：

• Vehicle为抽象类；Car，Truck为Vehicle的子类；ICargoTransport为接口。Truck实现IcargoTransport接口。
• 类Person和Vechicle之间的关联关系如图所示。
• Engine是一个类，它和Vehicle之间为聚合关系，即Vehicle包含Engine。

写出各个类、接口的定义，包括实例变量的定义，方法的定义和方法的示例性实现。

 

答案：

1. 填写序号
   

1. 正确的打√，错误的打×
   

前40题正确，后20题错误。

3.    

4.    

5.    

6.    

7.    

8.    

9:

10.    

将此题答案写在第二页答题纸的反面。

public abstract class Vehicle {

private Engine engine;

public Vehicle() {

}

public void setEngine(Engine engine) {

this.engine = engine;

}

public abstract String go();

public void startEngine() {

if (this.engine != null) {

this.engine.start();

}

}

public void stopEngine() {

if (this.engine != null) {

this.engine.stop();

}

}

public boolean isEngineOn() {

if (this.engine != null) {

return this.engine.isOn();

}

return false;

}

}

 

public class Car extends Vehicle{

public Car() {

}

public String go() {

if (this.isEngineOn()) {

return “!!!!”;

}

else {

return “…”;

}

}

}

 

public interface CargoTransport {

public void loadCargo();

}

public class Truck extends Vehicle implements CargoTransport {

public Truck() {

}

public String go() {

if (this.isEngineOn()) {

return “!!!”;

}

else {

return “…”;

}

}

public void loadCargo() {

System.out.println(“truck can load cargo.”);

}

 

}

 

public class Engine {

private boolean on;

public Engine() {

}

public void start() {

this.on = true;

}

public void stop() {

this.on = false;

}

public boolean isOn() {

return this.on;

}

}

 

public class Person {

private Vector vehicles = new Vector();

public Person() {

}

public void addVehicle(Vehicle v) {

vehicles.addElement(v);

}

}