应聘Java笔试时可能出现问题

应聘Java笔试时可能出现问题
Java基础方面:
1、作用域public,private,protected,以及不写时的区别
Public、Protected、Private是成员访问修饰符；
final、abstract、transient、synchronized、native、strictfp是非访问成员修饰符。
可见性PublicProtectedDefaultPrivate
同一个类是是是是
同一个包中的类是是是否
同一个包中的子类是是是否
同一包外的子类是是否否
同一包外的非子类是否否否

Java的基本包
java.lang 其中包含有：
接口：Comparable、Cloneable、Runable等
类：八个基本数据类型封装类、Math、Runtime、Object、String、StringBuffer、Thread、Exception等

集合框架
集合是将多个元素组成一个单元的对象。集合用于存储、检索和操纵数据。
集合框架提供管理对象集合的接口和类。它包含几个组件，接口是表示集合的抽象数据类型，用于操纵集合；类是用于存储集合的实际数据对象；算法是用于操纵集合的。

2、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

就HashMap与HashTable主要从三方面来说.
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap允许在一个集合中有一个null键和在一个集合中有多个null值

Hashtable是HashMap的同步版本；HashMap允许有null值和一个null键，但是，Hashtable不允许有任何内容为null

Hashtable类的对象必须覆盖Object类的hashCode()和equals()方法

关于其他集合类型：
一.ArrayList 提供快速遍历和快速访问。现在设计了新的 RandomAccess 接口，它指出这种列表支持快速随机访问。Vector也实现了RandomAccess 接口。
二.遍历HashSet与HashMap时，其顺序是未知的（但添加删除快）。LinkedHashSet和LinkedHashSet是按照元素的插入的顺序遍历的（遍历快）。
三．TreeSet和TreeMap将保证元素按照元素的自然顺序进行排列。也可以使用一个用户自己实现的比较规则。
四、HashSet有一个散列表支持它。它为基本操作提供固定时间性能。TreeSet它确保了排序集将按元素升序，根据自然顺序排序。

Dictionary类
主要用于将关键字转换成值，该类接收一个关键字并返回一个值。Dictionary是一个抽象类，它是H
Hashtable的超类。
Properties类
扩展了Hashtable类，但Properties对象的关键字和值必须是String类型，并能将对象写入一个输出流并保存在一个文件中，然后可以把它读回一个输入流。


如果需要维护和搜索一个部件列表，它们由唯一的字母数字序列号标示，其中的部件是Part类型，这时应该使用哪种集合？如果我们改变需求，你也需要能够按顺序、按它们的序列号打印出部件？
1、应该选择HashMap
2、应该选择TreeMap

3、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify

GC是什么? 为什么要有GC?
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

7、垃圾回收机制,如何优化程序?
当一个对象失去引用或者离开了作用域后，就成为垃圾而被Java运行环境自动清除，清除垃圾就是清除这些对象。
Java垃圾回收机制的特点是：
1、垃圾回收机制自动运行。系统提供一个低优先级的线程来跟踪内存的分配情况。如果发现某个内存单元不再使用，就清除它。
2、何时清除垃圾是不可预期的。
3、垃圾回收机制随JVM的不同而不同。

Java的垃圾搜索器为内存管理器提供一种自动解决方案。缺点是不能完全控制它什么时候执行以及什么时候不执行。
当垃圾搜集器运行时，其目的是查找和删除不能被访问的对象。
垃圾搜集器受JVM控制，JVM决定什么时候运行垃圾搜集器。从Java程序内可以请求JVM运行垃圾搜集器，但是，在任何情况下都无法保证JVM会答应你的请求。JVM通常会在它感到内存减少时运行垃圾搜集器。
垃圾收集器运行时，当它发现一个对象不能被任何活线程访问时，它将认为该对象符合删除条件，它可能在某时删除该对象。
垃圾收集器不能保证有足够的内存，它只能保证可以使用的内存将尽可能被有效的管理。
使对象符合垃圾搜集器搜索条件的情况有：出现空引用、重新为引用变量赋值、隔离引用。

强制执行垃圾搜集：
Runtime对象为直接与虚拟机通信提供一种机制。System类可以调用与其相同的方法。
请求垃圾收集器的最简单的方法是：System.gc();

Javac编译选项？
G产生调试信息
g:none不产生调试信息
verbose输出编译器消息，可以知道程序编译时用到了哪些Java类
Noware编译时不产生警告信息
encoding指出原文件的编码方式
D指定类文件产生的目录
classPath指出用户class文件的路径
sourcePath指出用户源文件路径

9、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?
答：Collection FrameWork如下：
核心接口有：
CollectionSetSorted Set
ListMapSorted Map

Set接口：不允许重复的元素。它对add、equals、hashCode方法增加了限制
SortedSet接口：扩展了Set接口，此接口的元素按升序排序。
List接口：一些集合具有顺序，即在一个项目后添加另一个项目。列表可以有重复元素。提供了ListIterator，允许向前或向后移动元素。
Map接口：将键映射到值得对象。Map不能包含重复键，但可以包含重复值。每个键最多都只能映射到一个值。

核心设计类：
Map 设计Set 设计List 设计
HashMapHashSetArrayList
HashtableLinkedHashSetVector
TreeMapTreeSetLinkedLisk
LinkedHasMap

散列表是最快的数据存储结构，它是一个数组。数据存储在数组中散列函数指定的特定下标。散列函数是一组输入数据和一组整数之间的映射。

集合类和接口层次

Collections是一个类，带有用于处理集合的静态实用方法
Collection是一个接口，带有多数集合常用的方法声明，包括add、remove、contains、size、iterator

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射

集合框架的优点：
提供一组可用的集合接口，可以方便地扩展或改写集合；
接口和算法的可重用性提高了软件的可重用性；
提供了有效的数据结构和算法，减少了编程工作。

10、Java中异常处理机制，事件机制？
事件代表了组件之间的交互。是一种在源对象和监听对象之间，某种状态发生变化的传递机制。
通过事件处理机制，可以让一些组件作为事件源，发出可被组件环境或其它组件接收的事件。这样，不同的组件就可以组合在一起，组件之间通过事件传递进行通信，构成一个应用。
在java中实现事件机制的事件模型由三个部分构成：一个事件对象用于描述事件源的状态变化；一个事件源将会产生事件，提供注册的事件监听器的方法，把事件发送到监听器；事件监听器接收事件通知，实现该事件的监听器接口。

异常实际上是程序中错误导致中断了正常的指令流的一种事件.
Java异常处理用于在方法中能检查出错误但不能处理错误的情况，在这样的方法中将抛出一个异常。如果一个异常与某个catch程序块中的参数匹配，那么就执行该catch块中的代码。指出try catch finally的工作顺序。

运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

事件有哪些？

什么是断言机制？
断言从JDK1.4版开始引入，它让开发期间测试假设，而没有付出为异常编写异常处理程序方面的代价，一旦程序完成开发，并全部部署，假设将从不会发生。
主要作用：因为在开发时对自己的假设非常肯定，所以不想花费时间来编写异常处理代码。断言让在开发期间测试你的假设。
private void method（int num）{
assert(num>=0）;//这里假定参数num是正数，如果不是真的将抛出一个AssertionError错误
useNum(num+x);
}
断言有两种形式：简单和非常简单。
非常简单：
private void doStuff（）{
assert(y>x);
//其他代码
}
简单：
将通过表达式的值向错误跟踪栈中添加更多信息，提供了更多调式帮助信息。
private void doStuff（）{
assert(y>x):”y is ”+y+” x is”+x;
//其他代码
}
运行时启用断言：
java –ea com.geeksanonymous.TestClass

运行时禁用断言：
java –da com.geeksanonymous.TestClass

11、JAVA中的多形与继承？
希望大家补上，谢谢

对象是定义了边界的、与要解决的问题有关的概念或事物。它们用于帮助理解现实世界。
类是拥有相同特性、共同的行为和共同的关系的一组对象。
封装是让开发者有选择地隐藏类中的特性和方法的过程
继承是允许通过重用现有类来构建新类的特性。]
多态性使用同一函数在不同的类上具有不同的行为。Java中的多态性是通过方法的动态绑定实现的。

12、抽象类与接口？
答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 都不能

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
可以继承其他类或完成其他接口，在swing编程中常用此方式。

IO流
字节流：数据在存储时与传输时都是以字节为单位进行的。通常用于读写二进制数据，如图像和声音文件。
字符流：数据在存储与传输时都是以字符为单位进行的。

流：对数据源的一种抽象，其目的是想用统一的方式访问各种不同的数据源（文件、网络、内存的缓冲区）

文件读写的基本类：File类提供定位本地文件系统，描述文件和目录的功能。

管道流用于在线程之间通信：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter
线程1àPipedOutputStreamàPipedInputStreamà线程2

键盘输入：
try{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s=br.readLine();
System.out.println(s);
}catch(Exception e){
}

文件输入输出：
try{
File f=new File("test.txt");
FileOutputStream fout=new FileOutputStream(f);
fout.write(System.in.read());
fout.close();
FileInputStream fin=new FileInputStream(f);
int size=fin.available();
for(int i=0;i<size;i++){
System.out.print((char)fin.read());
}
fin.close();
}catch(Exception e){
}

通过网络传输文件：
客户端：
File f=new File("bk.exe");
FileInputStream fin=new FileInputStream(f);
Socket st=new Socket("localhost",6000);
BufferedOutputStream bout=new BufferedOutputStream(st.getOutputStream());
int size=fin.available();
for(int i=0;i<size;i++){
bout.write(fin.read());
}
服务器端：
ServerSocket server=new ServerSocket(6000);
Socket st=server.accept();
File f=new File("kk.exe");
BufferedInputStream bin=new BufferedInputStream(st.getInputStream());
FileOutputStream fout=new FileOutputStream(f);
int i=0;
while(i!=-1){
i=bin.read();
fout.write(i);
}

