java程序员经典笔试题

关键词： 事务管理 程序员 笔试 试题

java程序员经典笔试题（通用11篇）

篇1：java程序员经典笔试题

姓名：联系方式：考试开始时间：

Java程序员笔试题

一、单项选择题（共10题，每题2分，共20分）

1.下列说法哪一个是正确的。（B）

A．Java程序经编译后会产生machine code

B．Java程序经编译后会产生byte code

C．Java程序经编译后会产生DLL

D．以上都不正确

2.提供Java存取数据库能力的包是。（A）

A．java.sqlB．java.awtC．java.langD．java.swing

3.执行如下程序代码后，C的值是。（C）

a=0;c=0;

do{

--c;

a=a-1;

}while(a>0);

A．0B．1C．-1D．死循环

4.下面的语句中正确的表达式为。（C）

A．byte b = 128;

B．boolean n = null;

C．double d = 0.9239d;

D．float f = 0.9239;

5.将一个十六进制值赋给一个long型变量的正确写法为。（D

A．long number = 345L;

B．long number = 0345;

C．long number = 0345L;

D．long number = 0x345L;

6.以下程序代码的输出是。（B）

public class test（public static void main(String args[])（System.out.printIn(6 ^ 3);))

A．3B．5C．6D．11

7.以下程序代码的输出是。（E）

public class test（private static int j = 0;

private static boolean methodB(int k)（j += k;）

return true;)

public static void methodA(int i){

boolean b:

b = i < 10 | methodB(4);

b = i < 10 || methodB(8);)

public static void main(String args[] }（methodA(0);

system.out.printIn(j);))

A．0B．4C．8D．12E．不能编译通过

8.以下程序代码的输出是。（A）

public class test {

public static void add3(Integer i)}

int val = i.intValue();

val += 3;

i = new Integer(val);

}

public static void main(String args [ ]){

Integer i = new Integer(0);

add3(i);

system.out.printIn(i.intValue());

})

A．编译失败B．编译成功但在第三行会出现异常

9.以下程序代码执行后，哪个说法正确？（B）

int index = 1;

boolean[] test = new Boolean[3];

boolean foo= test [index];

A．有异常抛出。

B．无法编译。

C．foo的值是0。

D．foo的值是null。

E．foo的值是true。

F．foo的值是false。

10.以下哪个类是swt包中的。（D）

A．MessageBoxB．MessageDialogC．JDialog

C．0D．3 D．DisplayMode

二、多项选择题（共5题，每题4分，共20分）

1.在下面的选项中合法的标识符有。（ADEF）

A．_ok

B．*point

C．this

D．$byte

E．const

F．ILikeJLCSS

2.下面的选项中哪些不是java的关键字。（AB D）

A．TRUE

B．sizeof

C．goto

D．const

E．super

F．void

3.下面的叙述中正确的有。（AC）

A． 环境变量可在编译source code时指定。

B． 在编译程序时，所能指定的环境变量不包括class path。

C． javac一次可同时编译数个Java源文件。

D． javac.exe能指定编译结果要置于哪个目录（directory）。

4.下面的叙述中正确的有。（C）

A．equals()方法判定引用值是否指向同一对象。

B．= = 操作符判定两个分立的对象的内容和类型是否一致。

C．equals()方法只有在两个对象的内容一致时返回true。

D．类File重写方法equals()在两个分立的对象的内容和类型一致时返回true。

5.下面有关变量及其作用域的陈述哪些是对的。（A C）

A.在方法里面定义的局部变量在方法退出的时候被撤销。

B.局部变量也叫自动变量。

C.在方法外面定义的变量（译注：即实例变量）在对象被构造时创建。

D.在方法中定义的方法的参变量只要该对象被需要就一直存在。

三、简答题（共7题，共40分）

1.请写出一个输出“Hello World！” 的程序。（3分）

答：public Class Hello World

{

Public static void main(String[]args)

{System.out.println(“HELLO WOTLD”)；

}

}

2.char型变量中能不能存贮一个中文汉字? 为什么?（3分）

答：能存储一个汉字；因为它能存储四个字节而每个汉字只占两个字节。

3.常见的两种xml解析技术是什么? 区别是什么?（4分）

答：常见的两种有：SAX和DOM。

区别：SAX 是一种事件驱动的xml解析方式。每次访问一个xml文件中的某个节点的时候，sax就会搜索一遍xml文件，在找到相应的节点后就会触发一个事件来处理请求。只读

DOM是一种基于树状的查找方式。DOM会将xml解析成一棵树，存在内存中。开发者可以通过查找树的节点来取得文件的内容或者修改内容。可读写

4.MVC是什么，如何实现?（5分）

答：MVC是一个是一个设计模式，它强制性的使应用程序的输入，处理和输出分开。

使用MVC应用程序被分为三个核心部件：M----------MODO模型，V----------VIEW试图，C---------Contral控制

实现：首先有页面（jsp）发送请求给控制器(servlet)，然后由控制器接收用户的请求，并决定应该调用哪个模型(javabean)来进行处理，然后模型用业务逻辑来处理用户的请求并返回数据，最后控制器用相应的视图格式化模型返回的数据，并通过表示层显示给用户。

5..J2EE是什么？（6分）

答：J2EE 是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterpriese application model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。

6.jsp有哪些内置对象?作用分别是什么?（9分）

答：1.request 用户端请求，此请求会包含来自GET/POST请求的参数；2.response 网页传回用户端的回应；3.pageContext 网页的属性是在这里管理；4.session 与请求有关的会话期；5.application servlet 正在执行的内容；6.out 用来传送回应的输出；7.config servlet的构架部件；8.page JSP网页本身；9.exception 针对错误网页，未捕捉的例外

7.作用域public,private,protected,以及不写时的区别 ？（10分）

答：作用域当前类同一package子孙类其他package

public√√√√

protected√√√×

friendly√√××

private√×××

不写时默认为friendly

四、编码及论述题（共2题，每题10分，共20分）

1.什么是Singleton，它的作用是什么，它有几种形式？请用代码写出一个Singleton类。

