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類為圖像設備編程接口類庫。