串行化的注意事项以及如何实现串行化
对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力，叫做对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization)。
序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。
一：对象序列化可以实现分布式对象。
二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。
// 序列化 today's date 到一个文件中.
   FileOutputStream f = new FileOutputStream("tmp");
   ObjectOutputStream s = new ObjectOutputStream(f);
   s.writeObject("Today");
   s.writeObject(new Date());
   s.flush();
//从文件中反序列化 string 对象和 date 对象
   FileInputStream in = new FileInputStream("tmp");
   ObjectInputStream s = new ObjectInputStream(in);
   String today = (String)s.readObject();
   Date date = (Date)s.readObject();
记住，对象流不序列化static或transient。
序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。
如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流

NIO的特征
l旧的I/O是以字节为单位进行读写的，而新的I/O是以块为单位进行读写的
l以新的Channel抽象类来配合节点类
l使用Buffer的概念来进行基本数据类型的存取
l增加更多字节编码的支持
l内存映像及数据锁定的支持
l提供非阻塞的存取机制
l提供正则表达式式的验证机制


import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.*;
import java.util.*;

class NBTest {
NBTest(){}
public void startServer() throws Exception{
int channels = 0;
int nKeys = 0;
int currentSelector = 0;
Selector selector = Selector.open();

//建立Channel 并绑定到9000端口
ServerSocketChannel ssc = ServerSocketChannel.open();
InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(),9000);
ssc.socket().bind(address);

//使设定non-blocking的方式。
ssc.configureBlocking(false);

//向Selector注册Channel及我们有兴趣的事件
SelectionKey s = ssc.register(selector, SelectionKey.OP_ACCEPT);
printKeyInfo(s);

while(true) //不断的轮询
{
debug("NBTest: Starting select");
//Selector通过select方法通知我们我们感兴趣的事件发生了。
nKeys = selector.select();
//如果有我们注册的事情发生了，它的传回值就会大于0
if(nKeys > 0){
debug("NBTest: Number of keys after select operation: " +nKeys);
//Selector传回一组SelectionKeys
//我们从这些key中的channel()方法中取得我们刚刚注册的channel。
Set selectedKeys = selector.selectedKeys();
Iterator i = selectedKeys.iterator();
while(i.hasNext()){
s = (SelectionKey) i.next();
printKeyInfo(s);
debug("NBTest: Nr Keys in selector: " +selector.keys().size());

//一个key被处理完成后，就都被从就绪关键字（ready keys）列表中除去
i.remove();
if(s.isAcceptable()){
// 从channel()中取得我们刚刚注册的channel。
Socket socket = ((ServerSocketChannel)s.channel()).accept().socket();
SocketChannel sc = socket.getChannel();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ |SelectionKey.OP_WRITE);
System.out.println(++channels);
}else{
debug("NBTest: Channel not acceptable");
}
}
}else{
debug("NBTest: Select finished without any keys.");
}
}
}

private static void debug(String s){
System.out.println(s);
}

private static void printKeyInfo(SelectionKey sk)
{
String s = new String();
s = "Att: " + (sk.attachment() == null ? "no" : "yes");
s += ", Read: " + sk.isReadable();
s += ", Acpt: " + sk.isAcceptable();
s += ", Cnct: " + sk.isConnectable();
s += ", Wrt: " + sk.isWritable();
s += ", Valid: " + sk.isValid();
s += ", Ops: " + sk.interestOps();
debug(s);
}

public static void main (String args[])
{
NBTest nbTest = new NBTest();
try{
nbTest.startServer();
}catch(Exception e){
e.printStackTrace();
}
}
}

Socket通信(TCP、UDP区别及Java实现方式)
套接字是一种进程间的数据交换机制。客户端和服务器通过套接字建立连接和进行通信。套接字是由IP地址、传输协议和一个端口号三部分组成的。
TCP/IP协议：其中TCP 为传输控制协议是传输层协议，
功能TCPUDP
数据传输连续的有序数据流消息传输
多路功能接收主机根据端口号决定数据流向那个应用相同
可靠传输使用TCP头部的序列与确认字段进行数据确认无
流量控制使用窗口机制的流量控制无
连接使用3次握手建立连接；连接后一直保持连接直到终止连接无连接

URL的组件：协议、IP地址或主机名、端口号和实际文件路径

import java.net.*;
import java.io.*;

public class DatagramServer{
public static DatagramSocket ds;
public static int clientport=1089,serverport=1090;
public static void main(String args[]) throws Exception{
byte buffer[]=new byte[1024];
ds=new DatagramSocket(serverport);
BufferedReader dis=new BufferedReader(new InputStreamReader(System.in));
System.out.println("服务器正等待输入");
InetAddress ia=InetAddress.getByName("localhost");
while(true){
String str=dis.readLine();
if(str==null||str.equals("end")){
break;
}
buffer=str.getBytes();
ds.send(new DatagramPacket(buffer,str.length(),ia,clientport));
}
}
}

import java.net.*;
import java.io.*;

public class DatagramClient{
public static DatagramSocket ds;
public static byte buffer[]=new byte[1024];
public static int clientport=1089,serverport=1090;
public static void main(String args[]) throws Exception{
ds=new DatagramSocket(clientport);
System.out.println("客户端正在等待服务器发送数据");
while(true){
DatagramPacket p=new DatagramPacket(buffer,buffer.length);
ds.receive(p);
String psx=new String(p.getData(),0,p.getLength());
System.out.println(psx);
}
}
}

13、Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？
答:Server端程序:
package test;
import java.net.*;
import java.io.*;

public class Server {
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server() {
try {
ss=new ServerSocket(10000);
while(true) {
socket = ss.accept();
String RemoteIP = socket.getInetAddress().getHostAddress();
String RemotePort = ":"+socket.getLocalPort();
System.out.println("A client come in!IP:"+RemoteIP+RemotePort);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println("Cleint send is :" + line);
out = new PrintWriter(socket.getOutputStream(),true);
out.println("Your Message Received!");
out.close();
in.close();
socket.close();
}
}catch (IOException e) {
out.println("wrong");
}
}
public static void main(String[] args) {
new Server();
}
};

Client端程序:
package test;
import java.io.*;
import java.net.*;

public class Client {
Socket socket;
BufferedReader in;
PrintWriter out;
public Client() {
try {
System.out.println("Try to Connect to 127.0.0.1:10000");
socket = new Socket("127.0.0.1",10000);
System.out.println("The Server Connected!");
System.out.println("Please enter some Character:");
BufferedReader line = new BufferedReader(new

InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(),true);
out.println(line.readLine());
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
socket.close();
}catch(IOException e) {
out.println("Wrong");
}
}
public static void main(String[] args) {
new Client();
}
};

常见排序法：
public class Sort{
public static int count=0;
public boolean LT(int num1,int num2){
return num1<num2;
}
public void output(int[] array){
System.out.print("第"+count+"次排序：");
for(int i=0;i<array.length;i++)
System.out.print(array[i]+"    ");
System.out.println();
}

//冒泡排序法
public void BubbleSort(int[] array){
boolean swap=true;
int index=0;

int i=0;
while(i<array.length-1){
int temp=array[i];
for(int j=i;j<array.length;j++){
if(!LT(array[i],array[j])){
int temp2=array[i];
array[i]=array[j];
array[j]=temp2;
swap=true;
index=j;
}else{
swap=false;
}
}
i++;
if(swap){
array[i]=array[index];
array[index]=temp;
i++;
}
output(array);
}
}

//直接插入排序法
public void InsertSort(int[] array){
for(int i=1;i<array.length;++i){
if (LT(array[i],array[i-1])){
int temp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
for(int j=i-1;j>0;--j){
if(LT(array[j],array[j-1])){
array[j]=array[j-1];
array[j-1]=temp;
}else{
break;
}
}
output(array);
}
}
}

//快速排序法
private int Partition(int array[],int low,int high){
int temp=array[low];
int pivotkey=array[low];
while(low<high){
while(low<high&&array[high]>pivotkey)--high;
array[low]=array[high];
while(low<high&&array[low]<=pivotkey)++low;
array[high]=array[low];
}
array[low]=temp;
output(array);
return low;
}

public void QSort(int array[],int low,int high){
if(low<high){
int pivotloc=Partition(array,low,high);
QSort(array,low,pivotloc-1);
QSort(array,pivotloc+1,high);
}
}

void QuickSort(int array[]){
QSort(array,0,array.length-1);
}
public static void main(String args[]){
int array[]={49,38,65,97,76,13,27,49};
Sort sort=new Sort();

System.out.println("===================================");
sort.output(array);
System.out.println("优化冒泡排序法");
sort.BubbleSort(array);

System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("直接插入排序法");
sort.InsertSort(array);

System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("快速排序法");
sort.QuickSort(array);
}
}

14、如在COLLECTION框架中，实现比较要实现什么样的接口？
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

什么是线程？
线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程（light-weight process）。一个进程中可以包含多个线程。

　　一个线程是一个程序内部的顺序控制流。
　　1. 进程：每个进程都有独立的代码和数据空间（进程上下文） ，进程切换的开销大。
　　2. 线程：轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
　　3. 多进程：在操作系统中，能同时运行多个任务程序。
4. 多线程：在同一应用程序中，有多个顺序流同时执行。

同步和异步有和异同，在什么情况下分别使用他们？
临界资源问题
线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。但是经常有一些同时运行的线程需要共享数据，此时就需考虑其他线程的状态和行为，否则就不能保证程序的运行结果的正确性。
我们需要做的是允许一个线程彻底完成其任务后，再允许下一个线程执行。必须保证一个共享的资源一次只能被一个线程使用。实现此目的的过程称为同步。
同步是用于确保资源一次只能被一个线程使用的过程。
同步对于单线程程序没有任何好处。使用同步比非同步的性能差三到四倍。