答：Java Singleton 模式用来保证在运行的应用程序中，一个Class只是实例化一次，也就是只有一个相应的对象存在。

它有三种形式

public class Singleton

{

private static Singleton instance = null;

public static synchronized Singleton getInstance()

{

if(instance==null)

instance＝new Singleton();

return instance;

}

}

2.在Struts + Spring + Hibernate的组合框架模式中，三者各自的特点都是什么？答：StrtusWEB层Spring是业务层Hiebenate是持久化层

篇2：java程序员经典笔试题

java程序员笔试题

JAVA 程序员笔试题

时间：30分钟

试题一：

简单描述一下什么是事务管理，事务管理中有哪些语句？

姓名：

试题二：

跳出当前循环的关键词是什么？继续本次循环的关键词是什么？

试题三：

在JSP页面源代码中写 “${flag}”是代表什么意思？

试题四：

请写出最少五种设计模式的名称。

试题五：

请写出Eclipse 中下列功能的快捷键： 删除当前行： 注释当前行：

代码助手完成一些代码的插入： 打开类型： 打开资源：

试题六：

什么情况下Eclipse不编译生成Class文件？

深圳市九城恩科软件技术有限公司

java程序员笔试题

试题七：

public static void main(String[] args){

int i=3,j=16;do{ if(++i>=j--)continue;}while(i<9);System.out.println(“i=”+i+“;j=”+j);} 这段程序运行后输出的结果是什么？

试题八：

public class One {

} public class Two extends One {

} protected void printA(){System.out.println(“two A”);} private void printB(){System.out.println(“two B”);} public static void main(String[] args){ Two t = new Two();t.printAB();} protected void printA(){System.out.println(“one A”);} private void printB(){System.out.println(“one B”);} protected void printAB(){printA();printB();} 这段程序运行后输出的结果是什么？

试题九：

有一个表 “表A” 中包含 “姓名”，“成绩”两个字段，请写一个SQL语句查询出“成绩”大于60分的，“姓名”有重复的人的名字

试题十：

篇3：关于Java程序笔试题

闰年特点：

①、普通年能被4整除;且不能被100整除的为闰年。(如就是闰年,19不是闰年)

②、世纪年能被400整除的是闰年。(如是闰年，19不是闰年) ③、对于数值很大的年份,既能整除3200，又能整除172800是闰年。如172800年是闰年，86400年不是闰年(因为虽然能整除3200，但不能整除172800)。

2、编写一个Java程序在屏幕上输出1!+2!+3!+??+10!的和。

3、打印出所有的 “水仙花数 ”，所谓 “水仙花数 ”是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 “水仙花数 ”，因为153=1的三次方+5的三次方+3的三次方。

4、利用递归方法求5!。

5、一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

6、编写一个Java应用程序，要求如下

1)从控制台输入两个字符串;

2)重载三个方法，方法名add，分别完成字符串拼接、整数相加、浮点数相加，返回 String，并在控制台分别输出返回结果;

3)要求处理异常，输入字符串不符合要求时给出提示，不能使程序崩溃;

4)输入“esc”时退出程序，否则可以重复执行。

7、、有n个人围成一圈，顺序排号。从第一个人开始报数(从1到3报数)，凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

8、大整数计算器，要求从控制台输入。

(例如：100000000000000000000+0000000000000000)

9、(1)编写一个圆类Circle，该类拥有：

①一个成员变量

Radius(私有，浮点型); // 存放圆的半径;

②两个构造方法

Circle( ) // 将半径设为0

Circle(double r ) //创建Circle对象时将半径初始化为r

③ 三个成员方法

double getArea( ) //获取圆的面积

double getPerimeter( ) //获取圆的周长

void show( ) //将圆的半径、周长、面积输出到屏幕

篇4：Java经典笔试题（含答案）

1. 以下属于面向对象的特征的是(C,D)。(两项)

A) 重载

B) 重写

C) 封装

D) 继承

2. 以下代码运行输出是(C)

public class Person{

private String name=”Person”;

int age=0;

}

public class Child extends Person{

public String grade;

public static void main(String[] args){

Person p = new Child;

System.out.println(p.name);

}

}

A) 输出：Person

B) 没有输出

C) 编译出错

D) 运行出错

3. 在使用super 和this关键字时，以下描述正确的是(A)

A) 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过

B) super()和this()不一定要放在构造方法内第一行

C) this()和super()可以同时出现在一个构造函数中

D) this()和super()可以在static环境中使用，包括static方法和static语句块

4. 以下对封装的描述正确的是(D)

A) 只能对一个类中的方法进行封装，不能对属性进行封装

B) 如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用

C) 封装的意义不大，因此在编码时尽量不要使用

D) 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

5. 以下对继承的描述错误的是(A)

A) Java中的继承允许一个子类继承多个父类

B) 父类更具有通用性，子类更具体

C) Java中的继承存在着传递性

D) 当实例化子类时会递归调用父类中的构造方法

6. 以下程序的运行结果是(D)

class Person{

public Person(){

System.out.println(“this is a Person”);

}

}

public class Teacher extends Person{

private String name=”tom”;

public Teacher(){

System.out.println(“this is a teacher”);

super();

}

public static void main(String[] args){

Teacher teacher = new Teacher();

System.out.println(this.name);

}

}

A) this is a Person

this is a teacher

tom

B) this is a teacher

this is a Person

tom

C) 运行出错

D) 编译有两处错误

7. 以下说法错误的是()

A) super.方法()可以调用父类的所有非私有方法

B) super()可以调用父类的所有非私有构造函数

C) super.属性可以调用父类的所有非私有属性

D) this和super关键字可以出现在同一个构造函数中

8. 以下关于final关键字说法错误的是(A,C)(两项)

A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性

B) final修饰的类肯定不能被继承

C) final修饰的方法不能被重载

D) final修饰的变量不允许被再次赋值

9. 访问修饰符作用范围由大到小是(D)

A) private-default-protected-public

B) public-default-protected-private

C) private-protected-default-public

D) public-protected-default-private

10. 以下(D)不是Object类的方法

A) clone()

B) finalize()

C) toString()

D) hasNext()