线程方法介绍：
构造函数：
Thread()
Thread(Runable target）
Thread(Runable target，String name）
Thread(ThreadGroup group,Runable target）
Thread(ThreadGroup group,Runable target,String name）
Thread(ThreadGroup group,String name）

用于完成一个线程“实际功能”的代码放在run方法中。Run方法可以在Thread的子类中重写，也可以在Runable对象中重写。

一旦线程死去，它就永远不能再重新启动，否则会抛出异常。用start方法启动一个已经启动的线程也会抛出异常。

isAlive、interrupt、Thread.currentThread、suspend、resume、stop

Sleep方法可以使低优先级的线程得到执行的机会，Yield方法只能使同优先级的线程有执行的机会。Join方法能够使调用该方法的线程在此之前执行完毕，在该方法之后，调用join方法的线程不会产生输出了，


Wait与notify使用时，需要注意的事项？
它们只能用于synchronized同步块中；
它们需要配对使用；
Wait一般出现在一个while循环中，while语句使用一个boolean标志控制。

死锁
当被锁定的A对象试图访问另一个被锁定的B对象，B对象同时又要访问已被锁定的A对象。这样导致两个线程都在等待另一个线程释放资源，这样就出现了死锁。

16、JAVA多线程编程。 用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。
希望大家补上，谢谢

17、STRING与STRINGBUFFER的区别。
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

String s = new String("xyz");创建了几个String Object? 两个

JDBC调用数据库的基本步骤

Weblogic Server中的JDBC配置
1、建立到指定数据库的连接池Connection Pool
2、建立基于该连接池的数据源DataSource
3、访问数据库时通过数据源的JNDI名字查找到该数据源，然后通过数据源获得数据库连接对象。得到该对象后就可以依次生成数据库语句对象和结果集对象，进行相应的数据库操作。

import java.sql.*;
import javax.naming.*;
import javax.sql.*;
import java.util.*;
import javax.rmi.*;

public class DataSourceTest{
private static Context getInitialContext() throws Exception{
String url="t3://localhost:7001";
String user="system";
String password="11111111";
Properties properties=null;

try{
properties=new Properties();
properties.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.WLInitialContextFactory");
properties.put(Context.PROVIDER_URL,url);

if(user!=null){
properties.put(Context.SECURITY_PRINCIPAL,user);
properties.put(Context.SECURITY_CREDENTIALS,
password==null?"":password);
}

return new InitialContext(properties);
}catch(Exception e){
throw e;
}
}

public static void main(String args[]){
UserTransaction tx=null;
DataSource ds=null;
Context ctx=null;
Connection myConn=null;

try{
ctx=getInitialContext();

tx=(UserTranscation)ctx.lookup("javax.transcation.UserTranscation");
tx.begin();

ds=(DataSource)ctx.lookup("myTxDataSource");
}catch(Exception e){
e.printStackTrace();
}

Statement myStatement=null;
ResultSet myResultSet=null;

try{
myConn=ds.getConnection();
myStatement=myConn.createStatement();
myResultSet=myStatement.executeQuery(
"select fullname from employee");

while(myResultSet.next()){
System.out.println(myResultSet.getString("fullname"));
}

tx.commit();
}catch(Exception e){
try{
tx.rollback();
}catch(Exception e){
}
}finally{
myStatement.close();
myConn.close();
}
}
}

JavaMail发邮件的步骤：
Properties props=System.getProperties();
props.put(“mail.smtp.host”,”*******”); //设置相关的属性
try{
    //创建一个会话对象
    Session session=Session.getDefaultInstance(props,null);
    //创建一个消息对象
    MimeMessage message=new MimeMessage(session);
    message.setText(“*****”); //发送文本格式的邮件
    message.setSubject(“*****”);
    message.setFrom(“*****”);
    message.addRecipient(Message.RecipientType.To,
                        new InternetAddress(“******”));
   //使用传送类的send方法发送消息
   Transport.send(message);
}catch(MessagingException me){
          me.printStackTrace();}

解析XML文件的几种方式和区别
XML解析器使用的两种基本API是:
文档对象模型DOM，一种基于树结构的API。它定义了一组java接口，用于创建、访问和操纵XML文档的内部结构。它是基于对象。整个XML文档被作为对象体系结构排列进行解析和存储，应用程序可以随机访问这些对象。
DOM主要用于：在结构上修改XML文档时；在内存中与其他应用程序共享文档时。

SAX提供一种用于解析XML文档的事件驱动模型，使用SAX接口的XML处理器并不创建数据结构，而是扫描输入的XML文档，并生成元素开始、元素结束等事件，在发生事件时，解析器会通知应用程序。
SAX优点：在解析大型文档时，不必将整个文件加载到内存中，因此占有的内存比DOM少。在只需要一个信息子集时，SAX忽略不需要的数据，而DOM无法做到这点。
SAX的缺点是：必须按到达顺序处理数据，不能对文档进行随即访问。SAX是只读的，它是设计来读取XML文档而不是写入的。文档只能遍历一次。

使用DOM API查找XML文档中的元素和属性
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import java.net.URL;

public class BookDetails{
public BookDetails(String filename){
Document doc=null;
try{
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
DocumentBuilder db=dbf.newDocumentBuilder();
doc=db.parse(new File(filename));

String nm="http://www.123books.com/booktitles";
String local="a";
String ob="http://www.onlinebooks.com";

System.out.println(nm+"名字空间中的元素");
NodeList nl=doc.getElementsByTagNameNS(nm,"*");
for(int i=0;i<nl.getLength();i++){
Node n=nl.item(i);
System.out.println(n.getNodeName());
}

System.out.println("/n 名称为 "+local+" 的元素");
nl=doc.getElementsByTagNameNS("*",local);
for(int i=0;i<nl.getLength();i++){
Node n=nl.item(i);
System.out.println(n.getNodeName());
}

System.out.println("/n名字空间 "+ob+" 中的属性");
nl=doc.getElementsByTagName("*");
for(int i=0;i<nl.getLength();i++){
if(nl.item(i) instanceof Element){
Text t=(Text)nl.item(i).getFirstChild();
Element e=(Element)nl.item(i);
Attr a=e.getAttributeNodeNS(ob,"class");
if(a!=null){
String val=a.getNodeValue();
System.out.println("<"+val+">"+t.getNodeValue()+"</"+val+">");
}
}
}
}catch(Exception e){
e.printStackTrace();
}
}

public static void main(String args[]){
BookDetails nsd=null;
if(args.length>=1){
nsd=new BookDetails(args[0]);
}else{
System.out.println("Books.xml");
}
}
}
使用SAX API解析XML文档
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

public class SAXParserHandler extends DefaultHanlder{
public void startDocument() throws SAXException{
System.out.println("起始文档");
}

public void endDocument() throws SAXException{
System.out.println("结束文档");
}

//在遇到字符数据时激发
public void characters(char[] ch,int start,int lenght) throws SAXException){
String charString=new String(ch,start,lenght);
System.out.println("字符："+charString);
}

public void startElement(String namespaceURI,String localName,String qName,
Attributes atts)throws SAXException{
System.out.println("起始元素"+qName);
for(int i=0;i<atts.getLength();i++){
System.out.println("属性值："+atts.getvalue(i));
}
}

public void endElement(String namespaceURI,String localName,String qName)
throws SAXException{
System.out.println("结束元素"+qName);
}

public static void main(String args[]) throws Exception{
SAXParserFactory factory=SAXParserFactory.newInstance();
SAXParser parser=factory.newSAXParser();
parser.parse("book.xml",new SAXParserHanlder());
}
}
使用DOM API写XML文档
import org.w3c.dom.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

import java.io.*;

public class Student{
public static void main(String args[]){
Document doc;
Element students;
Element stud;
Element fName;
Element sName;
try{
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
DocumentBuilder db=dbf.newDocumentBuilder();
doc=db.newDocument();

stud=doc.createElement("Student");

fName=doc.createElement("FirstName");;
fName.appendChild(doc.createTextNode("John"));
stud.appendChild(fName);

sName=doc.createElement("Surname");
sName.appendChild(doc.createTextNode("David"));
stud.appendChild(sName);

students=doc.createElement("Students");
students.setAttribute("Department","Mathematics");
students.appendChild(stud);

doc.appendChild(students);

TransformerFactory tf=TransformerFactory.newInstance();
Transformer transformer=tf.newTransformer();
transformer.transform(new DOMSource(doc),new StreamResult(System.out));

}catch(Exception e){
e.printStackTrace();
}
}
}
使用DOM API显示现有XML文档内容

使用DOM API将XML文档数据插入数据库

使用DOM API根据数据库创建XML文档

Java的国际化
国际化是为了将应用程序发布在多个地区（locale）而进行准备的过程。不同地区标识了各个特定的国家在信息表现上所广泛使用的语言、流通货币、字符集、日期格式及其他要素。

支持国际化的应用程序具有以下特点：
1、不用改变代码就可以支持另外的语言。
2、文本元素、消息和图片保存在源代码之外。
3、将于文化背景有关的数据，比如日期和时间、十进制数值以及流通货币，根据用户所用的语言和所在地理位置进行正确格式化。
4、支持非标准字符集。
5、应用程序可以快速适应新的语言区域。

为了使一个应用程序国际化，：
1、必须将用户所见到的硬编码字符（如标签、工具提示和错误信息等）替换成包含在资源包ResourceBundle中的字符。它是一个java属性文件，它将关键字映射为字符值。并且可以使用多个不同语言版本的ResourceBundle，这样将可以对于不同语言提供不同的字符串。
2、使用Locale对象，可以使数据格式化为与地区相关的数据。
3、国际化的应用程序还必须使用统一的字符编码标准字符集。

应用服务器有那些？

Servlet方面
什么是Servlet？
Servlet是J2EE应用框架中部署于Web层的Web组件，运行在支持Servlet的Web服务器或应用服务器上。Servlet为客户端和服务器端的信息处理提供了一种“请求/响应”机制。
客户程序将请求发送到服务器；服务器将请求发送到Servlet；依据客户程序的请求，Servlet动态地构造回答信息并返回给服务器；服务器将回答返回给客户程序。

什么是JSP？
JSP是J2EE应用框架中部署于Web层的Web组件，是对Servlet技术的扩展。它使在静态的页面中加入动态的内容变得非常容易。并且通过使用标签库可以大大节省开发时间；将JavaBean与JSP一起使用可以将数据表示和程序实现分离。

在MVC架构模式中：
使用Servlet作为控制器，而JSP作为数据视图。

CGI与Servlet的区别？
CGI（公共网关接口）是一项标准，使WEB服务器可以与外部应用程序交互。但是该技术存在一些严重的限制：
1、CGI应用程序占用资源很多。当系统要处理来自一个用户的请求时，就会创建一个新的进程来处理该请求，一旦CGI脚本停止执行，系统就必须收回该进程。这种重量级进程的经常启动和停止非常低效。
2、CGI很难链接于请求进程的其他阶段，因为在WEB服务器上它们运行于不同的进程。这就很难处理授权、工作流和日志记录工作。

Java Servlet技术提供了一个基于组件、与平台无关的方法来构建WEB应用程序。Servlet没有标准CGI应用程序所遇到的性能局限。
Servlet比CGI更高效是因为：
Servlet应用中将只创建一个单一个重量级进程，并对每个用户请求使用更轻量级的线程来完成请求处理，并且这些线程是由JVM自动维护。每个客户端请求对应一个线程，每个Servlet类在Servlet容器中只存在一个唯一的对象（实例）。Servlet类首次加载后将常驻内存。

1、说一说Servlet的生命周期?
答:在第一次请求Servlet时将创建Servlet实例，容器调用实例的init方法，如果容器有请求要传送给servlet，它就会调用servlet实例的Service方法。一个请求将作为一个线程。如果服务器要销毁servlet实例就会调用servlet实例的destory方法，否则该实例将会常驻内存。

2、Servlet版本间(忘了问的是哪两个版本了)的不同?
希望大家补上，谢谢

会话根中技术
用户认证：使用用户名和口令进行验证来让客户端访问某些资源。
隐藏表单字段：用于保存一个浏览器在服务器中的相关信息。
URL重写：在URL后面添加附加信息
持久Cookie：在请求和响应头信息中添加和编辑信息

什么是会话对象？
会话对象用于在用户访问一个Web站点的多个页面时共享信息。任何时候用户第一次访问某个网页，系统都将创建一个会话。如果以后用户访问此网页，JSP将检索有关此会话的信息。只要服务器收到此用户的请求，则会话就会持续，如果经过一段时间没有收到此用户的新请求，会话就会终止。

3、JAVA SERVLET API中forward() 与redirect()的区别？
使用重定向：当调用sendRedirect方法时，Web容器就会向浏览器返回响应，指示需要新的URL。因为浏览器发出了完全崭新的请求，所以在重定向之前存储为请求属性的任何对象都会消失。
使用转发：当为一个请求调用转发时，请求就发送给服务器上另一个资源，而无需通知客户机由不同的资源处理请求。这个过程完全在Web容器内部进行，客户机绝不知晓。与重定向不同，转发过程中，对象可以存储在请求中，并发送给下一个资源使用。
因为转发过程完全在服务器上进行，与客户机没用通信，因此转发的性能优于重定向。
但是如果在JSP页面上使用图形的相对路径和其他资源，转发机制就会带来问题。因为浏览器无从得知发生了转发，所以相对路径只是相对初始的Servlet，而不是所转发到的JSP页面。使用JSP自定义标签可以解决这个问题。

如何现实servlet的单线程模式

servlet的配置

4、Servlet的基本架构
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}



Jsp方面
1、jsp有哪些内置对象?作用分别是什么?
JSP的隐式对象
RequestJavax.servlet.ServletRequest它包含了有关浏览器请求的信息.通过该对象可以获得请求中的头信息、Cookie和请求参数。
Enumeration getHeaderNames（）String getHeader（name）Cookie[] getCookies（）Enumeration GetParameterNames（）String getParameter（name）String[] GetParametervalues（name）HttpSession getSession（flag）
responseJavax.servlet.ServletResponse作为JSP页面处理结果返回给用户的响应存储在该对象中。并提供了设置响应内容、响应头以及重定向的方法（如cookies,头信息等）
Void setContentType(type)String getCharacterEncoding()Void addCookie(cookie)Void sendRedirect(url)
outJavax.servlet.jsp.JspWriter用于将内容写入JSP页面实例的输出流中，提供了几个方法使你能用于向浏览器回送输出结果。
pageContextJavax.servlet.jsp.PageContext描述了当前JSP页面的运行环境。可以返回JSP页面的其他隐式对象及其属性的访问，另外，它还实现将控制权从当前页面传输至其他页面的方法。
Void forward(path)PAGE_SCOPEREQUEST_SCOPESESSION_SCOPEAPPLICATION_SCOPEVoid setAtrribute(key,value,scope)Enumeration getAttributeNamesInScope(scope)Object getAttribute(key,scope)Void RemoveAttribute(key,scope)Object findAttribute(name)Int getAttributeScope(name)
sessionjavax.servlet.http.HttpSession会话对象存储有关此会话的信息，也可以将属性赋给一个会话，每个属性都有名称和值。会话对象主要用于存储和检索属性值。
Void setAttribute(name,data)Object getAttribute（name）
applicationjavax.servle.ServletContext存储了运行JSP页面的servlet以及在同一应用程序中的任何Web组件的上下文信息。
pageJava.lang.Object表示当前JSP页面的servlet实例
configjavax.servlet.ServletConfig该对象用于存取servlet实例的初始化参数。
Enumeration getInitParameterNames()String getInitParameter(name)
ExceptionJavax.lang.Throwable在某个页面抛出异常时，将转发至JSP错误页面，提供此对象是为了在JSP中处理错误。
String getMessage()Void printStackTrace(out)<%@ page errorPage=”error.jsp”%><%@ page isErrorPage=”true” %>


2、jsp有哪些动作?作用分别是什么?
答:JSP共有以下6种基本动作
ljsp:include：在页面被请求的时候引入一个文件。
ljsp:useBean：寻找或者实例化一个JavaBean。
ljsp:setProperty：设置JavaBean的属性。
ljsp:getProperty：输出某个JavaBean的属性。
ljsp:forward：把请求转到一个新的页面。
ljsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

3、JSP中动态INCLUDE与静态INCLUDE的区别？
答：动态INCLUDE用jsp:include动作实现
<jsp:include page="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@ include file="included.htm" %>

4、两种跳转方式分别是什么?有什么区别?
答：有两种，分别为：
<jsp:include page="included.jsp" flush="true">
<jsp:forward page= "nextpage.jsp"/>
前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数.后者完全转向新页面，不会再回来。相当于go to 语句。

JSP的常用指令
<%@ include file=”localURL” %>
<%@ page attribute=”value1” %>
属性值缺省值示例
contentTypeMIME类型和字符集“text/hmt”contentType=“text/html；charset=ISO-8859-1“contentType=“text/xml“
Extends类名无Extends=“com.taglib.wdjsp.MyJspPage“
Import 类名或包名无
Session布尔值TrueSession=“true”
isThreadSafe布尔值True
ErrorPage
isErrorPage


<%@ taglib uri=”tagLibraryURL” prefix=”tagPrefix” %>

Jdbc
说出数据连接池的工作机制是什么?


1、可能会让你写一段Jdbc连Oracle的程序,并实现数据查询.
答:程序如下：
package hello.ant;
import java.sql.*;
public class jdbc {
String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
String theUser="admin";
String thePw="manager";
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc() {
try{
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql) {
try {
conn.executeUpdate(sql);
return true;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql) {
rs=null;
try {
rs=conn.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close(){
try {
conn.close();
c.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery("select * from test");
try{
while (rs.next()) {
System.out.println(rs.getString("id"));
System.out.println(rs.getString("name"));
}
}catch(Exception e) {
e.printStackTrace();
}
}
}

2、Class.forName的作用?为什么要用?
答：调用该访问返回一个以字符串指定类名的类的对象。

说出在JSP页面里是怎么分页的?
页面需要保存以下参数：
总行数：根据sql语句得到总行数
每页显示行数：设定值
当前页数：请求参数
页面根据当前页数和每页行数计算出当前页第一行行数，定位结果集到此行，对结果集取出每页显示行数的行即可。

4、在ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。
答:一种分页方法
<%
int i=1;
int numPages=14;

//获取当前页面
String pages = request.getParameter("page") ;
int currentPage = 1;
currentPage=(pages==null)?(1):{Integer.parseInt(pages)};

//获得记录总数
sql = "select count(*) from tables";
ResultSet rs = DBLink.executeQuery(sql) ;
while(rs.next()) i = rs.getInt(1) ;

//获取总页数
int intPageCount=1;
intPageCount=(i%numPages==0)?(i/numPages):(i/numPages+1);

//设置上下页
int nextPage ;
int upPage;
nextPage = currentPage+1;
if (nextPage>=intPageCount) nextPage=intPageCount;
upPage = currentPage-1;
if (upPage<=1) upPage=1;

//获取数据内容并显示
rs.close();
sql="select * from tables";
rs=DBLink.executeQuery(sql);
i=0;
while((i<numPages*(currentPage-1))&&rs.next()){i++;}
%>
//输出内容
//输出翻页连接
合计:<%=currentPage%>/<%=intPageCount%>
<a href="List.jsp?page=1">第一页</a>
<a href="List.jsp?page=<%=upPage%>">上一页</a>

<%
for(int j=1;j<=intPageCount;j++){
if(currentPage!=j){
%>
//显示所有页面的连接
<a href="list.jsp?page=<%=j%>">[<%=j%>]</a>

<%
}else{
out.println(j);
} //end of if
} //end of for
%>

<a href="List.jsp?page=<%=nextPage%>">下一页</a>
<a href="List.jsp?page=<%=intPageCount%>">最后页 </a>


Xml方面
2、你在项目中用到了xml技术的哪些方面?如何实现的?
答:用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。

3、用jdom解析xml文件时如何解决中文问题?如何解析?
答:看如下代码,用编码方式加以解决
package test;
import java.io.*;
public class DOMTest {
private String inFile = "c://people.xml";
private String outFile = "c://people.xml";
public static void main(String args[]){
new DOMTest();
}
public DOMTest() {
try {
javax.xml.parsers.DocumentBuilder builder =
javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
org.w3c.dom.Document doc = builder.newDocument();
org.w3c.dom.Element root = doc.createElement("老师");
org.w3c.dom.Element wang = doc.createElement("王");
org.w3c.dom.Element liu = doc.createElement("刘");
wang.appendChild(doc.createTextNode("我是王老师"));
root.appendChild(wang);
doc.appendChild(root);
javax.xml.transform.Transformer transformer =
javax.xml.transform.TransformerFactory.newInstance().newTransformer();

transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312");
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");
transformer.transform(new javax.xml.transform.dom.DOMSource(doc),
new javax.xml.transform.stream.StreamResult(outFile));
} catch (Exception e) {
System.out.println (e.getMessage());
}
}
}

4、编程用JAVA解析XML的方式.
答:用SAX方式解析XML，XML文件如下：
<?xml version="1.0" encoding="gb2312"?>
<person>
<name>王小明</name>
<college>信息学院</college>
<telephone>6258113</telephone>
<notes>男,1955年生,博士，95年调入海南大学</notes>
</person>
事件回调类SAXHandler.java
import java.io.*;
import java.util.Hashtable;
import org.xml.sax.*;
public class SAXHandler extends HandlerBase {
private Hashtable table = new Hashtable();
private String currentElement = null;
private String currentvalue = null;
public void setTable(Hashtable table) {
this.table = table;
}
public Hashtable getTable(){
return table;
}
public void startElement(String tag, AttributeList attrs) throws SAXException {
currentElement = tag;
}
public void characters(char[] ch, int start, int length) throws SAXException {
currentvalue = new String(ch, start, length);
}
public void endElement(String name) throws SAXException {
if (currentElement.equals(name)) table.put(currentElement, currentvalue);
}
}

JSP内容显示源码,SaxXml.jsp:
<HTML>
<HEAD>
<title>剖析XML文件people.xml</title>
</HEAD>
<BODY>
<%@ page errorPage="ErrPage.jsp" contentType="text/html;charset=GB2312" %>
<%@ page import="java.io.*" %>
<%@ page import="java.util.Hashtable" %>
<%@ page import="org.w3c.dom.*" %>
<%@ page import="org.xml.sax.*" %>
<%@ page import="javax.xml.parsers.SAXParserFactory" %>
<%@ page import="javax.xml.parsers.SAXParser" %>
<%@ page import="SAXHandler" %>
<%
File file = new File("c://people.xml");
FileReader reader = new FileReader(file);
Parser parser;
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXHandler handler = new SAXHandler();
sp.parse(new InputSource(reader), handler);
Hashtable hashTable = handler.getTable();
out.println("<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>");
out.println("<TR><TD>姓名</TD>" + "<TD>" +
(String)hashTable.get(new String("name")) + "</TD></TR>");
out.println("<TR><TD>学院</TD>" + "<TD>" +
(String)hashTable.get(new String("college"))+"</TD></TR>");
out.println("<TR><TD>电话</TD>" + "<TD>" +
(String)hashTable.get(new String("telephone")) + "</TD></TR>");
out.println("<TR><TD>备注</TD>" + "<TD>" +
(String)hashTable.get(new String("notes")) + "</TD></TR>");
out.println("</TABLE>");
%>
</BODY>
</HTML>

EJB方面
1、EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别?
答：规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工作。JSP,Servlet,EJB,JNDI,JDBC,JMS.....

2、EJB与JAVA BEAN的区别？
JavaBean是可复用的平台独立的软件组件，开发者可以在软件构造器工具中对其直接进行可视化操作。

Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

3、EJB的基本架构
答:一个EJB包括三个部分:
Remote Interface 接口的代码
package Beans;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface Add extends EJBObject {
//some method declare
}

Home Interface 接口的代码
package Beans;
import java.rmi.RemoteException;
import jaax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface AddHome extends EJBHome {
//some method declare
}

EJB类的代码
package Beans;
import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javx.ejb.SessionContext;
public class AddBean Implements SessionBean {
//some method declare
}

J2EE,MVC方面
1、MVC的各个部分都有那些技术来实现?如何实现?
答:MVC是Model－View－Controller的简写。设计的基本原理是将复杂性分解为三个组件，即模型、视图、控制器。
模型表示数据和处理数据的业务逻辑或应用程序对象。
试图是用户要查看或存取的数据的表示。
控制器定义了用户与模型和试图交互的方式。


2、应用服务器与WEB SERVER的区别？
Web Service 是一种新的分布式技术。一个Web服务本质上是一个应用组件，可以通过Web协议和数据编码机制，例如HTTP和XML，对这个组件进行访问。

Soap简单对象访问协议：
是一种基于XML的通信协议。它包括3个部分。
Soap封装结构：定义消息的XML格式，包括其整体框架、消息内容、由谁处理这些内容等。
Soap编程规则：定义如何将程序数据表示为XML。
Soap RPC表示：定义如何使用scap进行远程过程调用。

WSDL Web服务描述语言：
WSDL文件是一个XML文档，用于说明一组soap消息以及如何交换这些消息。还定义了服务的位置以及使用服务的通信协议等。

Uddi统一描述、发现和集成标准
是wed服务的黄页。它提供了用于服务注册的目录技术，并用它来建立Web服务的目录信息。UDDI的核心组件是UDDI商业注册，它使用一个XML文档来描述企业及所提供的Web服务。它包括3个部分：
白页：介绍提供服务的公司，包括名称、地址和联系方式等；
黄页：包括按照标准分类法进行分类的行业类别；
绿页：详细介绍，访问服务接口等技术信息。

Web服务是构建在soap（简单对象访问协议）、wsdl（web服务描述语言）、uddi（统一描述、发现和集成标准）3个开放的核心标准之上的。Soap用来进行Web服务通信的协议，WSDL用来进行说明和描述Web服务
由于Web服务完全基于XML的，使Web服务成为一个跨语言、跨平台、跨网络的可互操作的分布式应用软件的新平台。
3、J2EE是什么？
J2EE是sun公司推出的一个高层次的全方位、多功能的企业应用开发环境。它包括了当今软件工业界许多最新、最重要的软件技术。J2EE平台包含一整套的服务、应用程序接口和协议，是java技术企业级应用的整体解决方案。J2EE平台通过基于组件的应用程序模型大大简化了开发过程，同时还支持任何分布式体系和多层次的应用开发。随着越来越多的第三方对J2EE的支持和标准认证，J2EE已被广泛用来开发企业级应用软件、中间件和组件软件。
J2EE Java2平台企业版：
1、提供了基于组件的方式来设计、开发、组装和部署企业应用。
2、提供了一个多层次分布式的应用模型，包括了可复用的组件、基于XML数据交换、统一的安全模式以及灵活的事务控制。基于这些技术，可开发出满足市场要求的，基于平台无关的J2EE组件的解决方案。
3、J2EE平台使用的多层分布式应用模型中应用程序主要分为：客户层（Applet）、Web层（Servlet和JSP）、业务层（EJB）、企业信息系统层。


使用类库开发与使用框架包进行开发的区别？
框架包简单的可以认为是一组类和接口，它们相互协作以解决特定类型的软件问题。
类库包含的是应用程序可以调用的函数或例程。而框架包提供通用的、相互协作的组件，应用程序通过扩展这些组件提供特定函数组。应用程序将在这些扩展点进行扩展，运行时这些扩展将被框架系统反调用。这正与使用类库开发的应用程序，运行时的函数调用时颠倒的。

5、BS与CS的联系与区别。
传统的分布式应用程序都是基于Client/Server结构的，而近年来人们发现基于Client/Server结构的应用程序有很多缺点，比如：如果客户端的代码需要改变，那么所有机器上的客户端程序都要重新安装；如果某台机器有了不可修复的损坏，那么得去别的机器上重新安装客户端软件才能够使用。而基于Browser/Server结构的应用程序就没有以上的缺点了，我们可以使用任何一台有浏览器的机器来工作，而因为所有的程序逻辑都在服务器端，所以服务器端的代码变动不需要作为客户端的浏览器再做任何工作。

6、STRUTS的应用(如STRUTS架构)
答：Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。 采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能：
一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。
二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。
三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

设计模式方面
1、开发中都用到了那些设计模式?用在什么场合?
答：人们在自己的环境中不断发现问题和寻找问题的解决方案的时候，发现有一些问题及其解决方案不断变换面孔重复出现，但在这些不同的面孔后面有着共同的本质，这些共同的本质就是模式。设计模式就是用来描述解决这些问题的解决方案的核心的。

工厂模式
专门负责将大量有共同接口的类实例化。工厂模式可以动态确定将那一个类实例化，不必事先知道每次要实例化那一个类。

简单工厂模式
或称静态工厂方法模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式就是由一个工厂类根据传入的参数决定创建那一种产品类的实例。
简单工厂模式涉及到工厂角色、抽象产品角色以及具体产品角色：l工厂类角色：含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象。l抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或它们共同拥有的接口。l具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例。
优点是：允许客户端相对独立于产品创建的过程，并且在系统引入新产品的时候无需修改客户端。缺点是：如果有新的产品加入到系统中去，就需要修改工厂类，将必要的逻辑加入到工厂类中。
工厂方法模式
或称多态性工厂模式。工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。它仅负责给出具体工厂子类必须实现的接口。这样可以用来允许系统在不修改具体工厂角色的情况下引进新的产品。
工厂方法模式涉及到的角色：l抽象工厂角色：它不包含应用逻辑。任何在模式中创建对象的工厂类必须实现这个接口。l具体工厂角色：含有与应用密切相关的逻辑，并且受到应用程序的调用以创建产品对象。l抽象产品角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。l具体产品角色：这个角色实现了抽象产品角色所声明的接口。
单例模式
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
特点：单例类只能有一个实例；单例类必须自己创建自己的惟一的实例；单例类必须给所有其他对象提供这一实例。
多例模式
多例类可以有多个实例，并且多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。
在系统中可以用于数据库连接池、键值缓存等。
代理模式
给某个对象提供一个代理对象，并由代理对象控制对原对象的引用。
代理模式所涉及的角色：抽象主题角色：声明了真实主题和代理主题的共同接口，这样一来在任何可以使用真实主题的地方都可以使用代理主题角色。

名称



2、UML方面
UML包括的图有：案例图、类图、序列图、合作图、状态图、活动图、构件图、部署图。

类图中的关系有：
一般关系（类于类的继承关系、接口与接口的继承关系、类对接口的实现关系）；
关联关系：它使一个类知道另一个类的属性和方法。在java中，使用实例变量实现。
聚合关系：是整体与个体之间的关系。也是使用实例变量实现。
合成关系：是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。
依赖关系：总是单向的。表示一个类依赖于另一个类的定义。

3、软件的可维护性与可复用性
一个好的系统设计应该有如下性质：
可扩展性：新的性能可以很容易地加入到系统中。
灵活性：可以允许代码修改平稳地发生、而不会波及到很多其他的模块。
可插入性：可以很容易地将一个类抽出去，同时将另一个有同样接口的类加入进来。

在java中可以给出一个或多个抽象java类或java接口，规定出所有的具体类必须提供的方法特征作为系统设计的抽象层。这个抽象层预见了所有的可能扩展，因此，在任何扩展情况下都不会改变。

接口是实现构件的可插入性的关键。一个java接口是一些方法特征的集合，这些方法一般都是在系统经常出现的方法。一个接口只有方法的特征，没有方法的实现，因此在不同地方的该方法实现，可以具有不同的行为。
接口是对可插入性的保证：
因为在类的关联中，如果一个关联不是针对一个具体类的，而是针对一个接口的，那么任何实现这个接口的类就都可以满足要求。当前对象并不在意所关联的是哪个具体类，而仅仅关心这个类是否实现了某个接口。这样一来，就可以动态地将这个关联从一个具体类转换到另一个具体类，而这样做的唯一条件是它们都实现某个接口。

抽象类仅提供一个类型的部分实现。抽象类通常代表一个抽象概念，它提供一个继承的出发点。
javascript方面
1、如何校验数字型?
var re=/^/d{1,8}$|/./d{1,2}$/;
var str=document.form1.all(i).value;
var r=str.match(re);
if (r==null) {
sign=-4;
break;
} else{
document.form1.all(i).value=parseFloat(str);
}

CORBA方面
什么是RMI？
Java RMI（Remote Method Invocation）--Java的远程方法调用是Java所特有的分布式计算技术，它允许运行在一个Java虚拟机上的对象调用运行在另一个Java虚拟机上的对象的方法，从而使Java编程人员可以方便地在网络环境中作分布式计算。面向对象设计要求每个任务由最适合该任务的对象执行，RMI将这个概念更深入了一步，使任务可以在最适合该任务的机器上完成。
RMI定义了一组远程接口，可以用于生成远程对象。客户机可以象调用本地对象的方法一样用相同的语法调用远程对象。RMI API提供的类和方法可以处理所有访问远程方法的基础通信和参数引用要求的串行化。
使用RMI开发步骤：
1、定义一个远程接口（远程接口必须继承接口，每个方法必须抛出远程异常，方法参数和方法返回值都必须是可序列化的）
2、实现远程接口
3、定义使用远程对象的客户程序
4、产生远程访问对象的桩和框
5、注册远程对象
6、运行服务器和客户程序

RMI和CORBA的区别？
远程方法调用（RMI）和CORBA都是分布式计算技术，在进行分布式时各有其优缺点，CORBA和RMI的区别。
　　CORBA（Common Object Request Broker Architecture）是OMG的Object Management Architecture（对象管理结构），它是面向对象的分布式系统建立所依据的标准。CORBA被设计成一个能供所有编程语言使用的一个开放性说明，就是说一个机器上的Java客户可以要求另一个用SmallTalk或C++的机器服务。正是由于这种语言的独立性使得CORBA这么灵活和吸引人。为了适应语言独立性，CORBA采用了非常通用的标准作为其接口。在不同的语言中，远程调用、签名和对象的引入有各自不同的定义，所以CORBA必须尽可能的中立和开放。正是这种通用性是CORBA的一个弱点。当开发人员都采用CORBA时，他们要用一种新的标准定义语言接口，它要求开发者学习新的编程接口，从而减小了远程模型的透明性。
　　RMI是为仅在Java对Java的分布式计算中而开发的。远程调用的标准是为了Java和应用Java的自然Java签名和调用而开发的，这使得RMI对Java的开发者相当透明而且易于实现。RMI用Java语言紧密集成从而同CORBA相比能够提供非常好的容错能力及对异常的处理。尽管Java的RMI标准不像CORBA那样语言独立，但Java本身是一个独立的平台，这就使RMI在跨平台的分布软件开发中是一个很好的选择。
　　RMI是Java语言在分布式计算上的基本模型，很多Java的分布式系统，包括我们本章要涉及的EJB，都是建立在RMI的思想上的。

基于IIOP协议的远程方法调用（RMI-IIOP）
RMI是一个分布对象系统，允许java对象与运行在其他虚拟机上的java对象进行交互。使得可以象访问本地对象一样访问远程对象；只要获得一个远程对象的引用，就可以把这个对象看作如同运行在同一虚拟机上那样来调用它的方法。但RMI是一个仅限于Java的分布式对象系统，这个系统使用了一个java特有的传输协议，即java远程方法协议（JRMP），在客户端和服务器之间进行信息传输。然而，这也意味着使用这种协议只能访问其他java对象，而无法访问非java对象。
远程方法调用的实际处理过程与CORBA的过程相似，即RMI使用客户端桩和服务器端框。要调用远程方法，客户端首先在桩上生成一个请求，然后将此请求传递给服务器，在服务器的框将请求转换成对远程对象的实际方法调用。客户端桩将远程方法的所有参数序列化后传递给服务器框，框将对参数反序列化。
但是由于这种协议不支持EJB需要的企业级交互，因为在这种类型的交互中必须通过远程方法调用来传递事务和安全环境。为此sun公司创建了RMI-IIOP即基于因特网内部对象请求代理协议之上的远程方法调用。IIOP是一个用在CORBA对象请求代理间进行通信的协议，在IIOP之上的RMI同时具有RMI和CORBA技术的特点。

LINUX方面
1、LINUX下线程，GDI类的解释。
答：LINUX实现的就是基于核心轻量级进程的"一对一"线程模型，一个线程实体对应一个核心轻量级进程，而线程之间的管理在核外函数库中实现。
GDI类为图像设备编程接口类库。

Java基础方面: 
1、作用域public,private,protected,以及不写时的区别 
答：区别如下： 
作用域 当前类 同一package 子孙类 其他package 
public √ √ √ √ 
protected √ √ √ × 
friendly √ √ × × 
private √ × × × 
不写时默认为friendly 

2、ArrayList和Vector的区别,HashMap和Hashtable的区别 
答：就ArrayList与Vector主要从二方面来说. 
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的 
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半 
就HashMap与HashTable主要从三方面来说。 
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value 

3、char型变量中能不能存贮一个中文汉字?为什么? 
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的 

4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 
同步的实现方面有两种，分别是synchronized,wait与notify 

5、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么? 
答:父类： 
package test; 
public class FatherClass 
{ 
public FatherClass() 
{ 
System.out.println("FatherClass Create"); 
} 
} 
子类: 
package test; 
import test.FatherClass; 
public class ChildClass extends FatherClass 
{ 
public ChildClass() 
{ 
System.out.println("ChildClass Create"); 
} 
public static void main(String[] args) 
{ 
FatherClass fc = new FatherClass(); 
ChildClass cc = new ChildClass(); 
} 
} 
输出结果： 
C:>java test.ChildClass 
FatherClass Create 
FatherClass Create 
ChildClass Create 

6、内部类的实现方式? 
答：示例代码如下： 
package test; 
public class OuterClass 
{ 
private class InterClass 
{ 
public InterClass() 
{ 
System.out.println("InterClass Create"); 
} 
} 
public OuterClass() 
{ 
InterClass ic = new InterClass(); 
System.out.println("OuterClass Create"); 
} 
public static void main(String[] args) 
{ 
OuterClass oc = new OuterClass(); 
} 
} 
输出结果: 
C:>java test/OuterClass 
InterClass Create 
OuterClass Create 
再一个例题： 
public class OuterClass { 
private double d1 = 1.0; 
//insert code here 
} 
You need to insert an inner class declaration at line 3. Which two inner class declarations are 

valid?(Choose two.) 
A. class InnerOne{ 
public static double methoda() {return d1;} 
} 
B. public class InnerOne{ 
static double methoda() {return d1;} 
} 
C. private class InnerOne{ 
double methoda() {return d1;} 
} 
D. static class InnerOne{ 
protected double methoda() {return d1;} 
} 
E. abstract class InnerOne{ 
public abstract double methoda(); 
} 
说明如下： 
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错 
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。 

故 D 错 
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确 
四.答案为C、E 

7、垃圾回收机制,如何优化程序? 
希望大家补上，谢谢 

8、float型float f=3.4是否正确? 
答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4 

9、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)? 
答：Collection FrameWork如下： 
Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
│　└Stack 
└Set 
Map 
├Hashtable 
├HashMap 
└WeakHashMap 
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements） 
Map提供key到value的映射 

10、Java中异常处理机制，事件机制？ 

11、JAVA中的多形与继承？ 
希望大家补上，谢谢 

12、抽象类与接口？ 
答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。 

13、Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？ 
答:Server端程序: 
package test; 
import java.net.*; 
import java.io.*; 

public class Server 
{ 
private ServerSocket ss; 
private Socket socket; 
private BufferedReader in; 
private PrintWriter out; 
public Server() 
{ 
try 
{ 
ss=new ServerSocket(10000); 
while(true) 
{ 
socket = ss.accept(); 
String RemoteIP = socket.getInetAddress().getHostAddress(); 
String RemotePort = ":"+socket.getLocalPort(); 
System.out.println("A client come in!IP:"+RemoteIP+RemotePort); 
in = new BufferedReader(new 

InputStreamReader(socket.getInputStream())); 
String line = in.readLine(); 
System.out.println("Cleint send is :" + line); 
out = new PrintWriter(socket.getOutputStream(),true); 
out.println("Your Message Received!"); 
out.close(); 
in.close(); 
socket.close(); 
} 
}catch (IOException e) 
{ 
out.println("wrong"); 
} 
} 
public static void main(String[] args) 
{ 
new Server(); 
} 
}; 
Client端程序: 
package test; 
import java.io.*; 
import java.net.*; 

public class Client 
{ 
Socket socket; 
BufferedReader in; 
PrintWriter out; 
public Client() 
{ 
try 
{ 
System.out.println("Try to Connect to 127.0.0.1:10000"); 
socket = new Socket("127.0.0.1",10000); 
System.out.println("The Server Connected!"); 
System.out.println("Please enter some Character:"); 
BufferedReader line = new BufferedReader(new 

InputStreamReader(System.in)); 
out = new PrintWriter(socket.getOutputStream(),true); 
out.println(line.readLine()); 
in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
System.out.println(in.readLine()); 
out.close(); 
in.close(); 
socket.close(); 
}catch(IOException e) 
{ 
out.println("Wrong"); 
} 
} 
public static void main(String[] args) 
{ 
new Client(); 
} 
}; 

14、用JAVA实现一种排序，JAVA类实现序列化的方法(二种)？ 如在COLLECTION框架中，实现比较要实现什么样的接口？ 
答:用插入法进行排序代码如下 
package test; 
import java.util.*; 
class InsertSort 
{ 
ArrayList al; 
public InsertSort(int num,int mod) 
{ 
al = new ArrayList(num); 
Random rand = new Random(); 
System.out.println("The ArrayList Sort Before:"); 
for (int i=0;i<num ;i++ ) 
{ 
al.add(new Integer(Math.abs(rand.nextInt()) % mod + 1)); 
System.out.println("al["+i+"]="+al.get(i)); 
} 
} 
public void SortIt() 
{ 
Integer tempInt; 
int MaxSize=1; 
for(int i=1;i<al.size();i++) 
{ 
tempInt = (Integer)al.remove(i); 
if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue()) 
{ 
al.add(MaxSize,tempInt); 
MaxSize++; 
System.out.println(al.toString()); 
} else { 
for (int j=0;j<MaxSize ;j++ ) 
{ 
if 

(((Integer)al.get(j)).intValue()>=tempInt.intValue()) 
{ 
al.add(j,tempInt); 
MaxSize++; 
System.out.println(al.toString()); 
break; 
} 
} 
} 
} 
System.out.println("The ArrayList Sort After:"); 
for(int i=0;i<al.size();i++) 
{ 
System.out.println("al["+i+"]="+al.get(i)); 
} 
} 
public static void main(String[] args) 
{ 
InsertSort is = new InsertSort(10,100); 
is.SortIt(); 
} 
} 
JAVA类实现序例化的方法是实现java.io.Serializable接口 
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口 

15、编程：编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。 
答：代码如下： 
package test; 

class SplitString 
{ 
String SplitStr; 
int SplitByte; 
public SplitString(String str,int bytes) 
{ 
SplitStr=str; 
SplitByte=bytes; 
System.out.println("The String is:′"+SplitStr+"′;SplitBytes="+SplitByte); 
} 
public void SplitIt() 
{ 
int loopCount; 


loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.length()/Split 

Byte+1); 
System.out.println("Will Split into "+loopCount); 
for (int i=1;i<=loopCount ;i++ ) 
{ 
if (i==loopCount){ 


System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length())); 
} else { 


System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte))); 
} 
} 
} 
public static void main(String[] args) 
{ 
SplitString ss = new SplitString("test中dd文dsaf中男大3443n中国43中国人 

0ewldfls=103",4); 
ss.SplitIt(); 
} 
} 

16、JAVA多线程编程。 用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。 
希望大家补上，谢谢 

17、STRING与STRINGBUFFER的区别。 
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法 

Jsp方面 

1、jsp有哪些内置对象?作用分别是什么? 
答:JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）： 
　request 用户端请求，此请求会包含来自GET/POST请求的参数 
response 网页传回用户端的回应 
pageContext 网页的属性是在这里管理 
session 与请求有关的会话期 
application servlet 正在执行的内容 
out 用来传送回应的输出 
config servlet的构架部件 
page JSP网页本身 
exception 针对错误网页，未捕捉的例外 

2、jsp有哪些动作?作用分别是什么? 
答:JSP共有以下6种基本动作 
jsp:include：在页面被请求的时候引入一个文件。 
jsp:useBean：寻找或者实例化一个JavaBean。 
jsp:setProperty：设置JavaBean的属性。 
jsp:getProperty：输出某个JavaBean的属性。 
jsp:forward：把请求转到一个新的页面。 
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记 

3、JSP中动态INCLUDE与静态INCLUDE的区别？ 
答：动态INCLUDE用jsp:include动作实现 
<jsp:include page="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数 
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面 
<%@ include file="included.htm" %> 

4、两种跳转方式分别是什么?有什么区别? 
答：有两种，分别为： 
<jsp:include page="included.jsp" flush="true"> 
<jsp:forward page= "nextpage.jsp"/> 
前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数.后者完全转向新页面，不会再回来。相当于go to 语句。 

Servlet方面 

1、说一说Servlet的生命周期? 
答:servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。 

2、Servlet版本间(忘了问的是哪两个版本了)的不同? 
希望大家补上，谢谢 

3、JAVA SERVLET API中forward() 与redirect()的区别？ 
答:前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。 

4、Servlet的基本架构 
public class ServletName extends HttpServlet { 
public void doPost(HttpServletRequest request, HttpServletResponse response) throws 
ServletException, IOException { 
} 
public void doGet(HttpServletRequest request, HttpServletResponse response) throws 
ServletException, IOException { 
} 
} 

Jdbc、Jdo方面 

1、可能会让你写一段Jdbc连Oracle的程序,并实现数据查询. 
答:程序如下： 
package hello.ant; 
import java.sql.*; 
public class jdbc 
{ 
String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl"; 
String theUser="admin"; 
String thePw="manager"; 
Connection c=null; 
Statement conn; 
ResultSet rs=null; 
public jdbc() 
{ 
try{ 
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); 
c = DriverManager.getConnection(dbUrl,theUser,thePw); 
conn=c.createStatement(); 
}catch(Exception e){ 
e.printStackTrace(); 
} 
} 
public boolean executeUpdate(String sql) 
{ 
try 
{ 
conn.executeUpdate(sql); 
return true; 
} 
catch (SQLException e) 
{ 
e.printStackTrace(); 
return false; 
} 
} 
public ResultSet executeQuery(String sql) 
{ 
rs=null; 
try 
{ 
rs=conn.executeQuery(sql); 
} 
catch (SQLException e) 
{ 
e.printStackTrace(); 
} 
return rs; 
} 
public void close() 
{ 
try 
{ 
conn.close(); 
c.close(); 
} 
catch (Exception e) 
{ 
e.printStackTrace(); 
} 
} 
public static void main(String[] args) 
{ 
ResultSet rs; 
jdbc conn = new jdbc(); 
rs=conn.executeQuery("select * from test"); 
try{ 
while (rs.next()) 
{ 
System.out.println(rs.getString("id")); 
System.out.println(rs.getString("name")); 
} 
}catch(Exception e) 
{ 
e.printStackTrace(); 
} 
} 
} 