11. 多态的表现形式有(A)

A) 重写

B) 抽象

C) 继承

D) 封装

12. 以下对重载描述错误的是(B)

A) 方法重载只能发生在一个类的内部

B) 构造方法不能重载

C) 重载要求方法名相同，参数列表不同

D) 方法的返回值类型不是区分方法重载的条件

13. 以下(D)添加到ComputerBook中不会出错

class Book{

protected int getPrice(){

return 30;

}

}

public class ComputerBook extends Book{

}

A) protected float getPrice(){}

B) protected int getPrice(int page){}

C) int getPrice(){}

D) public int getPrice(){return 10;}

14. 以下对抽象类的描述正确的是(C)

A) 抽象类没有构造方法

B) 抽象类必须提供抽象方法

C) 有抽象方法的类一定是抽象类

D) 抽象类可以通过new关键字直接实例化

15. 以下对接口描述错误的有(D)

A) 接口没有提供构造方法

B) 接口中的方法默认使用public、abstract修饰

C) 接口中的属性默认使用public、static、final修饰

D) 接口不允许多继承

16. 以下代码，描述正确的有(A)

interface IDemo{

public static final String name; 1

void print(); 2

public void getInfo(); 3

}

abstract class Person implements IDemo{ 4

public void print(){

}

}

A) 第1行错误，没有给变量赋值

B) 第2行错误，方法没有修饰符

C) 第4行错误，没有实现接口的全部方法

D) 第3行错误，没有方法的实现

17. 接口和抽象类描述正确的有(B,C)(两项)

A) 抽象类没有构造函数

B) 接口没有构造函数

C) 抽象类不允许多继承

D) 接口中的方法可以有方法体

18. 以下描述错误的有(C)

A) abstract 可以修饰类、接口、方法

B) abstract修饰的类主要用于被继承

C) abstract 可以修饰变量

D) abstract修饰的类，其子类也可以是abstract修饰的

19. 以下描述正确的有(B)

A) 方法的重写应用在一个类的内部

B) 方法的重载与返回值类型无关

C) 构造方法不能重载

D) 构造方法可以重写

20. 以下程序运行结果是(A)

public class Test extends Father{

private String name=”test”;

public static void main(String[] args){

Test test = new Test();

System.out.println(test.getName());

}

}

class Father{

private String name=”father”;

public String getName() {

return name;

}

}

A) father

B) test

C) 编译出错

D) 运行出错，无输出

21. 以下对异常的描述不正确的有(C)

A) 异常分为Error和Exception

B) Throwable是所有异常类的父类

C) Exception是所有异常类父类

D) Exception包括RuntimeException和RuntimeException之外的异常

22. 在try-catch-finally语句块中，以下可以单独与finally一起使用的是(B)

A) catch

B) try

C) throws

D) throw

23. 下面代码运行结果是(B)

public class Demo{

public int add(int a,int b){

try{

return a+b;

}catch(Exception e){

System.out.println(“catch 语句块”);

}finally{

System.out.println(“finally 语句块”);

}

return 0;

}

public static void main(String[] args){

Demo demo = new Demo();

System.out.println(“和是：”+demo.add(9,34));

}

}

A) 编译异常

B) finally语句块 和是：43

C) 和是：43 finally语句块

D) catch语句块 和是：43

24. 以下描述不正确的有(D)

A) try块不可以省略

B) 可以使用多重catch块

C) finally块可以省略

D) catch块和finally块可以同时省略

25. 以下对自定义异常描述正确的是(C)

A) 自定义异常必须继承Exception

B) 自定义异常可以继承自Error

C) 自定义异常可以更加明确定位异常出错的位置和给出详细出错信息

D) 程序中已经提供了丰富的异常类，使用自定义异常没有意义

26. 以下程序运行结果是(D)

public class Test {

public int div(int a, int b) {

try {

return a / b;

}catch(Exception e){

System.out.println(“Exception”);

}catch(NullPointerException e){

System.out.println(“ArithmeticException”);

}

catch (ArithmeticException e) {

System.out.println(“ArithmeticException”);

} finally {

System.out.println(“finally”);

}

return 0;

}

public static void main(String[] args) {

Test demo = new Test();

System.out.println(“商是：” + demo.div(9, 0));

}

}

A) Exception finally 商是：0

B) ArithmeticException finally 商是：0

C) finally商是：0

D) 编译报错

27. 以下对TCP和UDP描述正确的是(D)

A) TCP不能提供数据的可靠性

B) UDP能够保证数据库的可靠性

C) TCP数据传输效率高于UDP

D) UDP数据传输效率高于TCP

28. 在Java中，下面对于构造函数的描述正确的是(D)。(选择一项)

A) 类必须显示定义构造函数

B) 构造函数的返回类型是void

C) 构造函数和类有相同的名称，并且不能带任何参数

D) 一个类可以定义多个构造函数

29. 根据下面的代码，

String s = null;

会抛出NullPointerException异常的有(A,C)。[两项]

A) if( (s!=null) & (s.length()>0) )

B) if( (s!=null) & & (s.length()>0) )

C) if( (s==null) | (s.length()==0) )

D) if( (s==null) || (s.length()==0) )

30. .在Java中，关于HashMap类的描述，以下廉洁错误的是( B )。

A) HashMap使用键/值得形式保存数据

B) HashMap 能够保证其中元素的顺序

C) HashMap允许将null用作键

D) HashMap允许将null用作值

31. 下列选项中关于java中super关键字的说法错误的是( B )

A) super关键字是在子类对象内部指代其父类对象的引用

B) super关键字不仅可以指代子类的直接父类，还可以指代父类的父类

C) 子类可以通过super关键字调用父类的方法

D) 子类可以通过super关键字调用父类的属性

32. 在Java中，以下代码( A )正确地创建了一个InputStreamReader对象。

A) InuptStreamReader(new FileInputStream(“1.dat”));

B) InuptStreamReader(new FileReader(“1.dat”));

C) InuptStreamReader(new BufferReader(“1.dat”));

D) InuptStreamReader (“1.dat”);

33. 在Java中，( D )类提供定位本地文件系统，对文件或目录及其属性进行基本操作。

A) FileInputStream

B) FileReader

C) FileWriter

D) File

34. Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述错误的是(C)(选择一项)

A) ArrayList和LinkedList均实现了List接口

B) ArrayList的访问速度比LinkedList快

C) 添加和删除元素时，ArrayList的表现更佳

D) HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

35. 在Java中开发JDBC应用程序时，使用DriverManager类的getConnection()方法建立与数据源的连接语句为：

Connection con = DriverManager.getConnection(“jdbc:odbc:news”);

URL连接中的“news”表示的是(C)(选择一项)

A) 数据库中表的名称

B) 数据库服务器的机器名

C) 数据源的名称

D) 用户名

36. 在Java中,JDBCAPI定义了一组用于与数据库进行通信的接口和类，它们包括在(B)包中。

A) java.lang

B) java.sql

C) java.util

D) java.math

37. Java中，以下( B )接口以键_值对的方式存储对象。

A) java.util.Collection

B) java.util.Map

C) java.util.List

D) java.util.Set

38. 以下关于对象序列化描述正确的是( C,D )[两项]

A) 使用FileOutputStream可以将对象进行传输

B) 使用PrintWriter可以将对象进行传输

C) 使用ObjectOutputStream类完成对象存储，使用ObjectInputStream类完成对象读取

D) 对象序列化的所属类需要实现Serializable接口

39. 在Java中，( A )类可用于创建链表数据结构的对象。

A) LinkedList

B) ArrayList

C) Collection

D) HashMap

40. 分析下面这段Java代码，它的运行结果是( C )。

import java.io.*;

public class B{

public static void main(string [] args){

int i=12;

System.out.println(i+=i-=i*=i);

}

}

A) 100

B) 0

C) -120

D) 程序无法编译

41. 使用JDBC事务的步骤是(C,A,B,D)(多选)

A) 取消Connection的事务自动提交方式

B) 发生异常回滚事务

C) 获取Connection对象

D) 操作完毕提交事务

42. 以下对JDBC事务描述错误的是( B )

A) JDBC事务属于JAVA事务的一种

B) JDBC事务属于容器事务类型

C) JDBC事务可以保证操作的完整性和一致性

D) JDBC事务是由Connection发起的，并由Connection控制

43. 要通过可滚动的结果集更新数据，以下正确的是(A

A) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE)

B) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY)

C) pst=con.prepareStatement(sql, Resu ltSet.TYPE_SCROLL_SENSITIVE)

D) pst=con.prepareStatement(sql, ResultSet.CONCUR_UPDATABLE)

44. 存储过程pro有两个参数，第一个为输入参数，第二个为输出参数，以下代码正确的是(C)

A) CallableStatement cst=con.prepareCall(“(call pro(?,?))”);

B) CallableStatement cst=con.prepareCall(“(call pro(?))”);

C) CallableStatement cst=con.prepareCall(“{call pro(?,?)}”);

D) CallableStatement cst=con.prepareCall(“{call pro(?,?,?)}”);

45. 以下描述正确的是(B)

A) CallableStatement是PreparedStatement的父接口

B) PreparedStatement是CallableStatement的父接口

C) CallableStatement是Statement的子接口

D) PreparedStatement是Statement的父接口

46. 要删除book表中书籍(bookName)是”java”的记录，以下代码正确的是(A)

String sql=”delete from book where bookName=?”;

PreparedStatement pst=con.preparedStatement(sql);

pst.execute();

A) pst.setString(1,”java”);

B) pst.setString(0,”java”);

C) pst.setInt(0,”java”);

D) 以上选项都不正确

47. 获取ResutlSet对象rst的第一行数据，以下正确的是(B)

A) rst.hashNext();

B) rst.next();

C) rst.first();

D) rst.nextRow();

48. 以下可以正确获取结果集的有(AD)(多选)

A) Statement sta=con.createStatement();

ResultSet rst=sta.executeQuery(“select * from book”);

B) Statement sta=con.createStatement(“select * from book”);

ResultSet rst=sta.executeQuery();

C) PreparedStatement pst=con.preparedStatement();

ResultSet rst=pst.executeQuery(“select * from book”);

D) PreparedStatement pst=con.preparedStatement(“select * from book”);

ResultSet rst=pst.executeQuery();

49. 以下负责建立与数据库连接的是(D)

A) Statement

B) PreparedStatement

C) ResultSet

D) DriverManager

50. 使用JDBC连接数据库的顺序是(B,A,D,C,E)(多选)

A) 加载驱动

B) 导入驱动包

C) 发送并处理SQL语句

D) 建立于数据库的连接

E 关闭连接

二、简答题(各5分，共25分)

1、在java中如果声明一个类为final，表示什么意思? (不计分)

答：final是最终的意思，final可用于定义变量、方法和类但含义不同，声明为final的类不能被继承。

1、父类的构造方法是否可以被子类覆盖(重写)?

答：父类的构造方法不可以被子类覆盖，因为父类和子类的类名是不可能一样的。

2、请讲述String 和StringBuffer的区别。

答：String 类所定义的对象是用于存放”长度固定”的字符串。

StringBuffer类所定义的对象是用于存放”长度可变动”的字符串。

3、如果有两个类A、B(注意不是接口)，你想同时使用这两个类的功能，那么你会如何编写这个C类呢?

答：因为类A、B不是接口，所以是不可以直接继承的，但可以将A、B类定义成父子类，那么C类就能实现A、B类的功能了。假如A为B的父类，B为C的父类，此时C就能实现A、B的功能。

4、分析sleep()和wait()方法的区别。

答： sleep睡眠的意思 : sleep() 方法用来暂时中止执行的线程。在睡眠后，线程将进入就绪状态。

wait等待的意思: 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。

5、谈谈你对抽象类和接口的理解。

答：定义抽象类的目的是提供可由其子类共享的一般形式、子类可以根据自身需要扩展抽象类、抽象类不能实例化、抽象方法没有函数体、抽象方法必须在子类中给出具体实现。他使用extends来继承。

篇5：java笔试题