2、Class.forName的作用?为什么要用? 
答：调用该访问返回一个以字符串指定类名的类的对象。 

3、Jdo是什么? 
答:JDO是Java对象持久化的新的规范，为java data object的简称,也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS)JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。 

4、在ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。 
答:一种分页方法 
<% 
int i=1; 
int numPages=14; 
String pages = request.getParameter("page") ; 
int currentPage = 1; 
currentPage=(pages==null)?(1):{Integer.parseInt(pages)} 
sql = "select count(*) from tables"; 
ResultSet rs = DBLink.executeQuery(sql) ; 
while(rs.next()) i = rs.getInt(1) ; 
int intPageCount=1; 
intPageCount=(i%numPages==0)?(i/numPages):(i/numPages+1); 
int nextPage ; 
int upPage; 
nextPage = currentPage+1; 
if (nextPage>=intPageCount) nextPage=intPageCount; 
upPage = currentPage-1; 
if (upPage<=1) upPage=1; 
rs.close(); 
sql="select * from tables"; 
rs=DBLink.executeQuery(sql); 
i=0; 
while((i<numPages*(currentPage-1))&&rs.next()){i++;} 
%> 
//输出内容 
//输出翻页连接 
合计:<%=currentPage%>/<%=intPageCount%><a href="/List.jsp?page=1">第一页</a><a 