1.java是从( )语言改进重新设计， a.ada b.c c.pasacal d.basic 答案：b

2.下列语句哪一个正确( ) a. java程序经编译后会产生machine code b. java程序经编译后会产生byte code c. java程序经编译后会产生dll d. 以上都不正确 答案：b

3.下列说法正确的有( ) a. class中的constructor不可省略 b. constructor必须与class同名，但方法不能与class同名 c. constructor在一个对象被new时执行 d. 一个class只能定义一个constructor 答案：c

4.提供java存取数据库能力的包是( ) a.java.sql b.java.awt c.java.lang d.java.swing 答案：a

5.下列运算符合法的是( ) a.& b. c.if d.:= 答案：a

6.执行如下程序代码 a=0;c=0; do{ --c; a=a-1; }while(a>0); 后，c的值是( ) a.0 b.1 c.-1 d.死循环 答案：c

7.下列哪一种叙述是正确的( ) a. abstract修饰符可修饰字段、方法和类 b. 抽象方法的body部分必须用一对大括号{ }包住 c. 声明抽象方法，大括号可有可无 d. 声明抽象方法不可写出大括号 答案：d

8.下列语句正确的是( ) a. 形式参数可被视为local variable b. 形式参数可被字段修饰符修饰 c. 形式参数为方法被调用时，真正被传递的参数 d. 形式参数不可以是对象 答案：a

9.下列哪种说法是正确的( ) a. 实例方法可直接调用超类的实例方法 b. 实例方法可直接调用超类的类方法 c. 实例方法可直接调用其他类的实例方法 d. 实例方法可直接调用本类的类方法 答案：d

二、多项选择题

1.java程序的`种类有( ) a.类(class) b.applet c.application d.servlet

2.下列说法正确的有( ) a. 环境变量可在编译source code时指定 b. 在编译程序时，所能指定的环境变量不包括class path c. javac一次可同时编译数个java源文件 d. javac.exe能指定编译结果要置于哪个目录(directory) 答案：bcd

3.下列标识符不合法的有( ) a.new b.$usdollars c.1234 d.car.taxi 答案：acd

4.下列说法错误的有( ) a. 数组是一种对象 b. 数组属于一种原生类 c. int number=[]={31,23,33,43,35,63} d. 数组的大小可以任意改变 答案：bcd

篇6：JAVA笔试题汇

1.笼统：

笼统即便疏忽一个主题中与目前目标无关的那些方面，以便更富余地当心与目前目标有关的方面，笼统并不计划打听全副问题，而只是抉择其中的一局部，临时无须局部细节。笼统包括两个方面，一是过程笼统，二是数据笼统。

2.继承：

继承是一种联合类的层次模型，并且批准和激励类的重用，它供给了一种确定表述共性的措施。对象的一个新类能够从现有的类中派生，这个过程称为类继承。新类继承了原始类的个性，新类称为原始类的`派生类(子类)，而原始类称为新类的基类(父类)。派生类能够从它的基类那里继承措施和实例变量，并且类能够修正或添置新的措施使之更合乎特异的必需。

3.封装：

封装是把过程和数据包围起来，对数据的拜会只能穿越既定义的界面。面向对象计算始于这个大约观念，即切实世界能够被描摹成一系列全面自治、封装的对象，这些对象穿越一个受防御的接口拜会其他对象。

4. 多态性：

多态性是指批准不同类的对象对统一消息作出响应。多态性包括参数化多态性和包括多态性，

多态性语言具有灵便、笼统、行动分享、代码分享的优势，很好的处理了利用过程函数同名问题。

5、String是最大约的数据种类吗?

大约数据种类包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final种类的，因而不能够继承这个类、不能修正这个类。为了长进效率勤俭空间，我们该当用StringBuffer类

6、int 和 Integer 有什么差异

Java 供给两种不同的种类：引用种类和原始种类(或内置种类)。Int是java的原始数据种类，Integer是java为int供给的封装类。Java为每个原始种类供给了封装类。

原始种类 封装类

boolean Boolean

char Character

byte Byte

short Short

int Integer

long Long

float Float

double Double

篇7：Android Java笔试题

Final是修饰符 表示类不能被继承 方法不能被重载，重写 变量不能被修改等

Finally是异常处理时的一个无论如何都会被执行的程序块

Finaliz方法是垃圾收集器删除对象之前对这个对象调用的进行清理工作的方法

2、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

可以

3、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

值传递

作用域public,private,protected,以及不写时的区别

用最有效率的方法算出2乘以8等於几 2《3

运行时异常与一般异常有何异

编译器要求声明并抛出一般异常 但不必声明抛出运行时异常 由系统处理

垃圾回收的优点和原理。并考虑2种回收机制

回收机制有分代复制垃圾回收 标记垃圾回收 和增量垃圾回收

4、描述一下JVM加载class文件的原理机制?

篇8：常见java应聘笔试题

1. Java中sleep和wait的区别

① 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源;wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