href="List.jsp?page=<%=upPage%>">上一页</a> 
<% 
for(int j=1;j<=intPageCount;j++){ 
if(currentPage!=j){ 
%> 
<a href="list.jsp?page=<%=j%>">[<%=j%>]</a> 
<% 
}else{ 
out.println(j); 
} 
} 
%> 
<a href="List.jsp?page=<%=nextPage%>">下一页</a><a href="List.jsp?page=<%=intPageCount%>">最后页 

</a> 


Xml方面 

1、xml有哪些解析技术?区别是什么? 
答:有DOM,SAX,STAX等 
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问 
STAX:Streaming API for XML (StAX) 

2、你在项目中用到了xml技术的哪些方面?如何实现的? 
答:用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。 

3、用jdom解析xml文件时如何解决中文问题?如何解析? 
答:看如下代码,用编码方式加以解决 
package test; 
import java.io.*; 
public class DOMTest 
{ 
private String inFile = "c:/people.xml"; 
private String outFile = "c:/people.xml"; 
public static void main(String args[]) 
{ 
new DOMTest(); 
} 
public DOMTest() 
{ 
try 
{ 
javax.xml.parsers.DocumentBuilder builder = 


javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder(); 
org.w3c.dom.Document doc = builder.newDocument(); 
org.w3c.dom.Element root = doc.createElement("老师"); 
org.w3c.dom.Element wang = doc.createElement("王"); 
org.w3c.dom.Element liu = doc.createElement("刘"); 
wang.appendChild(doc.createTextNode("我是王老师")); 
root.appendChild(wang); 
doc.appendChild(root); 
javax.xml.transform.Transformer transformer = 
javax.xml.transform.TransformerFactory.newInstance().newTransformer(); 
transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312"); 
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes"); 


transformer.transform(new javax.xml.transform.dom.DOMSource(doc), 
new 

javax.xml.transform.stream.StreamResult(outFile)); 
} 
catch (Exception e) 
{ 
System.out.println (e.getMessage()); 
} 
} 
} 

4、编程用JAVA解析XML的方式. 
答:用SAX方式解析XML，XML文件如下： 
<?xml version="1.0" encoding="gb2312"?> 
<person> 
<name>王小明</name> 
<college>信息学院</college> 
<telephone>6258113</telephone> 
<notes>男,1955年生,博士，95年调入海南大学</notes> 
</person> 
事件回调类SAXHandler.java 
import java.io.*; 
import java.util.Hashtable; 
import org.xml.sax.*; 
public class SAXHandler extends HandlerBase 
{ 
private Hashtable table = new Hashtable(); 
private String currentElement = null; 
private String currentValue = null; 
public void setTable(Hashtable table) 
{ 
this.table = table; 
} 
public Hashtable getTable() 
{ 
return table; 
} 
public void startElement(String tag, AttributeList attrs) 
throws SAXException 
{ 
currentElement = tag; 
} 
public void characters(char[] ch, int start, int length) 
throws SAXException 
{ 
currentValue = new String(ch, start, length); 
} 
public void endElement(String name) throws SAXException 
{ 
if (currentElement.equals(name)) 
table.put(currentElement, currentValue); 
} 
} 
JSP内容显示源码,SaxXml.jsp: 
<HTML> 
<HEAD> 
<TITLE>剖析XML文件people.xml</TITLE> 
</HEAD> 
<BODY> 
<%@ page errorPage="ErrPage.jsp" 
contentType="text/html;charset=GB2312" %> 
<%@ page import="java.io.*" %> 
<%@ page import="java.util.Hashtable" %> 
<%@ page import="org.w3c.dom.*" %> 
<%@ page import="org.xml.sax.*" %> 
<%@ page import="javax.xml.parsers.SAXParserFactory" %> 
<%@ page import="javax.xml.parsers.SAXParser" %> 
<%@ page import="SAXHandler" %> 
<% 
File file = new File("c:/people.xml"); 
FileReader reader = new FileReader(file); 
Parser parser; 
SAXParserFactory spf = SAXParserFactory.newInstance(); 
SAXParser sp = spf.newSAXParser(); 
SAXHandler handler = new SAXHandler(); 
sp.parse(new InputSource(reader), handler); 
Hashtable hashTable = handler.getTable(); 
out.println("<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>"); 
out.println("<TR><TD>姓名</TD>" + "<TD>" + 
(String)hashTable.get(new String("name")) + "</TD></TR>"); 
out.println("<TR><TD>学院</TD>" + "<TD>" + 
(String)hashTable.get(new String("college"))+"</TD></TR>"); 
out.println("<TR><TD>电话</TD>" + "<TD>" + 
(String)hashTable.get(new String("telephone")) + "</TD></TR>"); 
out.println("<TR><TD>备注</TD>" + "<TD>" + 
(String)hashTable.get(new String("notes")) + "</TD></TR>"); 
out.println("</TABLE>"); 
%> 
</BODY> 
</HTML> 