synchronized(x){ x.notify() //或者wait() }

2. Java中HashMap和HashTable的区别

① 历史原因: Hashtable是给予陈旧的Dictonary类的, HashMap是Java1.2引进的Map接口的一个实现

② HashMap允许空的键值对, 而HashTable不允许

③ HashTable同步，而HashMap非同步，效率上比HashTable要高

3. 请简述在异常当中，throw和throws有什么区别

① throw代表动作，表示抛出一个异常的动作;throws代表一种状态，代表方法可能有异常抛出

② throw用在方法实现中，而throws用在方法声明中

③ throw只能用于抛出一种异常，而throws可以抛出多个异常

4. 内存溢出和内存泄露的区别

内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory;比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。

内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。

memory leak会最终会导致out of memory!

内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。

内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还()，结果你申请到的那块内存你自己也不能再访问(也许你把它的地址给弄丢了)，而系统也不能再次将它分配给需要的程序。一个盘子用尽各种方法只能装4个果子，你装了5个，结果掉倒地上不能吃了。这就是溢出!比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出。

以发生的方式来分类，内存泄漏可以分为4类：

① 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。

② 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。

③ 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。

④ 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。

从用户使用程序的角度来看，内存泄漏本身不会产生什么危害，作为一般的用户，根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积，这会最终消耗尽系统所有的内存。从这个角度来说，一次性内存泄漏并没有什么危害，因为它不会堆积，而隐式内存泄漏危害性则非常大，因为较之于常发性和偶发性内存泄漏它更难被检测到。

5. String，StringBuffer 和 StringBuilder的区别

①可变与不可变

String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。

private final char value[];

StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。

char[] value;

②是否多线程安全

String中的对象是不可变的，也就可以理解为常量，显然线程安全。

AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、、indexOf等公共方法。

StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：

public synchronized StringBuffer reverse() { super.reverse(); return this; } public int indexOf(String str) { return indexOf(str, 0); //存在 public synchronized int indexOf(String str, int fromIndex) 方法 }

StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

③StringBuilder与StringBuffer共同点

StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。

抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法;而接口中只是对方法的申明和常量的定义。

StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。

6. 数组和链表的区别

二者都属于一种数据结构

从逻辑结构来看：

① 数组必须事先定义固定的长度(元素个数)，不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数;当数据减少时，造成内存浪费;数组可以根据下标直接存取。

② 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。(数组中插入、删除数据项时，需要移动其它数据项，非常繁琐)链表必须根据next指针找到下一个元素。

从内存存储来看：

①(静态)数组从栈中分配空间，对于程序员方便快速,但是自由度小。

②链表从堆中分配空间，自由度大但是申请管理比较麻烦。

从上面的比较可以看出，如果需要快速访问数据，很少或不插入和删除元素，就应该用数组;相反，如果需要经常插入和删除元素就需要用链表数据结构了。

7. ArrayList和LinkedList的区别

①ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

②对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

③对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

篇9：JAVA软件开发笔试题

对日java软件开发工程师笔试题

1:设int a=10, b=20, c=30;条件表达式a

A.5

B.10

C.20

D.30

2:对 do-whie 语言 错误 的说法是

A.可构成多重循环结构

B.循环次数不可能为 0

C.循环次数可能为 0

D.先执行后判断

3:调用函数时，若实参是一个数组名，则向函数对应的`形参传送的是

A.数组的长度

B.数组的首地址

C.数组第一个元素的值

D.整个数组元素的值

4:C语言中，″x3d″在内存中占用的字节数是

A.1

B.2

C.4

D.5

5:若定义了( )

union

{ char a[10];

short b[4][5];

long c[5];

篇10：JAVA和数据库笔试题

一个是final修饰的方法不能被Overload还是Override或者都可以或者都不能?

5.接口和抽象方法的区别，不是让写不同之处，是看代码中那个是错误的.，这个题也考extends和implement;

6.set list map区别

填空题：

1.java中提供对象比较的两个接口：(这个我没填上，记得最清楚了)

2.面向对象的特性：继承 封装 多态

3.11&12的值：8 (按位与运算)

编程：(给了一个表格，每种车有name、price、kind属性，然后有三辆车)编写一个抽象类Car，属性有name、price、kind;编写两个类(kind不同)分别继承Car，又有各自的计算初始折价率的方法(题目的意思是不同类型的车price*0.1，price*0.15);编写一个方法可以比较两种车的初始折旧率;写一个算法按初始折旧率升序排序;

数据库：

选择：

1.事务的特性考了一下下;

2.DML、DDL、DCL那个最重要

3.为了提高数据查询效率一般干什么事? 索引

4.删除表的语句

填空：

1.事务显式提交的命令是 ，事务回退的命令是 。

2.查询时匹配用 % _ ;只能对String数据类型起作用;

3.游标用法步骤：定义游标、后面三个空;

编程：

有一个职工表employee(eno,ename,esex，deptno,sal)，其中eno代表职工号，数值型(整数)，长度为8，eno为student表的主键;ename代表职工姓名，字符型，长度为10;esex代表性别，取值仅为“男”或者“女”;deptno代表部门号，数值型(整数)，非空，长度为6;sal是工资(大概是这样)

1) ：创建表

2)：查询性张得员工

3)：查询每个部门员工的人数

4)：工资不等于1000的员工的人数

篇11：java程序员经典笔试题

本题主要考查了选项中出现的几种树的结构特点。对于选项A，根据二叉排序树的结构特点我们可以知道，二叉排序树的中序遍历结果是一个有序序列，而在中序遍历中，父结点并不总是出现在孩子结点的前面（或后面），故该选项不正确。例如我们用关键字5,2,3建立一棵二叉排序树，则从结点3出发到根的路径上所经过的结点序列为3,2,5，并不是一个有序的序列。对于选项B，赫夫曼树在后续的章节中会介绍，根据赫夫曼树的结构特点我们可以知道，在赫夫曼树中所有的关键字只出现在叶结点上，其非叶结点上并没有关键字值，显然不正确。对于选项C，AVL树其本质上也是一种二叉排序树，只不过是平衡化之后的二叉排序树，故该选项也是不正确的。例如我们用序列5,1,8,6,9建立一棵AVL树，从结点6出发到根的路径上所经过的结点序列为6,8,5，也不是一个有序的序列。对于选项D，堆的概念我们会在堆排序中给大家介绍，根据建堆的过程，不断地把大者“上浮”，将小者“筛选”下去，最终得到的正是一个从任一结点出发到根的路径上所经过的结点序列按其关键字有序的树状结构，故D是正确的。本题中的A和C同时出现，没有起到干扰的作用，因为AVL树和二叉排序树只是在平衡性上有区别，在结点的排列方式上没有区别。

下面关于线程的叙述中，正确的是()。正确答案: C 你的答案: D(错误)不论是系统支持线程还是用户级线程，其切换都需要内核的支持 线程是资源的分配单位，进程是调度和分配的单位 不管系统中是否有线程，进程都是拥有资源的独立单位 在引入线程的系统中，进程仍是资源分配和调度分派的基本单位 A：用户级线程，切换时不需要内核的支持

B：线程是资源调度和分配的单位，进程是资源拥有的单位 C:对

D：引入线程后，线程才是资源分配和调度分派的基本单位

在引入线程前，进程的两个基本属性是：1.可拥有资源的独立单位。2.可独立调度和分配的基本单位。

后来为了使多个程序更好的并发执行，人们把上述两个属性分开，引入线程作为可独立调度和分配的基本单位。

一条tcp连接，主动关闭的一方不可能出现的连接状态是()正确答案: A 你的答案: A(正确)CLOSE_WAIT FIN_WAIT2 TIME_WAIT FIN_WAIT1

1）当客户端没有主动close的时候就断开连接，即客户端发送的fin丢失或者失败： 1：这时候若客户端断开的时候发送了FIN包，则服务端将会处于CLOSE_WAIT状态；2：

这时候若客户端断开的时候未发送FIN包，则服务端处还是显示ESTABLISHED状态

2）当client想要关闭它与server之间的连接。client（某个应用进程）首先调用 close 主动关闭连接，这时TCP发送一个FIN M；client端处于 FIN_WAIT1 状态。

3）当server端接收到FIN M之后，执行被动关闭。对这个FIN进行确认，返回给client ACK。当server端返回给client ACK后，client处于 FIN_WAIT2 状态，server处于 CLOSE_WAIT 状态。它的接收也作为文件结束符传递给应用进程，因为FIN的接收

意味着应用进程在相应的连接上再也接收不到额外数据； 4）一段时间之后，当server端检测到client端的关闭操作(read返回为0)。接收到文件结束符的server端调用close 关闭它的socket。这导致server端的TCP也发送一个FIN N；此时server的状态为last——ack.5）当client收到来自server的FIN后。client端的套接字处于 TIME_WAIT 状态，它会向server端再发送一个ack确认，此时server端收到ack确认后，此套接字处于CLOSED状态。

介绍一下TCP连接建立与关闭过程中的状态。TCP连接过程是状态的转换，促使状态发生转换的因素包括用户调用、特定数据包以及超时等，具体状态如下所示：

1.CLOSED ：初始状态，表示没有任何连接。

2.LISTEN ： Server 端的某个 Socket 正在监听来自远方的 TCP 端口的连接请求。

3.SYN_SENT ：发送连接请求后等待确认信息。当客户端 Socket 进行 Connect 连接时，会首先发送 SYN 包，随即进入 SYN_SENT 状态，然后等待 Server 端发送三次握手中的第 2 个包。

4.SYN_RECEIVED ：收到一个连接请求后回送确认信息和对等的连接请求，然后等待确认信息。通常是建立TCP 连接的三次握手过程中的一个中间状态，表示 Server 端的 Socket 接收到来自 Client 的 SYN 包，并作出回应。ESTABLISHED ：表示连接已经建立，可以进行数据传输。

5.FIN_WAIT_1 ：主动关闭连接的一方等待对方返回 ACK 包。若 Socket 在 ESTABLISHED 状态下主动关闭连接并向对方发送 FIN 包（表示己方不再有数据需要发送），则进入 FIN_WAIT_1 状态，等待对方返回 ACK包，此后还能读取数据，但不能发送数据。在正常情况下，无论对方处于何种状态，都应该马上返回 ACK包，所以 FIN_WAIT_1 状态一般很难见到。

6.FIN_WAIT_2 ：主动关闭连接的一方收到对方返回的 ACK 包后，等待对方发送 FIN 包。处于 FIN_WAIT_1 状态下的 Socket 收到了对方返回的 ACK 包后，便进入 FIN_WAIT_2 状态。由于 FIN_WAIT_2 状态下的 Socket需要等待对方发送的 FIN 包，所有常常可以看到。若在 FIN_WAIT_1 状态下收到对方发送的同时带有 FIN 和ACK 的包时，则直接进入 TIME_WAIT 状态，无须经过 FIN_WAIT_2 状态。

7.TIME_WAIT ：主动关闭连接的一方收到对方发送的 FIN 包后返回 ACK 包（表示对方也不再有数据需要发送，此后不能再读取或发送数据），然后等待足够长的时间（2MSL）以确保对方接收到 ACK 包（考虑到丢失 ACK 包的可能和迷路重复数据包的影响），最后回到 CLOSED 状态，释放网络资源。8.CLOSE_WAIT ：表示被动关闭连接的一方在等待关闭连接。当收到对方发送的 FIN 包后（表示对方不再有数据需要发送），相应的返回 ACK 包，然后进入 CLOSE_WAIT 状态。在该状态下，若己方还有数据未发送，则可以继续向对方进行发送，但不能再读取数据，直到数据发送完毕。

9.LAST_ACK ：被动关闭连接的一方在 CLOSE_WAIT 状态下完成数据的发送后便可向对方发送 FIN 包（表示己方不再有数据需要发送），然后等待对方返回 ACK 包。收到 ACK 包后便回到 CLOSED 状态，释放网络资源。10.CLOSING ：比较罕见的例外状态。正常情况下，发送 FIN 包后应该先收到（或同时收到）对方的 ACK 包，再收到对方的 FIN 包，而 CLOSING 状态表示发送 FIN 包后并没有收到对方的 ACK 包，却已收到了对方的FIN 包。有两种情况可能导致这种状态：其一，如果双方几乎在同时关闭连接，那么就可能出现双方同时发送FIN 包的情况；其二，如果 ACK 包丢失而对方的 FIN 包很快发出，也会出现 FIN 先于 ACK 到达。11.数据库恢复的基础是利用转储的冗余数据。这些转储的冗余数据包括（）

12.正确答案: D 你的答案: A(错误)13.数据字典，应用程序，审计档案，数据库后备副本 14.数据字典，应用程序，审计档案，日志文件 15.数据字典，应用程序，数据库后备副本 16.日志文件，数据库后备副本

17.题目说的是转储，转储只需要日志文件和后备数据就可以了 18.数据字典只是用来定义数据库，应用程序也是一个道理....19.进程依靠()从阻塞状态过渡到就绪状态。20.正确答案: D 你的答案: D(正确)21.程序员的命令 22.系统服务

23.等待下一个时间片到来 24.“合作”进程的唤醒

25.引起进程阻塞和唤醒的事件：

26.1、向系统请求共享资源失败。进程转变为阻塞状态。27.2、等待某种操作完成。比如进程启动了I/O设备，必须等I/O操作完成后，进程才能继续。

28.3、新数据尚未到达。对于合作的进程，如果一个进程A需要先获得另一进程B提供的数据后，才能对该数据进程处理，只要数据尚未到达，进程A只能阻塞。当进程B提供数据后，便可以去唤醒进程A。

29.4、等待新任务到达，用于特定的系统进程。它们每当完成任务后，就把自己阻塞起来，等待新任务。30.1.什么是正则表达式的贪婪与非贪婪匹配 31.如：String str=“abcaxc”;32.Patter p=“ab*c”;33.贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(ab*c)。

34.非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab*c)。35.2.编程中如何区分两种模式

36.默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。

37.量词：{m,n}：m到n个 38.*：任意多个 39.+：一个到多个 40.？：0或一个

41.以上来自博主的博客，然后这道题目 42..表示除n之外的任意字符 43.*表示匹配0-无穷

+表示匹配1-无穷

44.(?=Expression)顺序环视，(?=()就是匹配正括号 45.懒惰模式正则：

src=“.*?(?=()）” 46.结果：北京市

47.因为匹配到第一个“就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。

A ”.*?(?=()“

B ”.*?(?=()“ C ”.*(?=()“ D ”.*(?=()“ 前面的.*?是非贪婪匹配的意思，表示找到最小的就可以了(?=Expression)顺序环视，(?=()就是匹配正括号

String text = ”北京市(海淀区)(朝阳区)(西城区)“;Pattern pattern = Pattern.compile(”.*?(?=()“);Matcher matcher = pattern.matcher(text);if(matcher.find()){ System.out.println(matcher.group(0));} 10.下面这个题不能再做了！！classB extendsObject {

static

{

System.out.println(”Load B“);

} classA {

} } publicB(){

System.out.println(”Create B“);} extendsB static {

System.out.println(”Load A“);} publicA(){

System.out.println(”Create A“);}

publicclassTestclass {

publicstaticvoidmain(String[] args)

{

newA();

} }。。。。。。。。。。

Load B->Create B->Load A-> Create A Load B-> Load A->Create B->Create A Load B-> Create B-> Create A-> Load A Create B->Create A->Load B->Load A 执行顺序：

父类静态代码块-》子类静态代码块-》父类构造代码块-》父类构造函数-》子类构造代码块-》子类构造函数

11.下列有关Servlet的生命周期，说法不正确的是？ 正确答案: A 你的答案: A(正确)

在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例 在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法

在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源 destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法

Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。

(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet(2)创建：通过调用servlet构造函数创建一个servlet对象(3)初始化：调用init方法初始化

(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求

(5)卸载：调用destroy方法让servlet自己释放其占用的资源

12.下面有关JAVA swing的描述，说法错误的是？ 正确答案: C 你的答案: A(错误)

Swing是一个基于Java的跨平台MVC框架。使用单线程模式。Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的

Swing优化了AWT，运行速度比AWT快 Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的。

Swing是一个用于开发Java应用程序用户界面的开发工具包。它以抽象窗口工具包（AWT）为基础使跨平台应用程序可以使用任何可插拔的外观风格。Swing开发人员只用很少的代码就可以利用Swing丰富、灵活的功能和模块化组件来创建优雅的用户界面。

工具包中所有的包都是以swing作为名称，例如javax.swing,javax.swing.event 用Swing创建图形界面步骤：

（1）导入Swing包

（2）选择界面风格

（3）设置顶层容器

（4）设置按钮和标签

（5）将组件放到容器上

（6）为组件增加边框

（7）处理事件

（8）辅助技术支持 1。导入Swing包

下面语句导入Swing包 importjavax.swing.*;大部分Swing程序用到了AWT的基础底层结构和事件模型,因此需要导入两个包： importjava.awt.*;importjava.awt.event.*;如果图形界面中包括了事件处理，那么还需要导入事件处理包： importjavax.swing.event.*;2.选择界面风格

Swing允许选择程序的图形界面风格常用的有java风格，windows风格等

下面的代码用于选择图形界面风格，这里选择的是跨平台的Java界面风格。

try { UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());} catch(Exception e){ }(3)设置顶层容器

图形界面至少要有一个顶级Swing容器

顶级Swing容器为其它Swing组件在屏幕上的绘制和处理事件提供支持

常用的顶级容器：

JFrame（框架）：表示主程序窗口

JDialog（对话框）：每个JDialog对象表示一个对话框，对话框属于二级窗口

JApplet（小程序）：在浏览器内显示一个小程序界面 一个框架包括边界、菜单栏、工具栏、状态栏，以及中间占主要部分的窗格

窗格也可以看作是一种面板，但它是框架的一个组成部分

组件不会直接放到框架上，而是放在若干个面板上，这些面板再放到窗格上

用框架对象的getContentPane()函数来获得窗格，再调用窗格的add()函数放置面板

public static void main(String[ ]args){JFrame frame=new JFrame(”SwingApplication");JPanel panel1=new JPanel();frame.getContentPane().add(panel1,BorderLayout.CENTER);......//添加其他组件

frame.pack();frame.setVisible(true);}

13.super.getClass().getName()返回：包名+类名

14.以下关于对象序列化描述正确的是 正确答案: C D a.使用FileOutputStream可以将对象进行传输 b.使用PrintWriter可以将对象进行传输 c.使用transient修饰的变量不会被序列化 d.对象序列化的所属类需要实现Serializable接口 …..C和D transient这个单词本身的意思就是瞬时的意思 transient是变量修饰符 变量定义为transient的，序列化时会忽略此字段，所以C是对的，只有实现了Serializable接口的，才可以被序列化.能够对对象进行传输的貌似只有ObjectOutputStream和ObjectInputStream这些以Object开头的流对象。

3、D项继承Seriallizable接口是经常见到的，这毋庸置疑。

4、transient 修饰的变量在对象串化的时侯并不会将所赋值的值保存到传中，串化的对象从磁盘读取出来仍然是null。