EJB方面 

1、EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别? 
答：规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工作。JSP,Servlet,EJB,JNDI,JDBC,JMS..... 

2、EJB与JAVA BEAN的区别？ 
答:Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。 

3、EJB的基本架构 
答:一个EJB包括三个部分: 
Remote Interface 接口的代码 
package Beans; 
import javax.ejb.EJBObject; 
import java.rmi.RemoteException; 
public interface Add extends EJBObject 
{ 
//some method declare 
} 
Home Interface 接口的代码 
package Beans; 
import java.rmi.RemoteException; 
import jaax.ejb.CreateException; 
import javax.ejb.EJBHome; 
public interface AddHome extends EJBHome 
{ 
//some method declare 
} 
EJB类的代码 
package Beans; 
import java.rmi.RemoteException; 
import javax.ejb.SessionBean; 
import javx.ejb.SessionContext; 
public class AddBean Implements SessionBean 
{ 
//some method declare 
} 

J2EE,MVC方面 

1、MVC的各个部分都有那些技术来实现?如何实现? 
答:MVC是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。 

2、应用服务器与WEB SERVER的区别？ 
希望大家补上，谢谢 


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

4、WEB SERVICE名词解释。JSWDL开发包的介绍。JAXP、JAXM的解释。SOAP、UDDI,WSDL解释。 
答：Web Service描述语言WSDL 
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。 
UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。 


5、BS与CS的联系与区别。 
希望大家补上，谢谢 

6、STRUTS的应用(如STRUTS架构) 
答：Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。 采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能： 
一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。 
二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。 
三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。 

 

找工作要面试，有面试就有对付面试的办法。以下一些题目来自我和我朋友痛苦的面试经历，提这些问题的公司包括IBM, E*Trade, Siebel, Motorola, SUN, 以及其它大小公司。

　　面试是没什么道理可讲的，它的题目有的不合情理、脱离实际。有在纸上写的，有当面考你的，也有在电话里问的，给你IDE的估计很少(否则你赶快去买彩票， 说不定中)。所以如果你看完此文后，请不要抱怨说这些问题都能用IDE来解决。你必须在任何情况下准确回答这些问题，在面试中如果出现一两题回答不准确很有可能你就被拒之门外了。

　　当然这些都是Java的基本题，那些面试的人大多数不会问你Hibernate有多先进，Eclipse的三个组成部分，或command design pattern，他们都是老一辈了，最喜欢问的就是基础知识。别小看了这些基础，我朋友水平一流，结果就栽在一到基础知识的问题下，和高薪无缘。

　　好了废话少说，开始正题。

　　第一，谈谈final, finally, finalize的区别。

　　最常被问到。

　　第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

　　第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

　　第四，&和&&的区别。

　　这个问得很少。

　　第五，HashMap和Hashtable的区别。

　　常问。

　　第六，Collection 和 Collections的区别。

　　你千万别说一个是单数一个是复数。

　　第七，什么时候用assert。

　　API级的技术人员有可能会问这个。

　　第八，GC是什么? 为什么要有GC?

　　基础。

　　第九，String s = new String("xyz");创建了几个String Object?

　　第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

　　第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

　　面试题都是很变态的，要做好受虐的准备。

　　第十二，sleep() 和 wait() 有什么区别?

　　搞线程的最爱。

　　第十三，Java有没有goto?

　　很十三的问题，如果哪个面试的问到这个问题，我劝你还是别进这家公司。

第十四，数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。
String有有length()这个方法。

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

第十七，给我一个你最常见到的runtime exception。
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

第十八，error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。


第十九，List, Set, Map是否继承自Collection接口?
List，Set是
Map不是

第二十，abstract class和interface有什么区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。



第二十四，构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

第二十五，是否可以继承String类?
String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。


第二十八，编程题: 用最有效率的方法算出2乘以8等於几?
有C背景的程序员特别喜欢问这种问题。
2 << 3

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。


第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，编程题: 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
　　private Singleton(){}
　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用
　　private static Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}
第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些