Java基礎面試題
一、面向對象的特徵有哪些方面 javascript
1.抽象：抽象就是忽略一個主題中與當前目標無關的那些方面。以便更充分地注意與當前目標有關的方面。抽象並不打算了解全部問題。而僅僅是選擇當中的一部分，臨時不用部分細節。html
抽象包含兩個方面，一是過程抽象，二是數據抽象。前端
2.繼承：繼承是一種聯結類的層次模型，並且贊成和鼓舞類的重用，它提供了一種明白表述共性的方法。java
對象的一個新類可以從現有的類中派生，這個過程稱爲類繼承。新類繼承了原始類的特性，新類稱爲原始類的派生類（子類）。而原始類稱爲新類的基類（父類）。mysql
派生類可以從它的基類那裏繼承方法和實例變量。並且類可以改動或添加新的方法使之更適合特殊的需要。c++
3.封裝：封裝是把過程和數據包圍起來。對數據的訪問僅僅能經過已定義的界面。面向對象計算始於這個基本概念，即現實世界可以被描繪成一系列全然自治、封裝的對象。這些對象經過一個受保護的接口訪問其它對象。git
4. 多態性：多態性是指贊成不一樣類的對象對同一消息做出響應。多態性包括參數化多態性和包括多態性。多態性語言具備靈活、抽象、行爲共享、代碼共享的優點，很是好的攻克了應用程序函數同名問題。web
二、String是最主要的數據類型嗎?面試
基本數據類型包含byte、int、char、long、float、double、boolean和short。算法
java.lang.String類是final類型的，所以不可以繼承這個類、不能改動這個類。爲了提升效率節省空間，咱們應該用StringBuffer類
三、int 和 Integer有什麼差異
Java 提供兩種不一樣的類型：引用類型和原始類型（或內置類型）。Int是java的原始數據類型，Integer是java爲int提供的封裝類。Java爲每個原始類型提供了封裝類。
原始類型封裝類booleanBoolean charCharacter byteByte shortShort intInteger longLong floatFloat doubleDouble
引用類型和原始類型的行爲全然不一樣，並且它們具備不一樣的語義。引用類型和原始類型具備不一樣的特徵和使用方法，它們包含：大小和速度問題，這樣的類型以哪一種類型的數據結構存儲，當引用類型和原始類型用做某個類的實例數據時所指定的缺省值。對象引用實例變量的缺省值爲 null，而原始類型實例變量的缺省值與它們的類型有關。
四、String 和StringBuffer的差異
JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操做字符串。即包括多個字符的字符數據。這個String類提供了數值不可改變的字符串。
而這個StringBuffer類提供的字符串進行改動。當你知道字符數據要改變的時候你就可以使用StringBuffer。
典型地，你可以使用StringBuffers來動態構造字符數據。
五、執行時異常與通常異常有何異同？
異常表示程序執行過程當中可能出現的非正常狀態。執行時異常表示虛擬機的一般操做中可能遇到的異常。是一種常見執行錯誤。
java編譯器要求方法必須聲明拋出可能發生的非執行時異常，但是並不要求必須聲明拋出未被捕獲的執行時異常。
六、說出Servlet的生命週期，並說出Servlet和CGI的差異。
Servlet被server實例化後，容器執行其init方法。請求到達時執行其service方法，service方法本身主動派遣執行與請求相應的doXXX方法（doGet，doPost）等，當server決定將實例銷燬的時候調用其destroy方法。
與cgi的差異在於servlet處於server進程中，它經過多線程方式執行其service方法，一個實例可以服務於多個請求。並且事實上例通常不會銷燬，而CGI對每個請求都產生新的進程，服務完畢後就銷燬。因此效率上低於servlet。
七、說出ArrayList,Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便添加和插入元素，它們都贊成直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操做，因此索引數據快而插入數據慢。Vector由於使用了synchronized方法（線程安全），一般性能上較ArrayList差。而LinkedList使用雙向鏈表實現存儲。按序號索引數據需要進行前向或後向遍歷，但是插入數據時僅僅需要記錄本項的先後項就能夠，因此插入速度較快。
八、EJB是基於哪些技術實現的？並說出SessionBean和EntityBean的差異。StatefulBean和StatelessBean的差異。
EJB包含Session Bean、Entity Bean、Message Driven Bean，基於JNDI、RMI、JAT等技術實現。
SessionBean在J2EE應用程序中被用來完畢一些server端的業務操做，好比訪問數據庫、調用其它EJB組件。
EntityBean被用來表明應用系統中用到的數據。
對於客戶機，SessionBean是一種非持久性對象。它實現某些在server上執行的業務邏輯。
對於客戶機，EntityBean是一種持久性對象，它表明一個存儲在持久性存儲器中的實體的對象視圖，或是一個由現有企業應用程序實現的實體。
Session Bean 還可以再細分爲Stateful Session Bean 與 Stateless Session Bean ，這兩種的 Session Bean都可以將系統邏輯放在 method之中運行，不一樣的是 Stateful Session Bean 可以記錄呼叫者的狀態。所以一般來講，一個使用者會有一個相相應的Stateful Session Bean 的實體。Stateless Session Bean 儘管也是邏輯組件，但是他卻不負責記錄使用者狀態，也就是說當使用者呼叫 Stateless Session Bean 的時候，EJB Container 並不會找尋特定的 StatelessSession Bean 的實體來運行這個 method。換言之，很是可能數個使用者在運行某個Stateless Session Bean 的 methods 時。會是同一個Bean 的 Instance 在運行。
從內存方面來看，Stateful Session Bean 與 Stateless Session Bean 比較。 Stateful Session Bean 會消耗 J2EEServer 較多的內存，然而 Stateful Session Bean 的優點卻在於他可以維持使用者的狀態。
九、Collection 和Collections的差異。 Collection是集合類的上級接口，繼承與他的接口主要有Set和List.
Collections是針對集合類的一個幫助類。他提供一系列靜態方法實現對各類集合的搜索、排序、線程安全化等操做。
十、&和&&的差異。 &是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）。
十一、HashMap和Hashtable的差異。
HashMap是Hashtable的輕量級實現（非線程安全的實現）。他們都完畢了Map接口，主要差異在於HashMap贊成空（null）鍵值（key）,由於非線程安全。效率上可能高於Hashtable。
HashMap贊成將null做爲一個entry的key或者value，而Hashtable不一樣意。
HashMap把Hashtable的contains方法去掉了。改爲containsvalue和containsKey。因爲contains方法easy讓人引發誤解。 Hashtable繼承自Dictionary類。而HashMap是Java1.2引進的Map interface的一個實現。
最大的不一樣是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時。不需要本身爲它的方法實現同步，而HashMap 就必須爲之提供外同步。
Hashtable和HashMap採用的hash/rehash算法都大概同樣。因此性能不會有很是大的差別。
十二、final, finally, finalize的差異。 final 用於聲明屬性，方法和類。分別表示屬性不可變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示老是運行。finalize是Object類的一個方法。在垃圾收集器運行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其它資源回收，好比關閉文件等。
1三、sleep() 和wait() 有什麼差異?
sleep是線程類（Thread）的方法，致使此線程暫停運行指定時間，給運行機會給其它線程。但是監控狀態依舊保持，到時後會本身主動恢復。
調用sleep不會釋放對象鎖。wait是Object類的方法，對此對象調用wait方法致使本線程放棄對象鎖，進入等待此對象的等待鎖定池，僅僅有針對此對象發出notify方法（或notifyAll）後本線程才進入對象鎖定池準備得到對象鎖進入運行狀態。
1四、Overload和Override的差異。Overloaded的方法可否夠改變返回值的類型?
方法的重寫Overriding和重載Overloading是Java多態性的不一樣表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。假設在子類中定義某方法與其父類有一樣的名稱和參數。咱們說該方法被重寫(Overriding)。
子類的對象使用這種方法時，將調用子類中的定義，對它而言，父類中的定義如同被「屏蔽」了。假設在一個類中定義了多個同名的方法。它們或有不一樣的參數個數或有不一樣的參數類型，則稱爲方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。
1五、error和exception有什麼差異?
error 表示恢復不是不可能但很是困難的狀況下的一種嚴重問題。
比方說內存溢出。
不可能期望程序能處理這種狀況。
exception 表示一種設計或實現問題。也就是說，它表示假設程序執行正常，從不會發生的狀況。
1六、同步和異步有何異同。在什麼狀況下分別使用他們？舉例說明。
假設數據將在線程間共享。好比正在寫的數據之後可能被還有一個線程讀到，或者正在讀的數據可能已經被還有一個線程寫過了。那麼這些數據就是共享數據，必須進行同步存取。當應用程序在對象上調用了一個需要花費很是長時間來運行的方法，並且不但願讓程序等待方法的返回時，就應該使用異步編程，在很是多狀況下採用異步途徑每每更有效率。
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
1七、abstract class和interface有什麼差異?聲明方法的存在而不去實現它的類被叫作抽象類（abstract class）。它用於要建立一個體現某些基本行爲的類，併爲該類聲明方法，但不能在該類中實現該類的狀況。
不能建立abstract 類的實例。
然而可以建立一個變量，其類型是一個抽象類，並讓它指向詳細子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract類的子類爲它們父類中的所有抽象方法提供實現，不然它們也是抽象類爲。取而代之，在子類中實現該方法。
知道其行爲的其餘類可以在類中實現這些方法。
接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可經過實現這種接口而得到。
接口中的所有方法都是抽象的。沒有一個有程序體。接口僅僅可以定義staticfinal成員變量。
接口的實現與子類類似，除了該實現類不能從接口定義中繼承行爲。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。而後，它可以在實現了該接口的類的不論什麼對象上調用接口的方法。由於有抽象類，它贊成使用接口名做爲引用變量的類型。一般的動態聯編將生效。引用可以轉換到接口類型或從接口類型轉換。instanceof運算符可以用來決定某對象的類是否實現了接口。
{
1. 一樣及聯繫
A. 二者都是抽象類。都不能實例化。
B. interface實現類及abstrct class的子類都必須要實現已經聲明的抽象方法。
2. 不一樣
A. interface需要實現，要用implements，而abstract class需要繼承。要用extends。
B. 一個類可以實現多個interface，但一個類僅僅能繼承一個abstract class。
C. interface強調特定功能的實現。而abstract class強調所屬關係。
D. 雖然interface實現類及abstrct class的子類都必須要實現對應的抽象方法。但實現的形式不一樣。
interface中的每一個方法都是抽象方法，都僅僅是聲明的(declaration,沒有方法體)。實現類必須要實現。
而abstract class的子類可以有選擇地實現。這個選擇有兩點含義：
一是Abastractclass中並非所有的方法都是抽象的。僅僅有那些冠有abstract的方法纔是抽象的，子類必須實現。那些沒有abstract的方法，在Abstrct class中必須定義方法體。
二是abstractclass的子類在繼承它時，對非抽象方法既可以直接繼承，也可以覆蓋；而對抽象方法，可以選擇實現，也可以經過再次聲明其方法爲抽象的方式，無需實現。留給其子類來實現，但此類必須也聲明爲抽象類。
既是抽象類，固然也不能實例化。
E. abstract class是interface與Class的中介。
interface是全然抽象的。僅僅能聲明方法。而且僅僅能聲明pulic的方法，不能聲明private及protected的方法，不能定義方法體，也不能聲明實例變量。
然而，interface卻可以聲明常量變量，而且在JDK中不難找出這樣的樣例。但將常量變量放在interface中違背了其做爲接口的做用而存在的宗旨。也混淆了interface與類的不一樣價值。假設的確需要，可以將其放在對應的abstract class或Class中。
abstract class在interface及Class中起到了承上啓下的做用。一方面。abstract class是抽象的，可以聲明抽象方法，以規範子類必須實現的功能；還有一方面，它又可以定義缺省的方法體，供子類直接使用或覆蓋。另外，它還可以定義本身的實例變量，以供子類經過繼承來使用。
3. interface的應用場合
A. 類與類以前需要特定的接口進行協調，而不在意其怎樣實現。
B. 做爲能夠實現特定功能的標識存在。也能夠是什麼接口方法都沒有的純粹標識。
C. 需要將一組類視爲單一的類。而調用者僅僅經過接口來與這組類發生聯繫。
D. 需要實現特定的多項功能。而這些功能之間可能全然沒有不論什麼聯繫。
4. abstract class的應用場合
一句話。在既需要統一的接口，又需要實例變量或缺省的方法的狀況下，就可以使用它。最多見的有：
A. 定義了一組接口。但又不想強迫每個實現類都必須實現所有的接口。可以用abstract class定義一組方法體，甚至可以是空方法體，而後由子類選擇本身所感興趣的方法來覆蓋。
B. 某些場合下。僅僅靠純粹的接口不能知足類與類之間的協調。還必需類中表示狀態的變量來差異不一樣的關係。abstract的中介做用可以很是好地知足這一點。
C. 規範了一組相互協調的方法，當中一些方法是共同的，與狀態無關的，可以共享的。無需子類分別實現；而還有一些方法卻需要各個子類依據本身特定的狀態來實現特定的功能
}
1八、heap和stack有什麼差異。棧是一種線形集合，其加入和刪除元素的操做應在同一段完畢。棧依照後進先出的方式進行處理。堆是棧的一個組成元素
{
1.heap是堆，stack是棧。
2.stack的空間由操做系統本身主動分配和釋放，heap的空間是手動申請和釋放的，heap常用newkeyword來分配。
3.stack空間有限，heap的空間是很是大的自由區。
在Java中。
若僅僅是聲明一個對象，則先在棧內存中爲其分配地址空間，
若再new一下，實例化它，則在堆內存中爲其分配地址。
4.舉例：
數據類型 變量名。這樣定義的東西在棧區。
如：Object a =null; 僅僅在棧內存中分配空間
new 數據類型();或者malloc(長度); 這樣定義的東西就在堆區
如：Object b =new Object(); 則在堆內存中分配空間
}
1九、forward 和redirect的差異forward是server請求資源，server直接訪問目標地址的URL，把那個URL的響應內容讀取過來，而後把這些內容再發給瀏覽器，瀏覽器根本不知道server發送的內容是從哪兒來的，因此它的地址欄中仍是原來的地址。redirect就是服務端依據邏輯,發送一個狀態碼,告訴瀏覽器又一次去請求那個地址。通常來講瀏覽器會用剛纔請求的所有參數又一次請求，因此session,request參數都可以獲取。
20、EJB與JAVABEAN的差異？Java Bean 是可複用的組件。對JavaBean並無嚴格的規範。理論上講。不論什麼一個Java類都可以是一個Bean。但一般狀況下，由於Java Bean是被容器所建立（如Tomcat）的，因此Java Bean應具備一個無參的構造器，另外，一般JavaBean還要實現Serializable接口用於實現Bean的持久性。
Java Bean實際上至關於微軟COM模型中的本地進程內COM組件。它是不能被跨進程訪問的。
EnterpriseJava Bean 至關於DCOM。即分佈式組件。它是基於Java的遠程方法調用（RMI）技術的，因此EJB可以被遠程訪問（跨進程、跨計算機）。但EJB必須被佈署在諸如Webspere、WebLogic這種容器中，EJB客戶從不直接訪問真正的EJB組件，而是經過其容器訪問。EJB容器是EJB組件的代理，EJB組件由容器所建立和管理。
客戶經過容器來訪問真正的EJB組件。
2一、Static Nested Class 和 Inner Class的不一樣。
Static Nested Class是被聲明爲靜態（static）的內部類，它可以不依賴於外部類實例被實例化。
而一般的內部類需要在外部類實例化後才幹實例化。
2二、JSP中動態INCLUDE與靜態INCLUDE的差異？動態INCLUDE用jsp:include動做實現 <jsp:includepage="included.jsp" flush="true" />它老是會檢查所含文件裏的變化，適合用於包括動態頁面，並且可以帶參數。靜態INCLUDE用include僞碼實現,定不會檢查所含文件的變化，適用於包括靜態頁面<%@include file="included.htm" %>
2三、何時用assert。
assertion(斷言)在軟件開發中是一種常用的調試方式。很是多開發語言中都支持這樣的機制。
在實現中。assertion就是在程序中的一條語句。它對一個boolean表達式進行檢查。一個正確程序必須保證這個boolean表達式的值爲true；假設該值爲false，說明程序已經處於不對的狀態下，系統將給出警告或退出。通常來講，assertion用於保證程序最基本、關鍵的正確性。assertion檢查一般在開發和測試時開啓。爲了提升性能，在軟件公佈後，assertion檢查通常是關閉的。
2四、GC是什麼? 爲何要有GC? GC是垃圾收集的意思（Garbage Collection）,內存處理是編程人員easy出現故障的地方，忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰。Java提供的GC功能可以本身主動監測對象是否超過做用域從而達到本身主動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操做方法。
2五、short s1 = 1; s1 = s1 + 1;有什麼錯?
short s1 = 1; s1 += 1;有什麼錯? short s1 = 1; s1 = s1 + 1; （s1+1運算結果是int型，需要強制轉換類型） short s1 = 1; s1 += 1;（可以正確編譯）
{
當使用+=、-=、*=、/=、%=、運算符對基本類型進行運算時，遵循例如如下規則：
• 運算符右邊的數值將首先被強制轉換成與運算符左邊數值一樣的類型，而後再運行運算，
且運算結果與運算符左邊數值類型一樣。
在s1=s1+1;中，s1+1
運算的結果是int型，把它賦值給一個 short型變量s1，因此會報錯。而在s1+=1;中，由於
是s1是short類型的，因此1首先被強制轉換爲short型，而後再參與運算，並且結果也是
short類型的，所以不會報錯。那麼。s1=1+1;爲何不報錯呢？這是因爲1+1是個編譯時可
以肯定的常量，「+」運算在編譯時就被運行了。而不是在程序運行的時候，這個語句的效果
等同於s1=2，因此不會報錯。前面講過了，對基本類型運行強制類型轉換可能得出錯誤的
結果。所以在使用+=、 -=、*=、/=、%=等運算符時，要多加註意。
}
2六、Math.round(11.5)等於多少?
Math.round(-11.5)等於多少? Math.round(11.5)==12 Math.round(-11.5)==-11 round方法返回與參數最接近的長整數，參數加1/2後求其floor.
2七、String s = newString("xyz");建立了幾個String Object?
兩個
2八、設計4個線程，當中兩個線程每次對j添加1，另外兩個線程對j每次下降1。寫出程序。
下面程序使用內部類實現線程。對j增減的時候沒有考慮順序問題。
public class ThreadTest1{private int j; public static void main(String args[]){ ThreadTest1 tt=new ThreadTest1(); Inc inc=tt.new Inc(); Dec dec=tt.new Dec(); for(int i=0;i<2;i++){ Thread t=new Thread(inc); t.start(); t=new Thread(dec); t.start(); } } privatesynchronized void inc(){ j++; System.out.println(Thread.currentThread().getName()+"-inc:"+j); }
privatesynchronized void dec(){ j--; System.out.println(Thread.currentThread().getName()+"-dec:"+j); }
class Inc implements Runnable{ public void run(){ for(int i=0;i<100;i++){ inc(); } } } class Dec implementsRunnable{public void run(){ for(inti=0;i<100;i++){ dec(); } } } }
2九、Java有沒有goto?
java中的保留字，現在沒有在java中使用。
30、啓動一個線程是用run()仍是start()?
啓動一個線程是調用start()方法。使線程所表明的虛擬處理機處於可執行狀態。這意味着它可以由JVM調度並執行。這並不意味着線程就會立刻執行。run()方法可以產生必須退出的標誌來中止一個線程。
{
啓動一個線程是調用start()方法。這並不意味着線程就會當即執行，僅僅是進入了可執行狀態。
直接調用run()方法不會產生線程，而是把它看成普通的方法調用，當即執行。
}
3一、EJB包含（SessionBean,EntityBean）說出他們的生命週期，及怎樣管理事務的？
SessionBean：StatelessSession Bean 的生命週期是由容器決定的，當客戶機發出請求要創建一個Bean的實例時。EJB容器不必定要建立一個新的Bean的實例供客戶機調用。而是隨便找一個現有的實例提供給客戶機。當客戶機第一次調用一個Stateful Session Bean時。容器必須立刻在server中建立一個新的Bean實例，並關聯到客戶機上，之後此客戶機調用StatefulSession Bean 的方法時容器會把調用分派到與此客戶機相關聯的Bean實例。EntityBean：Entity Beans能存活相對較長的時間，並且狀態是持續的。僅僅要數據庫中的數據存在，Entity beans就一直存活。
而不是依照顧用程序或者服務進程來講的。即便EJB容器崩潰了，Entity beans也是存活的。Entity Beans生命週期能夠被容器或者 Beans本身管理。
EJB經過下面技術管理實務：對象管理組織（OMG）的對象實務服務（OTS），Sun Microsystems的TransactionService（JTS）、Java TransactionAPI（JTA），開發組（X/Open）的XA接口。
3二、應用server有那些？
BEA WebLogic Server。IBM WebSphereApplication Server，Oracle9i Application Server，jBoss，Tomcat
3三、給我一個你最多見到的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
34、接口是否可繼承接口? 抽象類是否可實現(implements)接口?
接口可以繼承接口。抽象類可以實現(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明白的構造函數。
{
答案很是明白。可以繼承。事實上從Object就是個實體類，java的API文檔裏，每個抽象類的條目裏都明白寫着直接或間接繼承自Object，因此這點是沒有疑問的。
關鍵在於這答案裏所說的「前提是實體類必須有明白的構造函數」一句，是什麼意思。
通常學習者會寫的簡單試驗代碼：
class A{}
abstract class B extends A{}
結果全然正常。編譯經過。
彷佛和「實體類必須有明白的構造函數」全然沒有關係。
這個問題涉及到兩個個基礎知識：
1.
所有的class都必須有一個構造方法，假設你沒有在代碼裏聲明構造方法，系統會本身主動給你生成一個公有無參的構造方法。
而僅僅要你本身聲明瞭一個構造方法，無論有參無參，私有公有，系統就再也不幫你生成默認無參構造器了。
2.
所有的子類構造器都要求在第一行代碼中調用父類構造器。假設不寫。系統默認去調用父類的無參構造器。
因此，假設把系統默認配給的方法也算進去。class A{}的代碼其實是
class A{
public A(){}
}
B繼承 A的時候，則是
abstract class B extends A{
public B(){
super();
}
}
要試驗出這繼承規則的內部狀況，也很是easy，在最上面那個簡單試驗代碼裏。加上個私有構造器，有參無參都行。
class A{
private A(){}
}
這個時候，如基礎知識(1)中所說，系統再也不給你默認無參構造器， B的構造器依據（2）中的規則去調用super()，卻找不到A的無參構造器，因此致使abstract class Bextends A{} 編譯不能經過。（因爲A中沒有不論什麼構造器可供子類調用，事實上這個時候A僅僅能夠供內部類繼承。我用的Eclipse的3.4版本號會建議給B更名，但是這解決不了這個問題。）
現在。你應該瞭解了資料給的那句語焉不詳的「實體類必須有明白的構造函數」的含義：
1.沒寫構造器的，那是擁有默認無參公有構造函數的。子類可以什麼都不寫。讓默認構造器去調用它。
這是最初那兩行代碼的狀況。
2.寫了子類可訪問的無參構造器的，也是同樣。子類裏可以什麼都不寫，用默認機制調用。
3.寫了有參構造器卻沒寫無參構造器的，父類裏沒有子類可訪問的無參構造器。子類必須在子類構造器裏的第一句寫明，調用父類有參構造器，並把參數傳進去。
4.聲明爲final的以及所有構造器都不在子類訪問權限以內的類沒法繼承
事實上僅僅要是在類的繼承中。無論抽象仍是實體。都需要符合這個規則的。在這個繼承試驗中隨時刪掉或是加上abstract的前綴，結果都沒有變化。
我的認爲「實體類必須有明白的構造函數」一句實在是沒法把這個狀況表達清楚，因此廣大求職者仍是寫得清楚些好。
我喜歡的寫法是「可以繼承。但是和實體類的繼承同樣。也要求父類可繼承，並且擁有子類可訪問到的構造器。」
}
3五、List, Set, Map是否繼承自Collection接口? List，Set是，Map不是
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
3六、說出數據鏈接池的工做機制是什麼?
J2EEserver啓動時會創建必定數量的池鏈接。並一直維持很多於此數目的池鏈接。
client程序需要鏈接時，池驅動程序會返回一個未使用的池鏈接並將其表記爲忙。假設當前沒有空暇鏈接，池驅動程序就新建必定數量的鏈接。新建鏈接的數量有配置參數決定。當使用的池鏈接調用完畢後，池驅動程序將此鏈接表記爲空暇，其它調用就可以使用這個鏈接。
3七、abstract的method是否可同一時候是static,是否可同一時候是native，是否可同一時候是synchronized?
都不能
{
這個問題要從實際的邏輯角度去看的，首先要了解abstract。static，synchronized。native這些keyword幹什麼用的。
abstract是抽象的，指的是方法僅僅有聲明而沒有實現，它的實現要放入聲明該類的子類中實現。
static是靜態的，是一種屬於類而不屬於對象的方法或者屬性，而咱們知道，類事實上也是一個對象，他是在class文件載入到虛擬機之後就會產生的對象。一般來講它是單例的。就是整個虛擬機中僅僅有一個這種類對象（固然，假設用新的類載入器也會生成新的類的對象）。
synchronized 是同步，是一種相對線程的鎖。
native 本地方法，這樣的方法和抽象方法及其相似，它也僅僅有方法聲明。沒有方法實現，但是它與抽象方法不一樣的是。它把詳細實現移交給了本地系統的函數庫，而沒有經過虛擬機。可以說是java與其餘語言通信的一種機制。
那麼咱們就來談談這些keyword爲何不能和abstract混用。
首先abstract與static，事實上一看他們的做用和屬性就很是easy辨別。abstract是沒有實現的。而static必定要有實現。因爲abstract的類不能生產對象。但是static是屬於類，而類已是一個存在的對象，這兩個keyword在這上面有一個關鍵的矛盾點。
synchronized 是同步，然而同步是需要有詳細操做才幹同步的，假設像abstract僅僅有方法聲明，那同步一些什麼東西就會成爲一個問題了，固然抽象方法在被子類繼承之後，可以加入同步。
native，這個東西自己就和abstract衝突，他們都是方法的聲明，僅僅是一個吧方法實現移交給子類，還有一個是移交給本地操做系統。假設同一時候出現。就至關於即把實現移交給子類，又把實現移交給本地操做系統，那究竟誰來實現詳細方法呢？
}
3八、數組有沒有length()這種方法?String有沒有length()這種方法？數組沒有length()這種方法。有length的屬性。String有有length()這種方法。
3九、Set裏的元素是不能反覆的。那麼用什麼方法來區分反覆與否呢?是用==仍是equals()?
Set裏的元素是不能反覆的，那麼用iterator()方法來區分反覆與否。
equals()是判讀兩個Set是否相等。equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，爲的是當兩個分離的對象的內容和類型相配的話，返回真值。
{
Set是Collection容器的一個子接口，它不一樣意出現反覆元素，固然也僅僅贊成有一個null對象。
equals 方法（是String類從它的超類Object中繼承的）被用來檢測兩個對象是否相等，即兩個對象的內容是否相等。
==用於比較引用和比較基本數據類型時具備不一樣的功能：
比較基本數據類型，假設兩個值一樣，則結果爲true
equals 方法是 java.lang.Object類的方法。
有兩種使用方法說明：
一.對於字符串變量來講，
使用「==」和「equals()」方法比較字符串時。其比較方法不一樣。
「==」比較兩個變量自己的值。即兩個對象在內存中的首地址。
「equals()」比較字符串中所包括的內容是否一樣。
比方：
String s1,s2,s3 ="abc", s4 ="abc" ;
s1 = newString("abc");
s2 = newString("abc");
那麼：
s1==s2 是false //兩個變量的內存地址不同，也就是說它們指向的對象不同樣，
故不相等。
s1.equals(s2) 是true //兩個變量的所包括的內容是abc，故相等。
注意（1）：
假設： StringBuffer s1 = new StringBuffer("a");
StringBuffer s2 = new StringBuffer("a");
結果： s1.equals(s2) //是false
解釋：StringBuffer類中沒有又一次定義equals這種方法，所以這種方法就來自Object類。
而Object類中的equals方法是用來比較「地址」的，因此等於false.
注意（2）：
對於s3和s4來講，有一點不同要引發注意，由於s3和s4是兩個字符
串常量所生成的變量，當中所存放的內存地址是相等的，
因此s3==s4是true（即便沒有s3=s4這樣一個賦值語句）
二.對於非字符串變量來講。
"=="和"equals"方法的做用是一樣的，都是用來比較其對象在堆內存的首地址。即用來比較兩個引用變量是否指向同一個對象。
比方：
class A
{
A obj1 = new A();
A obj2 = new A();
}
那麼：obj1==obj2是false
obj1.equals(obj2)是false
但是如加上這樣一句：obj1=obj2;
那麼 obj1==obj2是true
obj1.equals(obj2) 是true
總之：equals方法對於字符串來講是比較內容的。而對於非字符串來講是比較
其指向的對象是否一樣的。
== 比較符也是比較指向的對象是否一樣的也就是對象在對內存中的的首地址。
String類中又一次定義了equals這種方法，而且比較的是值。而不是地址。因此是true。
關於equals與==的差異從下面幾個方面來講：
（1）假設是基本類型比較，那麼僅僅能用==來比較，不能用equals
比方：
public class TestEquals {
public static void main(String[] args)
{
int a = 3;
int b = 4;
int c = 3;
System.out.println(a == b);//結果是false
System.out.println(a == c);//結果是true
System.out.println(a.equals(c));//錯誤，編譯不能經過，equals方法
//不能運用與基本類型的比較
}
}
（2）對於基本類型的包裝類型，比方Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用變量，==是比較地址的，而equals是比較內容的。比方：
public class TestEquals {
public static void main(String[] args)
{ Integer n1 = new Integer(30);
Integer n2 = new Integer(30);
Integer n3 = new Integer(31);
System.out.println(n1 == n2);//結果是false兩個不一樣的Integer對象。故其地址不一樣，
System.out.println(n1 == n3);//那麼不管是new Integer(30)仍是new Integer(31)結果都顯示false
System.out.println(n1.equals(n2));//結果是true依據jdk文檔中的說明。n1與n2指向的對象中的內容是相等的，都是30，故equals比較後結果是true
System.out.println(n1.equals(n3));//結果是false因對象內容不同，一個是30一個是31
}
}
這是Integer的實例，假設是其它的比方Double、Character、Float等也同樣。
（3）注意：對於String(字符串)、StringBuffer(線程安全的可變字符序列)、StringBuilder(可變字符序列)這三個類做進一步的說明。
（a）首先，介紹String的使用方法。請看如下的實例：
public class TestEquals {
public static void main(String[] args) {
String s1 = "123";
String s2 = "123";
String s3 = "abc";
String s4 = new String("123");
String s5 = new String("123");
String s6 = new String("abc");
System.out.println(s1 == s2);//（1）true
System.out.println(s1.equals(s2));//（2）true
System.out.println(s1 == s3);//（3）flase
System.out.println(s1.equals(s3));//（4）flase
System.out.println(s4 == s5);//（5）flase
System.out.println(s4.equals(s5));//（6）true
System.out.println(s4 == s6);//（7）flase
System.out.println(s4.equals(s6));//（8）flase
System.out.println(s1 == s4);//（9）false
System.out.println(s1.equals(s4));//（10）true
}
}
答案解釋：s1與s2分別指向由字符串常量」123」建立的對象。在常量池中，僅僅有一個對象，內容爲123。有兩個引用s1和s2指向這個對象，故這兩個引用變量所指向的地址是一樣的，於是（1）處的執行結果爲true。又因爲s1.equals(s2)是比較s1和s2所指向的對象的內容是否相等，而咱們知道這兩個對象的內容都是字符串常量」123」，故標記（2）處的執行結果是true。
用相同的方法分析，s1和s3所指向的對象不同，內容也不同，故標記（3）和（4）處執行結果是false。
再看看s4和s5，這兩個引用變量所指向的對象的內容都是同樣的（內容都是123），但是這兩個對象是用new操做符建立處類的。是在內存中分配兩塊空間給這兩個對象的。於是這兩個對象的內存地址不同，故事兩個不一樣的對象，標記（5）處的s4 == s5 執行結果爲false，但是內容同樣。故標記（6）處的s4.equals(s5)執行結果爲true。同理，s4和s6所指向的對象地址不一樣，內容也不一樣樣。故標記（7）（8）處執行結果爲false。
s1和s4分別指向兩個不一樣的對象（之因此這樣稱呼，是因爲這兩個對象在內存中的地址不一樣樣。故而對象不一樣樣）。故標記爲（9）處的s1 == s4執行結果爲false。
總結：
（1）對字符變量來講：
「==」比較兩個變量自己的值，即兩個對象在內存中的首地址。
「equals()」比較字符串中所包括的內容是否一樣
（StringBuffer類中沒有又一次定義equals這種方法，所以這種方法就來自Object類，而Object類中的equals方法是用來比較「地址」的。
String類中定義又一次定義了equals這種方法，比較的是「值」不是「地址」。）
（2）對非字符變量來講：
"=="和"equals"方法的做用是一樣的，都是用來比較其對象在堆內存的首地址，即用來比較兩個引用變量是否指向同一個對象。
}
40、構造器Constructor是否可被override?構造器Constructor不能被繼承。所以不能重寫Overriding，但可以被重載Overloading。
{
爲何構造器不能是abstract, static, final, native orsynchronized的？
2008-01-24 00:11
Unlike methods, a constructor cannot beabstract, static, final, native or synchronized.
1. A constructor is not inherited, so there is no need to declare it final
2. As the same reason above, an abstract constructor could never beimplemented.
3. A constructor is always invoked with respect to an object, so it makes nosense for a constructor to be static.
4. There is no practical need for a constructor to be synchronized, because itwould lock the object under construction, which is normally not made availableto other threads until all constructors for the object have completed theirwork.
5. The lack of native constructors is an arbitrary language design choice thatmakes it easy for an implementation of the Java virtual machine to verify thatsuperclass constructors are always properly invoked during object creation.
翻譯例如如下：
不一樣於方法，構造器不能是abstract, static, final, native, strictfp, 或者synchronized的.
1.構造器不是經過繼承獲得的。因此沒有必要把它聲明爲final的。
2.同理。一個抽象的構造器將永遠不會被實現。（因此也不能聲明爲abstract的）
3.構造器老是關聯一個對象而被調用。因此把它聲明爲static是沒有意義的。
4.沒有實際的需要把構造器定義成同步的。因爲它將會在構造的時候鎖住該對象，直到所有的構造器完畢它們的工做，這個構造的過程對其餘線程來講，通常是不可訪問的。
5.沒有本地的構造器是隨意一種語言的設計選擇，這樣會使得在建立對象的過程當中JVM實現很是easy去校驗父類的構造器是否老是被正確地調用了。
（本地化的方法狀況特別複雜。因此JVM調用起來很是麻煩。需要考慮很是多種狀況。沒有nativekeyword的狀況下，JVM實現起來比較easy。）
}
4一、可否夠繼承String類?String類是final類故不可以繼承。
4二、swtich可否做用在byte上。可否做用在long上。可否做用在String上?switch（expr1）中。expr1是一個整數表達式。所以傳遞給 switch 和 case 語句的參數應該是 int、 short、char 或者 byte。long,string 都不能做用於swtich。
{
在switch（expr1）中。expr1僅僅能是一個整數表達式或者枚舉常量（更大字體）。整數表達式可以是int基本類型或Integer包裝類型，由於，byte,short,char都可以隱含轉換爲int，因此。這些類型以及這些類型的包裝類型也是可以的。顯然。long和String類型都不符合switch的語法規定，並且不能被隱式轉換成int類型，因此。它們不能做用於swtich語句中。
}
4三、try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被運行，何時被運行，在return前仍是後?會運行，在return前運行。
{
如下是個測試程序
public class FinallyTest
{
publicstatic void main(String[] args) {
System.out.println(newFinallyTest().test());;
}
{
intx = 1;
try
{
x++;
returnx;
}
finally
{
++x;
}
}
}
結果是2，意思是finally裏的代碼沒運行？
最佳答案
確定運行了
你在finally里加一條輸出語句你就知道了
但結果爲何會是2呢？
在try語句中，在運行return語句時，要返回的結果已經準備好了。就在此時，程序轉到finally運行了。
在轉去以前，try中先把要返回的結果存放到不一樣於a的局部變量中去。運行完finally以後，在從中取出返回結果，
所以，即便finally中對變量a進行了改變，但是不會影響返回結果。
它應該使用棧保存返回值。
}
4四、編程題: 用最有效率的方法算出2乘以8等於幾?
2 << 3
{
有C背景的程序猿特別喜歡問這樣的問題。
2<< 3
粗看彷佛很是在理，大體想來2<<3會是移位操做，在Java的字節碼中移位指令是ishl（右移），而在CPU上的硬件指令可能就會是shl（算術右移指令）。
事實上否則。假設熟悉彙編語言，還考慮過編譯優化，2<<3根本不會使用移位操做。而是在編譯時就優化計算出16來了。
但假設是寫成這種方式（int i = 2; int j = i<<2;）。又是不同的，你們可以從代碼不一樣寫法生成的Java操做指令或彙編指令看出個端倪。
| Java代碼 |
相應的字節碼指令 |
說明 |
| int i = 2 << 3; |
0: bipush 16 |
編譯時就把2左移3位的置算出來了，可以說減小了編譯時效率 |
| int i = 2 * 8; |
與上同 |
|
| int i = 2; |
0: iconst_2 |
常量2壓棧 |
| int i = 2; |
0: iconst_2 |
javac 生成的字節碼操做指令是 imul，javac未做優化 |
因此把代碼寫成int i = 2 << 3，和寫成 int i = 16;是同樣的。前者還有減小了編譯時效率
如下再舉例說明一下，VC++編譯器。事實上也會做這種優化
| C++ 代碼 |
相應的彙編指令 |
說明 |
| int i = 2 << 3; |
mov dword ptr [ebp-4],10h |
也是把2<<3算出來了。爲16（10h），放入內存 |
| int i = 2 * 8; |
與上同 |
|
| int i = 2; |
mov dword ptr [ebp-4],2 |
把2放入內存中 SS:[ebp-4] |
| int i = 2; |
與上同 |
VC++本身主動優化成移位操做，因爲8爲2的整數次冪 |
| int i = 2; |
mov dword ptr [ebp-4],2 |
生成的彙編指令爲 imul ,因爲9不是2的整數次冪 |
因此從回答說是int i = 2 << 3;並沒改變一點運行上的效率，因爲它 int i = 16; 是全然同樣的。但假設寫成
int i = 2;
int j = i << 3;
比寫成
int i = 2;
int j = i * 8:
確實會提升必定的運行效率。因爲 i * 8,要用Java操做指令 imul 進行運算，這也僅僅是說JDK的編譯器javac是這麼處理的。
JDK編譯時並無 i * 8 優化成 i << 3。
假設把代碼換成是C++代碼,也是寫成
int i = 2;
int j = i * 8:
由VC++編譯出來的彙編指令代碼也仍是用shl eax, 3。它和寫成 intj = i << 3 全一致的。
VC++從效率出發已經給你做了這種代優化，再回味一下這個問題的答案中的一句話「有C背景的程序猿特別喜歡問這種問題。」。可以獲知那個有C背景的程序猿在這裏耍了一個「小聰明」。卻又沒有佔到一點小廉價，僅僅因爲他低估了編譯器的優化功能。
之因此問這樣問題的人。他們僅僅是基於這樣一個事實。整數乘法或整數除法所需要的時鐘週期遠遠大於移位操做所需的時鐘週期，如下列出這個指令的基本運行時間：
移位指令寄存器移 1位時鐘週期數爲 2
整數乘法IMUL 16位寄存器乘時鐘週期爲 128 ~ 154
整數除法IDIV 16位寄存器時鐘週期爲 165 ~ 184
而即便Java編譯器在編譯 intj = i * 8; 時用的是imul，但真正運行這這段代碼，由虛擬機JVM轉換成本地代碼是時候會不會進一步優化成用移位操做的彙編指也未得而知。必要時固然可追蹤一下java.exe的運行過程。即便運行時會做此優化，在java中把 int j = i * 8 寫成 int j = i <<3，可獲取一點點的效率。微不足道。
任外，在VisualC++ .net 2003,還添加了對Intel Pentium 4和 AMD Athlon的代碼優化，當用 /G7編譯時。可以產生了更快（但更長）的指令序列，避免了使用 imul指令。該指令在 Intel Pentium 4上具備 14個週期的滯後時間。
如 i* 9,可能被編譯成例如如下代碼
mov ecx, dword ptr _i＄[esp-4]
mov eax, ecx
shl eax, 3
add eax, ecx
原本應該是imul乘法指令，用/G7編譯選項巧妙的生成了先左移3位。再加上原來的值。網上介紹的是這麼說的，可以我在VisualC++ .net 2003,用/G7選項編譯時卻沒有生成與上相似的彙編代碼。仍然是生成的 imul指令。
}
4五、兩個對象值一樣(x.equals(y) == true)，但卻可有不一樣的hash code。這句話對不正確?不正確，有一樣的hash code。
{
1.equals() 和hashCode() 是2個不一樣的方法，要實現 "(x.equals(y) == true)，但卻可有不一樣的hash code " 是能作到的。
2. 但這樣作很很差。
在 Hashtable 中是這樣使用 equals() 和 hashCode() 的：get 和 put 時。首先使用 hashCode() 進行在 keys 中定位和查找，這樣會提升查找效率。假設現有多個 key 的hashCode 一樣，再用equals 在具備一樣hashCode 的這幾個 key中進行依次查找。
也就是說，java中的設計思想是：贊成不一樣對象有一樣的 hashCode()，但是 equal 的對象的 hashCode 確定是一樣的。
equals() 在 java 中被以爲：對象之間"如出一轍"。
這句話在java語法上對，在java規範上錯
}
4六、當一個對象被看成參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏到底是值傳遞仍是引用傳遞?是值傳遞。
Java 編程語言僅僅有值傳遞參數。當一個對象實例做爲一個參數被傳遞到方法中時，參數的值就是對該對象的引用。
對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的。
4七、當一個線程進入一個對象的一個synchronized方法後，其餘線程是否可進入此對象的其餘方法?
不能，一個對象的一個synchronized方法僅僅能由一個線程訪問。
{
本人以爲有些所答非所問。
故寫了兩個demo進行測試。
發現答案要分三種狀況討論。
狀況一：
當一個線程進入一個對象的一個synchronized方法後，其餘線程訪問該對象的非同步方法。
代碼例如如下：
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod()
{
System.out.println("Invoked synchronizedMethod!") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void generalMethod()
{
System.out.println("Invoked generalMethod ...");
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadOne implements Runnable {
private InvokedObject object ;
public ThreadOne(InvokedObject object)
{
this.object = object ;
}
public void run() {
object.synchronizedMethod() ;
}
}
額但願用得上。。。
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadTwo implements Runnable {
private InvokedObject object ;
public ThreadTwo(InvokedObject object)
{
this.object = object ;
}
public void run() {
// TODO Auto-generated method stub
object.generalMethod() ;
}
}
package com.mutithreading.client;
import com.mutithreading.Object.InvokedObject;
import com.mutithreading.threads.ThreadOne;
import com.mutithreading.threads.ThreadTwo;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
InvokedObject object = new InvokedObject() ;
ThreadOne one = new ThreadOne(object) ;
ThreadTwo two = new ThreadTwo(object) ;
Thread threadOne = new Thread(one) ;
Thread threadTwo = new Thread(two) ;
threadOne.start() ;
threadTwo.start() ;
}
}
執行結果：
一個線程在訪問一個對象的同步方法時，還有一個線程可以同一時候訪問這個對象的非同步方法。
狀況二：
當一個線程進入一個對象的一個synchronized方法後。其餘線程也訪問該同步方法。
執行結果：
一個線程在訪問一個對象的同步方法時。還有一個線程不能同一時候訪問這個同步方法。（代碼略）
狀況三：
當一個線程進入一個對象的一個synchronized方法後，其餘線程同一時候訪問該對象的還有一個同步方法。
此處僅給出對InvokedObject類作出的改動代碼：
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod1()
{
System.out.println("Invoked synchronizedMethod1!") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void synchronizedMethod2()
{
System.out.println("Invoked synchronizedMethod2!") ;
}
}
執行結果：
一個線程在訪問一個對象的同步方法時。還有一個線程不能同一時候訪問這個對象的還有一個同步方法。
}
4八、編程題: 寫一個Singleton出來。
Singleton模式主要做用是保證在Java應用程序中，一個類Class僅僅有一個實例存在。通常Singleton模式一般有幾種種形式:第一種形式: 定義一個類，它的構造函數爲private的。它有一個static的private的該類變量，在類初始化時實例話，經過一個public的getInstance方法獲取對它的引用,繼而調用當中的方法。
public class Singleton {private Singleton(){}private static Singleton instance = new Singleton(); public static Singleton getInstance() { return instance; } } 另一種形式: public class Singleton { private static Singleton instance =null; public static synchronizedSingleton getInstance() { if (instance==null) instance＝new Singleton();
return instance; } } 其它形式: 定義一個類，它的構造函數爲private的，所有方法爲static的。
通常以爲第一種形式要更加安全些
因爲Java不支持多繼承，而有可能某個類或對象要使用分別在幾個類或對象裏面的方法或屬性，現有的單繼承機制就不能知足要求。與繼承相比。接口有更高的靈活性。因爲接口中沒有不論什麼實現代碼。當一個類實現了接口之後，該類要實現接口裏面所有的方法和屬性。並且接口裏面的屬性在默認狀態如下都是publicstatic final,所有方法默認狀況下是public abstract.一個類可以實現多個接口。
{
c++虛類至關與java裏面的抽象類，與接口的不一樣之處例如如下：
一、一個子類僅僅能繼承一個抽象類（虛類），但能實現多個接口；
二、一個抽象類可以有構造方法，接口沒有構造方法。
三、一個抽象類中的方法不必定是抽象方法，即當中的方法可以有實現（有方法體），接口中的方法都是抽象方法，不能有方法體，僅僅有聲明；
四、一個抽象類可以是public。default,
接口僅僅有public;default
五、一個抽象類中的方法可以是public、private、protected、default，
接口中的方法僅僅能是public和default.
一樣之處：都不能實例化。
}
50、Java中的異常處理機制的簡單原理和應用。
當JAVA程序違反了JAVA的語義規則時，JAVA虛擬機就會將發生的錯誤表示爲一個異常。違反語義規則包含2種狀況。一種是JAVA類庫內置的語義檢查。
好比數組下標越界,會引起IndexOutOfBoundsException;訪問null的對象時會引起NullPointerException。
還有一種狀況就是JAVA贊成程序猿擴展這樣的語義檢查，程序猿可以建立本身的異常，並自由選擇在什麼時候用throwkeyword引起異常。所有的異常都是java.lang.Thowable的子類。
{
java中Throwable這個類可以被做爲異常拋出的類,繼承它的分爲異常Exception和錯誤Error.
Exception表示程序需要捕捉和處理的的異常;
Error表示系統級別的錯誤和程序無需處理的。
咱們所需要關心的是Exception.Execption可以分爲java標準定義的異常和程序猿本身定義異常2種.
（1）一種是當程序違反了java語規則的時候,JAVA虛擬機就會將發生的錯誤表示爲一個異常.這裏語法規則指的是JAVA類庫內置的語義檢查。
（2）還有一種狀況就是JAVA贊成程序猿擴展這樣的語義檢查，程序猿可以建立本身的異常，並自由選擇在什麼時候用throwkeyword引起異常。所有的異常都是Thowable的子類
}
5一、垃圾回收的長處和原理。並考慮2種回收機制。
Java語言中一個顯著的特色就是引入了垃圾回收機制，使c++程序猿最頭疼的內存管理的問題迎刃而解，它使得Java程序猿在編敲代碼的時候再也不需要考慮內存管理。由於有個垃圾回收機制。Java中的對象再也不有「做用域」的概念，僅僅有對象的引用纔有「做用域」。垃圾回收可以有效的防止內存泄露。有效的使用可以使用的內存。垃圾回收器通常是做爲一個單獨的低級別的線程執行，不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收。程序猿不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。回收機制有分代複製垃圾回收和標記垃圾回收，增量垃圾回收。
5二、請說出你所知道的線程同步的方法。
wait():使一個線程處於等待狀態。而且釋放所持有的對象的lock。
sleep():使一個正在執行的線程處於睡眠狀態，是一個靜態方法。調用此方法要捕捉InterruptedException異常。notify():喚醒一個處於等待狀態的線程，注意的是在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM肯定喚醒哪一個線程，而且不是按優先級。
Allnotity():喚醒所有處入等待狀態的線程，注意並不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。
5三、你所知道的集合類都有哪些？主要方法？最常用的集合類是 List 和Map。 List 的詳細實現包含 ArrayList 和 Vector，它們是可變大小的列表。比較適合構建、存儲和操做不論什麼類型對象的元素列表。
List 適用於按數值索引訪問元素的情形。 Map 提供了一個更通用的元素存儲方法。Map 集合類用於存儲元素對（稱做「鍵」和「值」），當中每個鍵映射到一個值。
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
5四、描寫敘述一下JVM載入class文件的原理機制?JVM中類的裝載是由ClassLoader和它的子類來實現的,JavaClassLoader 是一個重要的Java執行時系統組件。
它負責在執行時查找和裝入類文件的類。
{
在Java中，類裝載器把一個類裝入Java虛擬機中，要通過三個步驟來完畢：裝載、連接和初始化，當中連接又可以分紅校驗、準備、解析
裝載：查找和導入類或接口的二進制數據；
連接：運行如下的校驗、準備和解析步驟。當中解析步驟是可以選擇的。
校驗：檢查導入類或接口的二進制數據的正確性；
準備：給類的靜態變量分配並初始化存儲空間。
解析：將符號引用轉成直接引用；
初始化：激活類的靜態變量,初始化Java代碼和靜態Java代碼塊
}
5五、char型變量中能不能存貯一箇中文漢字?
爲何?
能夠定義成爲一箇中文的。因爲java中以unicode編碼，一個char佔16位，因此放一箇中文是沒問題的
{
能。java中的字符就是指char類型的變量，無論中文仍是英文，都是佔2個字節。因爲都是用Unicode編碼，一個Unicode編碼就是16位，也就是2個字節。
因此放一箇中文是沒問題的
因此：
publicclass Test {
publicstatic void main(String[] args) {
StringmyName="My name is於祥通";
charxiang='於';//合法的
System.out.println("個人姓氏爲："+xiang);//輸出：個人姓氏爲：於
System.out.println(myName.substring(0, 1));//輸出：M
System.out.println(myName.substring(myName.length()-1,myName.length()));//輸出：通
}
}
substring 處理的最小單元就是一個字符，也就是一個char類型，2個字節。
}
5六、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
多線程有兩種實現方法，各自是繼承Thread類與實現Runnable接口 ,同步的實現方面有兩種，各自是synchronized,wait與notify
5七、JSP的內置對象及方法。
request表示HttpServletRequest對象。它包括了有關瀏覽器請求的信息。並且提供了幾個用於獲取cookie, header, 和session數據的實用的方法,response表示HttpServletResponse對象，並提供了幾個用於設置送回 瀏覽器的響應的方法（如cookies,頭信息等）
out對象是javax.jsp.JspWriter的一個實例，並提供了幾個方法使你能用於向瀏覽器回送輸出結果。pageContext表示一個javax.servlet.jsp.PageContext對象。
它是用於方便存取各類範圍的名字空間、servlet相關的對象的API，並且包裝了通用的servlet相關功能的方法。 session表示一個請求的javax.servlet.http.HttpSession對象。Session可以存貯用戶的狀態信息 applicaton 表示一個javax.servle.ServletContext對象。
這有助於查找有關servlet引擎和servlet環境的信息 config表示一個javax.servlet.ServletConfig對象。
該對象用於存取servlet實例的初始化參數。 page表示從該頁面產生的一個servlet實例
5八、線程的基本概念、線程的基本狀態以及狀態之間的關係線程指在程序運行過程當中。能夠運行程序代碼的一個運行單位。每個程序至少都有一個線程，也就是程序自己。Java中的線程有四種狀態各自是：運行、就緒、掛起、結束。
5九、JSP的常用指令<%@pagelanguage=」java」 contenType=」text/html;charset=gb2312」 session=」true」buffer=」64kb」 autoFlush=」true」 isThreadSafe=」true」 info=」text」errorPage=」error.jsp」 isErrorPage=」true」 isELIgnored=」true」pageEncoding=」gb2312」 import=」java.sql.*」%>isErrorPage(可否使用Exception對象)。isELIgnored(是否忽略表達式)<%@include file=」filename」%><%@taglib prefix=」c」uri=」http://……」%>
60、什麼狀況下調用doGet()和doPost()？Jsp頁面中的form標籤裏的method屬性爲get時調用doGet()。爲post時調用doPost()。
6一、servlet的生命週期web容器載入servlet，生命週期開始。經過調用servlet的init()方法進行servlet的初始化。經過調用service()方法實現。依據請求的不一樣調用不一樣的do***()方法。結束服務。web容器調用servlet的destroy()方法。
6二、怎樣現實servlet的單線程模式 <%@ pageisThreadSafe=」false」%>
6三、頁面間對象傳遞的方法 request。session。application，cookie等
6四、JSP和Servlet有哪些一樣點和不一樣點。他們之間的聯繫是什麼？
JSP是Servlet技術的擴展，本質上是Servlet的簡易方式，更強調應用的外表表達。JSP編譯後是"類servlet"。
Servlet和JSP最基本的不一樣點在於。Servlet的應用邏輯是在Java文件裏，並且全然從表示層中的HTML裏分離開來。而JSP的狀況是Java和HTML可以組合成一個擴展名爲.jsp的文件。JSP側重於視圖。Servlet主要用於控制邏輯。
6五、四種會話跟蹤技術 cookie,url重寫,session,隱藏域
65,jsp的四種範圍
page否是表明與一個頁面相關的對象和屬性。一個頁面由一個編譯好的Java servlet 類（可以帶有不論什麼的 include 指令。但是沒有include 動做）表示。這既包含 servlet 又包含被編譯成servlet 的 JSP 頁面
request是是表明與 Web 客戶機發出的一個請求相關的對象和屬性。一個請求可能跨越多個頁面。涉及多個 Web 組件（由於forward 指令和 include 動做的關係）
session是是表明與用於某個 Web 客戶機的一個用戶體驗相關的對象和屬性。
一個 Web 會話可以也經常會跨越多個客戶機請求
application是是表明與整個 Web 應用程序相關的對象和屬性。這實質上是跨越整個 Web 應用程序。包含多個頁面、請求和會話的一個全局做用域
6六、Request對象的主要方法：
setAttribute(String name,Object)：設置名字爲name的request的參數值
getAttribute(String name)：返回由name指定的屬性值
getAttributeNames()：返回request對象所有屬性的名字集合。結果是一個枚舉的實例
getCookies()：返回client的所有Cookie對象。結果是一個Cookie數組
getCharacterEncoding()：返回請求中的字符編碼方式
getContentLength()：返回請求的Body的長度
getHeader(String name)：得到HTTP協議定義的文件頭信息
getHeaders(String name)：返回指定名字的requestHeader的所有值。結果是一個枚舉的實例
getHeaderNames()：返回因此requestHeader的名字，結果是一個枚舉的實例
getInputStream()：返回請求的輸入流。用於得到請求中的數據
getMethod()：得到client向server端傳送數據的方法
getParameter(String name)：得到client傳送給server端的有name指定的參數值
getParameterNames()：得到client傳送給server端的所有參數的名字，結果是一個枚舉的實例
getParameterValues(String name)：得到有name指定的參數的所有值
getProtocol()：獲取client向server端傳送數據所根據的協議名稱
getQueryString()：得到查詢字符串
getRequestURI()：獲取發出請求字符串的client地址
getRemoteAddr()：獲取client的IP地址
getRemoteHost()：獲取client的名字
getSession([Boolean create])：返回和請求相關Session
getServerName()：獲取server的名字
getServletPath()：獲取client所請求的腳本文件的路徑
getServerPort()：獲取server的port號
removeAttribute(String name)：刪除請求中的一個屬性
6七、J2EE是技術仍是平臺仍是框架？J2EE自己是一個標準，一個爲企業分佈式應用的開發提供的標準平臺。
J2EE也是一個框架，包含JDBC、JNDI、RMI、JMS、EJB、JTA等技術。
{
J2EE是技術:
核心技術爲JSP, Servlet, EJB ..
J2EE是平臺:
符合J2EE規範的server平臺，都是J2EEserver。比方JBoss,weblogic,webspher
J2EE是框架:
這個不太好說，要說的話。也可以說是三層/多層框架。
}
6八、咱們在web應用開發過程當中經常遇到輸出某種編碼的字符，如iso8859-1等，怎樣輸出一個某種編碼的字符串？
PublicString translate (String str) { StringtempStr = ""; try { tempStr =new String(str.getBytes("ISO-8859-1"), "GBK"); tempStr =tempStr.trim(); } catch (Exception e) { System.err.println(e.getMessage()); } return tempStr; }
6九、簡述邏輯操做(&,|,^)與條件操做(&&,||)的差異。
差異主要答兩點：a.條件操做僅僅能操做布爾型的,而邏輯操做不只可以操做布爾型,而且可以操做數值型b.邏輯操做不會產生短路
70、XML文檔定義有幾種形式？它們之間有何本質差異？解析XML文檔有哪幾種方式？
a: 兩種形式 dtd schema，b: 本質差異:schema自己是xml的，可以被XML解析器解析(這也是從DTD上發展schema的根本目的)，c:有DOM,SAX,STAX等 DOM:處理大型文件時其性能降低的很厲害。這個問題是由DOM的樹結構所形成的，這樣的結構佔用的內存較多。而且DOM必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問 SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束。或者標籤開頭與標籤結束時，它會觸發一個事件，用戶經過在其回調事件中寫入處理代碼來處理XML文件。適合對XML的順序訪問 STAX:Streaming API forXML (StAX)
7一、簡述synchronized和java.util.concurrent.locks.Lock的異同 ？
主要一樣點：Lock能完畢synchronized所實現的所有功能主要不一樣點：Lock有比synchronized更精確的線程語義和更好的性能。
synchronized會本身主動釋放鎖，而Lock必定要求程序猿手工釋放，並且必須在finally從句中釋放。
7二、EJB的角色和三個對象
一個完整的基於EJB的分佈式計算結構由六個角色組成，這六個角色可以由不一樣的開發商提供，每個角色所做的工做必須遵循Sun公司提供的EJB規範。以保證彼此之間的兼容性。
這六個角色各自是EJB組件開發人員（Enterprise Bean Provider） 、應用組合者（ApplicationAssembler）、部署者（Deployer）、EJB server提供者（EJB Server Provider）、EJB 容器提供者（EJB Container Provider）、系統管理員（SystemAdministrator）三個對象是Remote（Local）接口、Home（LocalHome）接口。Bean類
7三、EJB容器提供的服務主要提供聲明週期管理、代碼產生、持續性管理、安全、事務管理、鎖和併發行管理等服務。
7四、EJB規範規定EJB中禁止的操做有哪些？ 1.不能操做線程和線程API(線程API指非線程對象的方法如notify,wait等)。2.不能操做awt，3.不能實現server功能，4.不能對靜態屬生存取，5.不能使用IO操做直接存取文件系統，6.不能載入本地庫.，7.不能將this做爲變量和返回，8.不能循環調用。
7五、remote接口和home接口主要做用remote接口定義了業務方法，用於EJBclient調用業務方法。home接口是EJB工廠用於建立和移除查找EJB實例
7六、bean 實例的生命週期對於StatelessSession Bean、Entity Bean、MessageDriven Bean通常存在緩衝池管理。而對於Entity Bean和StatefullSession Bean存在Cache管理，一般包括建立實例，設置上下文、建立EJBObject（create）、業務方法調用、remove等過程，對於存在緩衝池管理的Bean。在create以後實例並不從內存清除。而是採用緩衝池調度機制不斷重用實例，而對於存在Cache管理的Bean則經過激活和去激活機制保持Bean的狀態並限制內存中實例數量。
7七、EJB的激活機制以Stateful Session Bean 爲例：其Cache大小決定了內存中可以同一時候存在的Bean實例的數量。依據MRU或NRU算法。實例在激活和去激活狀態之間遷移，激活機制是當client調用某個EJB實例業務方法時，假設相應EJB Object發現本身沒有綁定相應的Bean實例則從其去激活Bean存儲中（經過序列化機制存儲實例）回覆（激活）此實例。狀態變遷前會調用相應的ejbActive和ejbPassivate方法。
7八、EJB的幾種類型會話（Session）Bean ，實體（Entity）Bean消息驅動的（Message Driven）Bean ；會話Bean又可分爲有狀態（Stateful）和無狀態（Stateless）兩種；實體Bean可分爲Bean管理的持續性（BMP）和容器管理的持續性（CMP）兩種
7九、客服端調用EJB對象的幾個基本步驟設置JNDI服務工廠以及JNDI服務地址系統屬性，查找Home接口。從Home接口調用Create方法建立Remote接口。經過Remote接口調用其業務方法。
80、怎樣給weblogic指定大小的內存?
在啓動Weblogic的腳本中（位於所在Domian相應server文件夾下的startServerName），添加setMEM_ARGS=-Xms32m -Xmx200m。可以調整最小內存爲32M，最大200M
8一、怎樣設定的weblogic的熱啓動模式(開發模式)與產品公佈模式?可以在管理控制檯中改動相應server的啓動模式爲開發或產品模式之中的一個。或者改動服務的啓動文件或者commenv文件。添加set PRODUCTION_MODE=true。
8二、怎樣啓動時不需輸入username與password?改動服務啓動文件，添加 WLS_USER和WLS_PW項。也可以在boot.properties文件裏添加加密過的username和password.
8三、在weblogic管理制臺中對一個應用域(或者說是一個站點,Domain)進行jms及ejb或鏈接池等相關信息進行配置後,實際保存在什麼文件裏?保存在此Domain的config.xml文件裏。它是server的核心配置文件。
8四、說說weblogic中一個Domain的缺省文件夾結構?比方要將一個簡單的helloWorld.jsp放入何文件夾下,然的在瀏覽器上就可打入http://主機:port號//helloword.jsp就可以看到執行結果了? 又比方這當中用到了一個本身寫的javaBean該怎樣辦?
Domain文件夾\server文件夾\applications，將應用文件夾放在此文件夾下將可以做爲應用訪問，假設是Web應用，應用文件夾需要知足Web應用文件夾要求。jsp文件可以直接放在應用文件夾中。Javabean需要放在應用文件夾的WEB-INF文件夾的classes文件夾中，設置server的缺省應用將可以實現在瀏覽器上無需輸入應用名。
8五、在weblogic中公佈ejb需涉及到哪些配置文件不一樣類型的EJB涉及的配置文件不一樣。都涉及到的配置文件包含ejb-jar.xml,weblogic-ejb-jar.xmlCMP實體Bean通常還需要weblogic-cmp-rdbms-jar.xml
8六、怎樣在weblogic中進行ssl配置與client的認證配置或說說j2ee(標準)進行ssl的配置缺省安裝中使用DemoIdentity.jks和DemoTrust.jks KeyStore實現SSL，需要配置server使用EnableSSL，配置其port，在產品模式下需要從CA獲取私有密鑰和數字證書。建立identity和trust keystore，裝載得到的密鑰和數字證書。
可以配置此SSL鏈接是單向仍是雙向的。
8七、怎樣查看在weblogic中已經公佈的EJB?
可以使用管理控制檯，在它的Deployment中可以查看所有已公佈的EJB
8八、CORBA是什麼?用途是什麼? CORBA 標準是公共對象請求代理結構(Common ObjectRequest Broker Architecture)，由對象管理組織 (Object ManagementGroup，縮寫爲 OMG)標準化。它的組成是接口定義語言(IDL),語言綁定(binding:也譯爲聯編)和贊成應用程序間互操做的協議。
其目的爲：用不一樣的程序設計語言書寫在不一樣的進程中執行。爲不一樣的操做系統開發。
8九、說說你所熟悉或據說過的j2ee中的幾種常用模式?
及對設計模式的一些見解
SessionFacade Pattern：使用SessionBean訪問EntityBean；Message Facade Pattern：實現異步調用；EJBCommand Pattern：使用Command JavaBeans代替SessionBean，實現輕量級訪問；Data Transfer Object Factory：經過DTOFactory簡化EntityBean數據提供特性。GenericAttribute Access：經過AttibuteAccess接口簡化EntityBean數據提供特性；Business Interface：經過遠程（本地）接口和Bean類實現一樣接口規範業務邏輯一致性。ＥＪＢ架構的設計好壞將直接影響系統的性能、可擴展性、可維護性、組件可重用性及開發效率。
項目越複雜，項目隊伍越龐大則越能體現良好設計的重要性。
90、說說在weblogic中開發消息Bean時的persistent與non-persisten的區別persistent方式的MDB可以保證消息傳遞的可靠性,也就是假設EJB容器出現故障而JMSserver依舊會將消息在此MDB可用的時候發送過來，而non－persistent方式的消息將被丟棄。
9一、Servlet運行時通常實現哪幾個方法？public void init(ServletConfig config)；public ServletConfig getServletConfig()；publicString getServletInfo()；public void service(ServletRequestrequest,ServletResponse response)；public void destroy()
9二、常用的設計模式？說明工廠模式。
Java中的23種設計模式：Factory（工廠模式），Builder（建造模式）， Factory Method（工廠方法模式），Prototype（原始模型模式）。Singleton（單例模式）， Facade（門面模式），Adapter（適配器模式）， Bridge（橋樑模式）。 Composite（合成模式），Decorator（裝飾模式）。 Flyweight（享元模式）。 Proxy（代理模式），Command（命令模式）。 Interpreter（解釋器模式）， Visitor（訪問者模式）。Iterator（迭代子模式）， Mediator（調停者模式）。 Memento（備忘錄模式）。Observer（觀察者模式），State（狀態模式）。Strategy（策略模式），Template Method（模板方法模式）。 Chain Ofresponsibility（責任鏈模式）。
工廠模式：工廠模式是一種經常被使用到的模式，依據工廠模式實現的類可以依據提供的數據生成一組類中某一個類的實例。一般這一組類有一個公共的抽象父類並且實現了一樣的方法，但是這些方法針對不一樣的數據進行了不一樣的操做。首先需要定義一個基類，該類的子類經過不一樣的方法實現了基類中的方法。
而後需要定義一個工廠類。工廠類可以依據條件生成不一樣的子類實例。當獲得子類的實例後，開發者可以調用基類中的方法而沒必要考慮究竟返回的是哪個子類的實例。
9三、EJB需直接實現它的業務接口或Home接口嗎，請簡述理由。
遠程接口和Home接口不需要直接實現。他們的實現代碼是由server產生的。程序執行中相應實現類會做爲相應接口類型的實例被使用。
9四、排序都有哪幾種方法？請列舉。
用JAVA實現一個高速排序。排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、高速排序）。選擇排序（直接選擇排序、堆排序），歸併排序。分配排序（箱排序、基數排序）
高速排序的僞代碼。
/ /使用高速排序方法對a[ 0 :n- 1 ]排序，從a[ 0 :n- 1 ]中選擇一個元素做爲m i d d l e。該元素爲支點，
把餘下的元素切割爲兩段left 和r i g h t。使得le f t中的元素都小於等於支點，而right 中的元素都大於等於支點，遞歸地使用高速排序方法對left進行排序，遞歸地使用高速排序方法對right 進行排序，所得結果爲le f t + m i d d l e + r i g h t。
9五、請對下面在J2EE中常用的名詞進行解釋(或簡單描寫敘述)web容器：給處於當中的應用程序組件（JSP。SERVLET）提供一個環境，使JSP,SERVLET直接更容器中的環境變量接口交互，沒必要關注其餘系統問題。
主要有WEBserver來實現。好比：TOMCAT,WEBLOGIC,WEBSPHERE等。該容器提供的接口嚴格遵照J2EE規範中的WEB APPLICATION 標準。咱們把遵照以上標準的WEBserver就叫作J2EE中的WEB容器。
EJB容器：Enterprise java bean 容器。更具備行業領域特點。他提供給執行在當中的組件EJB各類管理功能。僅僅要知足J2EE規範的EJB放入該容器。當即就會被容器進行高效率的管理。並且可以經過現成的接口來得到系統級別的服務。好比郵件服務、事務管理。
JNDI：（Java Naming & Directory Interface）JAVA命名文件夾服務。
主要提供的功能是：提供一個文件夾系統，讓其餘各地的應用程序在其上面留下本身的索引，從而知足高速查找和定位分佈式應用程序的功能。JMS：（Java Message Service）JAVA消息服務。
主要實現各個應用程序之間的通信。
包含點對點和廣播。JTA：（JavaTransaction API）JAVA事務服務。提供各類分佈式事務服務。
應用程序僅僅需調用其提供的接口就能夠。
JAF：（Java Action FrameWork）JAVA安全認證框架。
提供一些安全控制方面的框架。讓開發人員經過各類部署和本身定義實現本身的個性安全控制策略。
RMI/IIOP:（Remote Method Invocation /internet對象請求中介協議）他們主要用於經過遠程調用服務。
好比，遠程有一臺計算機上執行一個程序，它提供股票分析服務，咱們可以在本地計算機上實現對其直接調用。固然這是要經過必定的規範才幹在異構的系統之間進行通訊。
RMI是JAVA特有的。
9七、一個「.java」源文件裏可否夠包含多個類（不是內部類）？有什麼限制？可以。
必須僅僅有一個類名與文件名稱一樣。
9八、MVC的各個部分都有那些技術來實現?
怎樣實現? MVC是Model－View－Controller的簡寫。"Model"表明的是應用的業務邏輯（經過JavaBean。EJB組件實現）， "View" 是應用的表示面（由JSP頁面產生）。"Controller" 是提供應用的處理過程控制（一般是一個Servlet）。經過這樣的設計模型把應用邏輯。處理過程和顯示邏輯分紅不一樣的組件實現。這些組件可以進行交互和重用。
100、java中有幾種類型的流？JDK爲每種類型的流提供了一些抽象類以供繼承。請說出他們各自是哪些類？
字節流。字符流。字節流繼承於InputStream \ OutputStream，字符流繼承於InputStreamReader\ OutputStreamWriter。在java.io包中還有更多的流，主要是爲了提升性能和使用方便。
10一、java中會存在內存泄漏嗎，請簡單描寫敘述。會。
如：int i,i2; return (i-i2); //when i爲足夠大的正數,i2爲足夠大的負數。
結果會形成溢位，致使錯誤。
10三、垃圾回收器的基本原理是什麼？垃圾回收器可以當即回收內存嗎？有什麼辦法主動通知虛擬機進行垃圾回收？對於GC來講，當程序猿建立對象時，GC就開始監控這個對象的地址、大小以及使用狀況。一般。GC採用有向圖的方式記錄和管理堆(heap)中的所有對象。
經過這樣的方式肯定哪些對象是"可達的"。哪些對象是"不可達的"。
當GC肯定一些對象爲"不可達"時，GC就有責任回收這些內存空間。可以。程序猿可以手動運行System.gc()，通知GC運行。但是Java語言規範並不保證GC必定會運行。
{
垃圾回收器是一個級別很是低的線程,它經過不定時監測程序使用的內存中被佔用的動態分配的內存內的對象是否還存在它的引用來推斷是否該回收那個內存單元,假設不存在則回收,不然相反~~並不是僅僅要監測到就會回收的,因爲垃圾回收器線程的低級別,因此當還有一個級別比它高的線程跟他同一時候競爭執行時間時,前者優先執行,咱們經過Thread或者繼承Runnable的線程都級別都比它高,因此你沒法知道垃圾回收器什麼時候回收,System.gc()僅僅是建議垃圾回收器進行回收處理,調用它並不能保證它會立刻回收,緣由就像上面所說的~
}
{
對於GC來講，當程序猿建立對象時，GC就開始監控這個對象的地址、大小以及使用狀況。
一般，GC採用有向圖的方式記錄和管理堆(heap)中的所有對象。
經過這樣的方式肯定哪些對象是"可達的"，哪些對象是"不可達的"。當GC肯定一些對象爲"不可達"時，GC就有責任回收這些內存空間。可以。
程序猿可以手動運行System.gc()，通知GC運行，但是Java語言規範並不保證GC必定會運行。強制運行垃圾回收：System.gc()。Runtime.getRuntime().gc()
靜態類：static的是屬於類的。而不是屬於對象的。至關因而全局的，不可能被回收
靜態變量自己不會被回收。但是它所引用的對象應該是可以回收的。
gc僅僅回收heap裏的對象，對象都是同樣的,僅僅要沒有對它的引用,就可以被回收(但是不必定被回收). 對象的回收和是否static沒有什麼關係!
如：static Vector pane = new Vector(); pane = null; 假設沒有其餘引用的話，原來pane指向的對象實例就會被回收。
Java程序猿在編敲代碼的時候再也不需要考慮內存管 理。由於有個垃圾回收機制。Java中的對象再也不有"做用域"的概念，僅僅有對象的引用纔有"做用域"。垃圾回收可以有效的防止內存泄露。有效的使用可以使用的內存。垃圾回收器通常是做爲一個單獨的低級別的線程執行，不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收，程序猿不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。
}
10四、靜態變量和實例變量的差異？static i = 10; //常量； class A a; a.i=10;//可變
{
文一：
在語法定義上的差異：靜態變量前要加statickeyword，而實例變量前則不加。
在程序執行時的差異：實例變量屬於某個對象的屬性。必須建立了實例對象。當中的實例變量纔會被分配空間。才幹使用這個實例變量。靜態變量不屬於某個實例對象。而是屬於類，因此也稱爲類變量，僅僅要程序載入了類的字節碼。不用建立不論什麼實例對象，靜態變量就會被分配空間。靜態變量就可以被使用了。
總之，實例變量必須建立對象後才幹夠經過這個對象來使用，靜態變量則可以直接使用類名來引用。
好比，對於如下的程序，無論建立多少個實例對象。永遠都僅僅分配了一個staticVar變量。並且每建立一個實例對象，這個staticVar就會加1。但是，每建立一個實例對象，就會分配一個instanceVar，就能夠能分配多個instanceVar。並且每個instanceVar的值都僅僅自加了1次。
publicclass VariantTest
{
publicstatic int staticVar = 0;
publicint instanceVar = 0;
publicVariantTest()
{
staticVar++;
instanceVar++;
System.out.println("staticVar= "++staticVar ", instanceVar = " ++instanceVar);
}
}
文二：
java類的成員變量有倆種：
一種是被statickeyword修飾的變量，叫類變量或者靜態變量
還有一種沒有static修飾。爲實例變量
類的靜態變量在內存中僅僅有一個，java虛擬機在載入類的過程當中爲靜態變量分配內存，靜態變量位於方法區，被類的所有實例共享。靜態變量可以直接經過類名進行訪問，其生命週期取決於類的生命週期。來源:考試大-Java認證考試
而實例變量取決於類的實例。每建立一個實例，java虛擬機就會爲實例變量分配一次內存，實例變量位於堆區中，其生命週期取決於實例的生命週期。
publicclass Temp {
intt; //實例變量
publicstatic void main(String args[]){
intt=1; //局部變量
System.out.println(t);//打印局部變量
Tempa= new Temp(); //建立實例
System.out.println(a.t);//經過實例訪問實例變量
}
}
結果爲：
1
0 （成員變量具備缺省值而局部變量則沒有）
把代碼改成
publicclass Temp {
staticint t; //類變量
publicstatic void main(String args[]){
System.out.println(t);//打印類變量
intt=1; //局部變量
System.out.println(t);//打印局部變量
Tempa= new Temp(); //建立實例
System.out.println(a.t);//經過實例訪問實例變量
}
}
結果則爲
0
1
0
}
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
10五、什麼是java序列化，怎樣實現java序列化？
序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操做，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流進行讀寫操做時所引起的問題。序列化的實現：將需要被序列化的類實現Serializable接口，該接口沒有需要實現的方法，implementsSerializable僅僅是爲了標註該對象是可被序列化的，而後使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接着。使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數爲obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。
1055.this
導讀：可能爲一個類寫了多個構造器。有時可能想在一個構造器中調用還有一個構造器，以免反覆代碼。可用thiskeyword作到這一點。不少其它進入考試大計算機java認證試題、真題、模擬題、輔導等。
一般寫this的時候，都是指「這個對象」或者「當前對象」。而且它自己表示對當前對象的引用。
在構造器中，假設爲this加入了參數列表。那麼就有了不一樣的含義。這將產生對符合此參數列表的某個構造器的明白調用。這樣。調用其它構造器就有了直接的途徑：
Java代碼
publicclass Flower{
intpetalCount=0;
Strings="initial value";
Flower(intpetals){
petalCount=petals;
System.out.print("Constructorw/int arg only,petalCount=.."+petalCount);
}
Flower(Stringss){
System.out.print("Constructorw/String arg only,s="+ss);
s=ss;
}
Flower(Strings,int petals){
this(petals);
this(s);//Can't call two!
this.s=s;//Another use of"this"
System.out.print("String&intargs");
}來源:考試大-Java認證考試
Flower(){
this("hi",47);
System.out.print("defaultconstructor(no args)");
}
voidprintPetalCount(){
this(11);//Not inside non-constructor!
System.out.print("petalCount="+petalCount+"s="+s);
}
publicstatic void main(String[]args){
Flowerx=new Flower():
x.printPetalCount();
}
}
結果輸出：
Java代碼
Constructorw/int arg only,petalCount=47
String& int args
defaultconstructor(no args)
petalCount=47s=hi
10六、可否夠從一個static方法內部發出對非static方法的調用？不可以,假設當中包括對象的method()；不能保證對象初始化.
{
不行，
可以這樣理解
static修飾的方法可以直接用類名調用
非static修飾的方法必須用類new出對象才幹調用
當咱們用類名直接調用時，可能這個類的對象並無new。
假設這時候static方法裏調用非static的方法就會出現空指針異常，
固然這樣的錯誤編譯時就不會經過
不可以。因爲非static方法是要與對象關聯在一塊兒的，必須建立一個對象後，才幹夠在該對象上進行方法調用，而static方法調用時不需要建立對象，可以直接調用。
也就是說。當一個static方法被調用時。可能尚未建立不論什麼實例對象，假設從一個static方法中發出對非static方法的調用，那個非static方法是關聯到哪一個對象上的呢？這個邏輯沒法成立，因此，一個static方法內部發出對非static方法的調用。
}
10七、寫clone()方法時，一般都有一行代碼，是什麼？Clone 有缺省行爲。super.clone();他負責產生正確大小的空間，並逐位複製。
{
在實際編程過程當中，咱們常常要遇到這樣的狀況：有一個對象A，在某一時刻A中已經包括了一些有效值，此時可能會需要一個和A全然一樣新對象B，並且此後對B不論什麼修改都不會影響到A中的值。也就是說。A與B是兩個獨立的對象。但B的初始值是由A對象肯定的。Clone有缺省行爲。super.clone();他負責產生正確大小的空間。並逐位複製。使用clone()來複制一個對象，clone()從Object類繼承。所有具備clone功能的類都有一個特性，那就是它直接或間接地實現了Cloneable接口。
protected native Object clone() throwsCloneNotSupportedException;
可以看出它是一個protected方法,因此咱們不能簡單地調用它。keywordnative，代表這種方法使用java之外的語言實現。
對於 object x,
x.clone() != x
x.clone().getClass() == x.getClass()
x.clone().equals(x)
以上返回的值都爲true
要說明的有兩點：一是拷貝對象返回的是一個新對象，而不是一個引用。二是拷貝對象與用new操做符返回的新對象的差異就是這個拷貝已經包括了一些原來對象的信息，而不是對象的初始信息。
1．淺複製與深複製概念
⑴淺複製（淺克隆）：被複制對象的所有變量都含有與原來的對象一樣的值。而所有的對其它對象的引用仍然指向原來的對象。
換言之，淺複製只複製所考慮的對象，而不復制它所引用的對象。
⑵深複製（深克隆）
被複制對象的所有變量都含有與原來的對象一樣的值，除去那些引用其它對象的變量。那些引用其它對象的變量將指向被複制過的新對象，而再也不是原有的那些被引用的對象。換言之。深複製把要複製的對象所引用的對象都複製了一遍。
public class TestClone1 implements Cloneable{
int count;
TestClone1 next;
public TestClone1(int count) {
this.count=count;
if(count>0)
next=new TestClone1(count-1);
}
void add(){
count++;
if(next!=null)
next.count++;
}
public String toString(){
String s=String.valueOf(count)+" ";
if(next!=null)
s+=next.toString();
return s;
}
public Object clone(){
Object o=null;
try{
o=super.clone();//假設沒有實現cloneable，將會拋出CloneNotSupported異常
}
catch(CloneNotSupportedException e){
System.err.println("cannot clone");
}
return o;
}
public static void main(String[] args){
TestClone1 t=new TestClone1(1);
System.out.println("t="+t);
TestClone1 t1=(TestClone1)t.clone();
System.out.println("t1="+t1);
t.add();
System.out.println("after added/nt t="+t+"/nt1="+t1)
}
}
在這個樣例中建立t至關於兩個相連的TestClone1實例。而在調用了t的add方法以後。意想不到的結果出現了：
t=1 0
t1=1 0
after added
t t=2 1
t1=1 1
t1也發生了改變。
實際上Object.clone()進行的複製有着"bitwise"原則，也就是逐位複製。對於一個對象中定義的對象。它僅僅是簡單的複製這個對象的引用。
這也就是常說的淺層拷貝（shallow copy）。想要運行深層拷貝（deep copy）。僅僅需要在TestClone1 t1=(TestClone1)t.clone();後面加上t1.next=(TestClone1)t.next.clone();就能獲得：
t=1 0
t1=1 0
after added
t t=2 1
t1=1 0
這個正確的結果。
}
10八、在JAVA中，怎樣跳出當前的多重嵌套循環？用break; return 方法。
{
在Java中。要想跳出多重循環，可以在外面的循環語句前定義一個標號，而後在裏層循環體的代碼中使用帶有標號的break語句。就能夠跳出外層循環。
代碼例如如下:
- loop:
- for(int i=0;i<10;i++) {
- System.out.println(i);
- for(int j=0;j<10;j++) {
- System.out.println("i=" + i + ",j=" + j);
- if(j == 5) break loop;
- }
- }
loop:
for(inti=0;i<10;i++) {
System.out.println(i);
for(intj=0;j<10;j++) {
System.out.println("i="+ i + ",j=" + j);
if(j== 5) break loop;
}
}
另外，我我的一般並不使用標號這樣的方式，而是讓外層的循環條件表達式的結果可以受到裏層循環體代碼的控制，好比。要在二維數組中查找到某個數字。
代碼例如如下:
- int arr[][] = {{1,2,3},{4,5,6,7},{9}};
- // int d=0;
- // byte a=1;
- // char b=1;
- short c=1;
- boolean found = false;
- for(int i=0;i<arr.length && !found;i++)
- {
- for(int j=0;j<arr[i].length;j++)
- {
- System.out.println("i=" + i + ",j=" + j);
- if(arr[i][j] == 5)
- {
- found = true;
- break;
- }
- }
- }
Java中使用break/continue label控制多重嵌套循環的跳轉
在Java中可以使用 break/continue label語句來控制多重嵌套循環的跳轉。
在如下樣例中，咱們使用continueouter中止當前循環，繼續外層循環的運行。而使用breakouter則跳出所有outer後面的嵌套循環。
break+ 標號label
標號提供了一種簡單的break語句所不能實現的控制循環的方法，當在循環語句中遇到break時。循環終止。但是，當你嵌套在幾層循環中想退出循環時又會如何呢？正常的break僅僅退出一重循環。你可以用標號標出你想退出的所有循環語句。
continue +標號label
相同，continue僅僅能繼續當前循環，假設要繼續外層循環就需要用標號指出對應的循環。注意此時標號僅僅能指向一個循環結構。
public class Main {
public static void main(String args[]) throws Exception
{
char a;
outer:
for(int i=0;i<100;i++)
{
for(int j=0;j<100;j++)
{
a =(char)System.in.read();
if(a=='x')
break outer;
if(a=='y')
continue outer;
System.out.println( a );
}
}
System.out.println("the end.-------------------");
}
}
}
10九、List、Map、Set三個接口，存取元素時，各有什麼特色？List 以特定次序來持有元素。可有反覆元素。Set沒法擁有反覆元素,內部排序。Map 保存key-value值，value可多值。
1十、J2EE是什麼？J2EE是Sun公司提出的多層(multi-diered),分佈式(distributed),基於組件(component-base)的企業級應用模型(enterprieseapplication model).在這種一個應用系統中，可依照功能劃分爲不一樣的組件，這些組件又可在不一樣計算機上，並且處於對應的層次(tier)中。所屬層次包含客戶層(clietn tier)組件,web層和組件,Business層和組件,企業信息系統(EIS)層。
1十一、UML方面 標準建模語言UML。用例圖,靜態圖(包含類圖、對象圖和包圖),行爲圖,交互圖(順序圖,合做圖),實現圖。
1十二、說出一些常用的類，包，接口。請各舉5個常用的類：BufferedReader BufferedWriter FileReader FileWirter String Integer。常用的包：java.lang java.awt java.io java.util java.sql；常用的接口：Remote List Map Document NodeList
11三、開發中都用到了那些設計模式?
用在什麼場合?
每個模式都描寫敘述了一個在咱們的環境中不斷出現的問題，而後描寫敘述了該問題的解決方式的核心。經過這樣的方式。你可以無數次地使用那些已有的解決方式。無需在反覆一樣的工做。
主要用到了MVC的設計模式。
用來開發JSP/Servlet或者J2EE的相關應用。
簡單工廠模式等。
11四、jsp有哪些動做?做用各自是什麼? JSP共同擁有下面6種基本動做jsp:include：在頁面被請求的時候引入一個文件。 jsp:useBean：尋找或者實例化一個JavaBean。 jsp:setProperty：設置JavaBean的屬性。
jsp:getProperty：輸出某個JavaBean的屬性。 jsp:forward：把請求轉到一個新的頁面。 jsp:plugin：依據瀏覽器類型爲Java插件生成OBJECT或EMBED標記。
11五、Anonymous Inner Class (匿名內部類) 可否夠extends(繼承)其它類。可否夠implements(實現)interface(接口)?可以繼承其它類或完畢其它接口，在swing編程中常用此方式。
{
匿名內部類是沒有名字的內部類,不能繼承其餘類,但一個內部類可以做爲一個接口,由還有一個內部類實現.
1、因爲匿名內部類沒有名字，因此它沒有構造函數。
因爲沒有構造函數，因此它必須全然借用父類的構造函數來實例化，換言之：匿名內部類全然把建立對象的任務交給了父類去完畢。
2、在匿名內部類裏建立新的方法沒有太大意義，但它可以經過覆蓋父類的方法達到奇妙效果，如上例所看到的。
這是多態性的體現。
3、因爲匿名內部類沒有名字，因此沒法進行向下的強制類型轉換，持有對一個匿名內部類對象引用的變量類型必定是它的直接或間接父類類型。
new <類或接口> <類的主體>
匿名類
匿名類是不能有名稱的類，因此沒辦法引用它們。
必須在建立時，做爲new語句的一部分來聲明它們。
這就要採用還有一種形式的new語句，例如如下所看到的：
new <類或接口> <類的主體>
這樣的形式的new語句聲明一個新的匿名類。它對一個給定的類進行擴展，或者實現一個給定的接口。
它還建立那個類的一個新實例。並把它做爲語句的結果而返回。
要擴展的類和要實現的接口是new語句的操做數，後跟匿名類的主體。
假設匿名類對還有一個類進行擴展。它的主體可以訪問類的成員、覆蓋它的方法等等，這和其它不論什麼標準的類都是同樣的。假設匿名類實現了一個接口，它的主體必須實現接口的方法。
注意匿名類的聲明是在編譯時進行的。實例化在執行時進行。這意味着for循環中的一個new語句會建立一樣匿名類的幾個實例，而不是建立幾個不一樣匿名類的一個實例。
從技術上說。匿名類可被視爲非靜態的內部類，因此它們具備和方法內部聲明的非靜態內部類同樣的權限和限制。
假設要運行的任務需要一個對象，但卻不值得建立全新的對象（緣由多是所需的類過於簡單。或者是由於它僅僅在一個方法內部使用），匿名類就顯得很實用。
匿名類尤爲適合在Swing應用程序中高速建立事件處理程序。
exp:
return new Contents() {
private int i = 11;
public int value() { return i; }
};
這樣的奇怪的語法要表達的意思是：「建立從Contents衍生出來的匿名類的一個對象」。
由new表達式返回的句柄會本身主動上溯造型成一個Contents句柄。
匿名內部類的語法事實上要表達的是：
class MyContents extends Contents {
private int i = 11;
public int value() { return i; }
}
return new MyContents();
若試圖定義內部類,並想使用在匿名內部類外部定義的一個對象,則編譯器要求外部對象必須是final屬性.
public class Parcel9 {
public Destination
dest(final String dest, final float price) {
return new Destination() {
private int cost;
// Instance initialization for each object:
{
cost = Math.round(price);
if(cost > 100)
System.out.println("Over budget!");
}
private String label = dest;
public String readLabel() { return label; }
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.dest("Tanzania", 101.395F);
}
}
}
11六、應用server與WEB SERVER的差異？應用server：Weblogic、Tomcat、Jboss； WEB SERVER：IIS、 Apache
{
1。應用server處理業務邏輯。webserver則主要是讓客戶可以經過瀏覽器進行訪問。
2。應用server處理業務邏輯，webserver是用於處理HTML文件的。webserver一般比應用server簡單。如apache就是webserver，Jboss就是EJB應用server。
應用server：Weblogic、Tomcat、Jboss
WEB SERVER：IIS、 Apache
應用server處理業務邏輯，webserver則主要是讓客戶可以經過瀏覽器進行訪問。
應用server處理業務邏輯,webserver是用於處理HTML文件的。webserver一般比應用server簡單，如apache就是webserver。Jboss就是EJB應用server
在B/S體系結構中，Web server是Application Server的前提和基礎。Web Server接受來自Browse（http）的request。爲了擴展Web的應用（如與後臺DataBase打交道）早期如一些DLL可以來完畢，後來各家公司有了Applicationserver豐富了這方面的性能。使用戶跟後臺的數據庫有了更好的接口。如：WebSphere Weblogic等等
webserver僅僅提供web服務功能。比喻說解釋jsp,servlet等。而應用server提供整個企業級解決方式。比方說：應用server提供EJB包容器,可以提供用戶控制。事務等居多功能。webserver是應用server的一個子集
Webserver與（Java）應用server是平行的概念。兩者不存在相互包容關係。好像J2EE體系結構就是這麼畫的：client《——》Webserver《——》應用server《——》數據庫server
假設你訪問的網頁僅僅有象HTML這樣的頁面的，用WEBserver就夠了，但是假設是JSP，也就是含JAVA代碼的HTML，則就需要JAVA應用server了。因爲僅僅有JAVA應用server才幹解析JSP裏的JAVA代碼，並將解析結果以HTML的格式返回給你。
}
11七、BS與CS的聯繫與差異。C/S是Client/Server的縮寫。server一般採用高性能的PC、工做站或小型機，並採用大型數據庫系統。如Oracle、Sybase、Informix或 SQL Server。
client需要安裝專用的client軟件。B/Ｓ是Brower/Server的縮寫。客戶機上僅僅要安裝一個瀏覽器（Browser），如NetscapeNavigator或Internet Explorer，server安裝Oracle、Sybase、Informix或SQL Server等數據庫。在這樣的結構下，用戶界面全然經過WWW瀏覽器實現，一部分事務邏輯在前端實現，但是主要事務邏輯在server端實現。
瀏覽器經過ＷebServer 同數據庫進行數據交互。C/S 與 B/S 差異： １．硬件環境不一樣: C/S 通常創建在專用的網絡上, 小範圍裏的網絡環境, 局域網之間再經過專門server提供鏈接和數據交換服務。 B/S創建在廣域網之上的, 沒必要是專門的網絡硬件環境,例與電話上網, 租用設備. 信息本身管理.有比C/S更強的適應範圍, 通常僅僅要有操做系統和瀏覽器便可２．對安全要求不一樣 ：C/S 通常面向相對固定的用戶羣, 對信息安全的控制能力很是強.通常高度機密的信息系統採用C/S 結構適宜. 可以經過B/S公佈部分可公開信息.B/S 創建在廣域網之上, 對安全的控制能力相對弱, 可能面向不可知的用戶。
３．對程序架構不一樣 ： C/S 程序可以更加註重流程,可以對權限多層次校驗, 對系統執行速度可以較少考慮. B/S 對安全以及訪問速度的多重的考慮, 創建在需要更加優化的基礎之上. 比C/S有更高的要求B/S結構的程序架構是發展的趨勢, 從MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持網絡的構件搭建的系統. SUN 和IBM推的JavaBean 構件技術等,使 B/S更加成熟. ４．軟件重用不一樣：C/S 程序可以不可避免的整體性考慮, 構件的重用性不如在B/S要求下的構件的重用性好. B/S 對的多重結構,要求構件相對獨立的功能. 可以相對較好的重用.就入買來的餐桌可以再利用,而不是作在牆上的石頭桌子 。
５．系統維護不一樣 ：C/S 程序由於整體性, 必須整體考察, 處理出現的問題以及系統升級.升級難. 多是再作一個全新的系統。 B/S 構件組成,方面構件個別的更換,實現系統的無縫升級.系統維護開銷減到最小.用戶從網上本身下載安裝就可以實現升級. ６．處理問題不一樣 ：C/S 程序可以處理用戶面固定, 並且在一樣區域, 安全要求高需求, 與操做系統相關.應該都是一樣的系統，B/S 創建在廣域網上, 面向不一樣的用戶羣, 分散地域, 這是C/S沒法做到的. 與操做系統平臺關係最小. ７．用戶接口不一樣：C/S 可能是創建的Window平臺上,表現方法有限,對程序猿廣泛要求較高，B/S 創建在瀏覽器上, 有更加豐富和生動的表現方式與用戶交流. 並且大部分難度減低,減低開發成本.
８．信息流不一樣 ： C/S 程序一般是典型的中央集權的機械式處理, 交互性相對低，B/S 信息流向可變化, B-B B-C B-G等信息、流向的變化, 更像交易中心。
11八、LINUX下線程，GDI類的解釋。LINUX實現的就是基於核心輕量級進程的"一對一"線程模型，一個線程實體相應一個核心輕量級進程，而線程之間的管理在覈外函數庫中實現。GDI類爲圖像設備編程接口類庫。
11九、STRUTS的應用(如STRUTS架構)Struts是採用Java Servlet/JavaServer Pages技術，開發Web應用程序的開放源代碼的framework。
採用Struts能開發出基於MVC(Model-View-Controller)設計模式的應用構架。Struts有例如如下的主要功能： 一.包括一個controllerservlet，能將用戶的請求發送到對應的Action對象。 二.JSP自由tag庫，並且在controller servlet中提供關聯支持。幫助開發員建立交互式表單應用。 三.提供了一系列有用對象：XML處理、經過Java reflection APIs本身主動處理JavaBeans屬性、國際化的提示和消息。
120、Jdo是什麼?
JDO是Java對象持久化的新的規範，爲java data object的簡稱,也是一個用於存取某種數據倉庫中的對象的標準化API。JDO提供了透明的對象存儲，所以對開發者來講，存儲數據對象全然不需要額外的代碼（如JDBC API的使用）。
這些繁瑣的例行工做已經轉移到JDO產品提供商身上。使開發者解脫出來，從而集中時間和精力在業務邏輯上。
另外，JDO很是靈活。因爲它可以在不論什麼數據底層上執行。JDBC僅僅是面向關係數據庫（RDBMS）JDO更通用，提供到不論什麼數據底層的存儲功能，比方關係數據庫、文件、XML以及對象數據庫（ODBMS）等等。使得應用可移植性更強。
12一、內部類可以引用他包括類的成員嗎？有沒有什麼限制？一個內部類對象可以訪問建立它的外部類對象的內容
12二、WEB SERVICE名詞解釋。
JSWDL開發包的介紹。
JAXP、JAXM的解釋。SOAP、UDDI,WSDL解釋。
Web ServiceWeb Service是基於網絡的、分佈式的模塊化組件，它運行特定的任務，遵照詳細的技術規範，這些規範使得Web Service能與其它兼容的組件進行互操做。JAXP(Java API for XML Parsing) 定義了在Java中使用DOM, SAX, XSLT的通用的接口。這樣在你的程序中你僅僅要使用這些通用的接口。當你需要改變詳細的實現時候也不需要改動代碼。JAXM(JavaAPI for XML Messaging) 是爲SOAP通訊提供訪問方法和傳輸機制的API。WSDL是一種 XML 格式。用於將網絡服務描寫敘述爲一組端點，這些端點對包括面向文檔信息或面向過程信息的消息進行操做。這樣的格式首先對操做和消息進行抽象描寫敘述，而後將其綁定到詳細的網絡協議和消息格式上以定義端點。相關的詳細端點即組合成爲抽象端點（服務）。SOAP即簡單對象訪問協議(Simple Object Access Protocol)。它是用於交換XML編碼信息的輕量級協議。 UDDI 的目的是爲電子商務創建標準。UDDI是一套基於Web的、分佈式的、爲Web Service提供的、信息註冊中心的實現標準規範，同一時候也包括一組使企業能將自身提供的Web Service註冊，以使別的企業能夠發現的訪問協議的實現標準。
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
JAVA代碼查錯
1.abstract class Name { private String name; public abstractboolean isStupidName(String name) {}}大俠們。這有何錯誤?答案: 錯。abstractmethod必須以分號結尾，且不帶花括號。
2.public class Something { void doSomething () { private String s = ""; int l = s.length(); } }有錯嗎?答案: 錯。局部變量前不能放置不論什麼訪問修飾符(private，public，和protected)。final可以用來修飾局部變量(final如同abstract和strictfp，都是非訪問修飾符，strictfp僅僅能修飾class和method而非variable)。
3. abstract class Something { private abstract StringdoSomething ();}這好像沒什麼錯吧?答案: 錯。abstract的methods不能以private修飾。abstract的methods就是讓子類implement(實現)詳細細節的，怎麼可以用private把abstract method封鎖起來呢? (同理。abstract method前不能加final)。
4.public class Something { public int addOne(final int x) {return ++x; }}這個比較明顯。
答案: 錯。int x被修飾成final，意味着x不能在addOne method中被改動。
5.public class Something { public static void main(String[]args) { Other o = new Other(); new Something().addOne(o); } public void addOne(final Other o) { o.i++; }} class Other { public int i;}和上面的很是類似，都是關於final的問題。這有錯嗎?
答案: 正確。
在addOne method中，參數o被修飾成final。
假設在addOne method裏咱們改動了o的reference。(比方: o = new Other();)，那麼如同上例這題也是錯的。
但這裏改動的是o的member vairable(成員變量)，而o的reference並無改變。
6.class Something { int i; public void doSomething() { System.out.println("i = " + i); }} 有什麼錯呢?
看不出來啊。答案: 正確。輸出的是"i= 0"。int i屬於instantvariable (實例變量，或叫成員變量)。instantvariable有default value。int的default value是0。
7.class Something { final int i; public void doSomething() {System.out.println("i = " + i); }}和上面一題僅僅有一個地方不一樣，就是多了一個final。這難道就錯了嗎?
答案: 錯。final int i是個final的instant variable (實例變量。或叫成員變量)。final的instant variable沒有default value，必須在constructor (構造器)結束以前被賦予一個明白的值。
可以改動爲"finalint i = 0;"。
8.public class Something { public static void main(String[]args) { Something s = new Something(); System.out.println("s.doSomething() returns " +doSomething()); } public String doSomething() { return "Do something ..."; }} 看上去很是完美。答案: 錯。看上去在main裏calldoSomething沒有什麼問題。畢竟兩個methods都在同一個class裏。但細緻看。main是static的。
staticmethod不能直接call non-static methods。
可改爲"System.out.println("s.doSomething()returns " + s.doSomething());"。
同理。staticmethod不能訪問non-static instant variable。
9.此處。Something類的文件名稱叫OtherThing.javaclassSomething { private static void main(String[] something_to_do) { System.out.println("Do something..."); }} 這個好像很是明顯。
答案: 正確。歷來沒有人說過Java的Class名字必須和其文件名稱一樣。但public class的名字必須和文件名稱一樣。
10．interface A{ intx = 0;} class B{ int x =1;} class C extends B implements A { public voidpX(){ System.out.println(x); } public static void main(String[] args) { newC().pX(); }}答案：錯誤。在編譯時會錯誤發生(錯誤描寫敘述不一樣的JVM有不一樣的信息。意思就是未明白的x調用，兩個x都匹配（就象在同一時候import java.util和java.sql兩個包時直接聲明Date同樣）。對於父類的變量,可以用super.x來明白。而接口的屬性默認隱含爲 public static final.因此可以經過A.x來明白。
11.interface Playable { void play();} interface Bounceable { void play();} interface Rollable extends Playable,Bounceable { Ball ball = newBall("PingPang");} class Ball implements Rollable { private Stringname; public String getName() { return name;} public Ball(String name) {this.name = name; } public void play() { ball = new Ball("Football");System.out.println(ball.getName()); }}這個錯誤不easy發現。答案: 錯。"interfaceRollable extends Playable, Bounceable"沒有問題。interface可繼承多個interfaces，因此這裏沒錯。
問題出在interfaceRollable裏的"Ball ball = newBall("PingPang");"。不論什麼在interface裏聲明的interface variable (接口變量，也可稱成員變量)，默以爲public static final。也就是說"Ballball = new Ball("PingPang");"其實是"publicstatic final Ball ball = new Ball("PingPang");"。在Ball類的Play()方法中。"ball = newBall("Football");"改變了ball的reference，而這裏的ball來自Rollableinterface，Rollable interface裏的ball是public static final的。final的object是不能被改變reference的。所以編譯器將在"ball = new Ball("Football");"這裏顯示有錯。
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
JAVA編程題
1．現在輸入n個數字。以逗號，分開；而後可選擇升或者降序排序；按提交鍵就在還有一頁面顯示按什麼排序，結果爲，提供reset
import java.util.*;
public class bycomma{ public static String[]splitStringByComma(String source){if(source==null||source.trim().equals("")) return null; StringTokenizer commaToker =new StringTokenizer(source,","); String[] result = new String[commaToker.countTokens()]; int i=0; while(commaToker.hasMoreTokens()){ result[i] = commaToker.nextToken(); i++; } return result;}
public static voidmain(String args[]){ String[] s =splitStringByComma("5,8,7,4,3,9,1"); int[] ii = new int[s.length];for(int i = 0;i<s.length;i++){ ii[i] =Integer.parseInt(s[i]); } Arrays.sort(ii); //asc for(int i=0;i<s.length;i++){ System.out.println(ii[i]); } //desc for(int i=(s.length-1);i>=0;i--){ System.out.println(ii[i]); } }}
2．金額轉換，阿拉伯數字的金額轉換成中國傳統的形式如：（￥1011）－>（一千零一拾一元整）輸出。
package test.format;import java.text.NumberFormat;importjava.util.HashMap;public class SimpleMoneyFormat {
public static finalString EMPTY = "";public static final String ZERO = "零";public static final String ONE = "壹";public static final String TWO = "貳";public static final String THREE = "叄";public static final String FOUR = "肆"; public static final String FIVE = "伍";public static final String SIX = "陸";public static final String SEVEN = "柒"; public static final String EIGHT = "捌"; public static final String NINE = "玖"; public static final String TEN = "拾"; public static final String HUNDRED = "佰"; public static final String THOUSAND = "仟"; public staticfinal String TEN_THOUSAND = "萬"; publicstatic final String HUNDRED_MILLION = "億";public static final String YUAN = "元"; publicstatic final String JIAO = "角"; public staticfinal String FEN = "分"; public static final String DOT ="."; private static SimpleMoneyFormat formatter = null;privateHashMap chineseNumberMap = new HashMap(); private HashMap chineseMoneyPattern = new HashMap(); private NumberFormat numberFormat = NumberFormat.getInstance(); private SimpleMoneyFormat() { numberFormat.setMaximumFractionDigits(4); numberFormat.setMinimumFractionDigits(2); numberFormat.setGroupingUsed(false); chineseNumberMap.put("0", ZERO);chineseNumberMap.put("1", ONE); chineseNumberMap.put("2", TWO);chineseNumberMap.put("3", THREE); chineseNumberMap.put("4",FOUR); chineseNumberMap.put("5", FIVE);chineseNumberMap.put("6", SIX); chineseNumberMap.put("7", SEVEN); chineseNumberMap.put("8", EIGHT);chineseNumberMap.put("9", NINE); chineseNumberMap.put(DOT, DOT); chineseMoneyPattern.put("1",TEN); chineseMoneyPattern.put("2", HUNDRED);chineseMoneyPattern.put("3", THOUSAND); chineseMoneyPattern.put("4",TEN_THOUSAND); chineseMoneyPattern.put("5", TEN); chineseMoneyPattern.put("6",HUNDRED); chineseMoneyPattern.put("7", THOUSAND);chineseMoneyPattern.put("8", HUNDRED_MILLION); }
public staticSimpleMoneyFormat getInstance() { if(formatter == null) formatter = newSimpleMoneyFormat(); return formatter; }
public Stringformat(String moneyStr) { checkPrecision(moneyStr); Stringresult; result = convertToChineseNumber(moneyStr); result =addUnitsToChineseMoneyString(result); return result; } public Stringformat(double moneyDouble) { return format(numberFormat.format(moneyDouble));} public String format(int moneyInt){ return format(numberFormat.format(moneyInt));
} public String format(long moneyLong) { returnformat(numberFormat.format(moneyLong)); }
public Stringformat(Number moneyNum) { returnformat(numberFormat.format(moneyNum)); }
private StringconvertToChineseNumber(String moneyStr) { String result; StringBuffer cMoneyStringBuffer = new StringBuffer(); for(int i = 0; i < moneyStr.length(); i++) { cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(i, i +1))); }
//拾佰仟萬億等都是漢字裏面纔有的單位。加上它們int indexOfDot = cMoneyStringBuffer.indexOf(DOT); int moneyPatternCursor = 1; for (int i = indexOfDot - 1; i > 0; i--){ cMoneyStringBuffer.insert(i,chineseMoneyPattern.get(EMPTY + moneyPatternCursor)); moneyPatternCursor = moneyPatternCursor == 8? 1 : moneyPatternCursor + 1; } String fractionPart =cMoneyStringBuffer.substring(cMoneyStringBuffer.indexOf(".")); cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("."),cMoneyStringBuffer.length()); while (cMoneyStringBuffer.indexOf("零拾") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零拾"), cMoneyStringBuffer.indexOf("零拾")+ 2, ZERO);
} while(cMoneyStringBuffer.indexOf("零佰") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零佰"), cMoneyStringBuffer.indexOf("零佰")+ 2, ZERO);
}while(cMoneyStringBuffer.indexOf("零仟") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零仟"), cMoneyStringBuffer.indexOf("零仟")+ 2, ZERO);
}while(cMoneyStringBuffer.indexOf("零萬") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零萬"), cMoneyStringBuffer.indexOf("零萬")+ 2, TEN_THOUSAND);
} while(cMoneyStringBuffer.indexOf("零億") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零億"), cMoneyStringBuffer.indexOf("零億")+ 2, HUNDRED_MILLION); } while (cMoneyStringBuffer.indexOf("零零") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零零"), cMoneyStringBuffer.indexOf("零零")+ 2, ZERO);
} if(cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1,cMoneyStringBuffer.length()); cMoneyStringBuffer.append(fractionPart);
result =cMoneyStringBuffer.toString(); returnresult; }private String addUnitsToChineseMoneyString(String moneyStr) { String result; StringBuffercMoneyStringBuffer = new StringBuffer(moneyStr); int indexOfDot =cMoneyStringBuffer.indexOf(DOT); cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);cMoneyStringBuffer.insert(cMoneyStringBuffer.length() - 1, JIAO);cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN); if(cMoneyStringBuffer.indexOf("零角零分") != -1)//沒有零頭。加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"), cMoneyStringBuffer.length(), "整"); else if(cMoneyStringBuffer.indexOf("零分") != -1)//沒有零分，加整 cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"), cMoneyStringBuffer.length(), "整");
else {if(cMoneyStringBuffer.indexOf("零角")!=-1)
cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),cMoneyStringBuffer.indexOf("零角")+2);
tmpBuffer.append("整"); } result = cMoneyStringBuffer.toString();return result; } private void checkPrecision(String moneyStr) {
int fractionDigits =moneyStr.length() - moneyStr.indexOf(DOT) - 1; if (fractionDigits > 2) thrownew RuntimeException("金額" + moneyStr + "的小數位多於兩位。"); //精度不能比分低 }public static void main(String args[]){ System.out.println(getInstance().format(new Double(10010001.01))); }}
三、繼承時候類的運行順序問題,通常都是選擇題,問你將會打印出什麼?
答:父類： package test;
public class FatherClass { public FatherClass() {System.out.println("FatherClass Create"); } }
子類: package test; import test.FatherClass; public classChildClass extends FatherClass { public ChildClass() {System.out.println("ChildClass Create"); } public static voidmain(String[] args) { FatherClass fc = new FatherClass(); ChildClass cc = newChildClass(); } } 輸出結果： C:>java test.ChildClass FatherClass Create FatherClass Create ChildClass Create
四、內部類的實現方式?
答：演示樣例代碼例如如下： package test; public classOuterClass { private class InterClass { public InterClass() {
System.out.println("InterClass Create"); } } publicOuterClass() { InterClass ic = new InterClass();System.out.println("OuterClass Create"); } public static voidmain(String[] args) { OuterClass oc = new OuterClass(); } } 輸出結果:C:>java test/OuterClass
InterClass Create OuterClassCreate 再一個例題： public class OuterClass { private doubled1 = 1.0;
//insert code here }
You need to insert an inner class declaration at line 3. Whichtwo 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() {returnd1;} }
E. abstract class InnerOne{ public abstract double methoda(); }
說明例如如下： 一.靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。 故 A、B 錯 二.靜態內部類的非靜態成員可以訪問外部類的靜態變量。而不可訪問外部類的非靜態變量；returnd1 出錯。故 D 錯 三.非靜態內部類的非靜態成員可以訪問外部類的非靜態變量。故 C 正確 四.答案爲C、E
五、Java 的通訊編程。編程題(或問答)，用JAVA SOCKET編程。讀server幾個字符，再寫入本地顯示？
答:Server端程序: package test; importjava.net.*; import java.io.*; public class Server { private ServerSocket ss;private Socket socket;
private BufferedReader in; private PrintWriter out; publicServer() { 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 MessageReceived!"); out.close(); in.close(); socket.close(); } }catch(IOException e) { out.println("wrong"); } } public static voidmain(String[] args) { new Server(); } }
Client端程序: package test; importjava.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 = newSocket("127.0.0.1",10000); System.out.println("The ServerConnected!"); System.out.println("Please enter someCharacter:"); BufferedReader line = new BufferedReader(newInputStreamReader(System.in)); out = newPrintWriter(socket.getOutputStream(),true);
Out
JAVA簡答題
一、 接口和內部類、抽象類的特徵答：接口：在一個類裏，僅僅有申明沒有實現。內部類：是在一個類的內部定義的一個類；抽象類：是以abstract 定義的，裏面至少有一個抽象方法。
二、 文件讀寫的基本類
答：File Reader 類和FileWriter類分別繼承自Reader類和Writer類。FileReader類用於讀取文件，File Writer類用於將數據寫入文件，這兩各種在使用前，都必須要調用其構造方法建立對應的對象，而後調用對應的read()或 write()方法。
三、 線程的基本概念、線程的本狀態以及狀態之間的關係
•新建 (Born) : 新建的線程處於新建狀態•就緒 (Ready) : 在建立線程後，它將處於就緒狀態，等待 start() 方法被調用•執行 (Running) : 線程在開始執行時進入執行狀態•睡眠 (Sleeping) : 線程的執行可經過使用 sleep() 方法來臨時停止。在睡眠後。線程將進入就緒狀態
•等待 (Waiting) : 假設調用了 wait() 方法，線程將處於等待狀態。用於在兩個或多個線程併發運行時。
•掛起 (Suspended) : 在暫時中止或中斷線程的運行時，線程就處於掛起狀態。•恢復 (Resume) :在掛起的線程被恢復運行時，可以說它已被恢復。
•堵塞 (Blocked) – 在線程等待一個事件時（好比輸入/輸出操做），就稱其處於堵塞狀態。
•死亡 (Dead) – 在 run() 方法已完畢運行或其stop() 方法被調用以後。線程就處於死亡狀態。
五、 串行化的注意事項以及怎樣實現串行化答：假設有循環引用是不可以串行化的。對象輸出流的WriteObject方法和對象輸入流的ReadObect 方法
四、 線程的同步、怎樣實現線程的同步答：當兩個或多個線程同一時候訪問同一個變量，並且以個線程需要改動這個變量。就要用到線程同步。在Java中，同步是經過 synchronized keyword來定義的。
諾是想同步化某程序段，可以使用 synchronized(object){}方法，當中{}內的程序語句被同步化。
五、 socket通訊（tcp/udp差異及JAVA的實現方式）TCP——傳輸控制協議。具備極高的可靠性，保證數據包依照順序準確到達。但其也有着很是高的額外負擔。UDP——使用者數據元協議，並不能保證數據包會被成功的送達。也不保證數據包到達的順序。但其傳輸速度很是快。
大多數咱們會使用TCP，偶爾纔會動用UDP。如聲音訊號。即便少許遺失，也無 關緊要。
六、 JAVA的事件託付機制和垃圾回收機制
java 事件託付機制的概念,一個源產生一個事件並將它送到一個或多個監聽器那裏。在這樣的方案中，監聽器簡單的等待，直到它收到一個事件。
一旦事件被接受，監聽器將處理這個事件。而後返回。垃圾回收機制垃圾收集是將分配給對象但不在使用的內存回收或釋放的過程。假設一個對象沒有指向它的引用或者其賦值爲null,則次對象適合進行垃圾回收
七、 JDBC調用數據庫的基本步驟導入必要的類。裝入JDBC驅動程序，識別數據源。分配一個Connection對象，分配一個Statement對象。使用Statement運行一個查詢。從返回的ResultSet對象中檢索數據，關閉ResultSet，關閉Statement對象，關閉Connection對象
八、XML文檔定義有幾種形式？它們之間有何本質差異？解析XML文檔有哪幾種方式？答：Dom解析 在內存中建立一個DOM樹，能隨機訪問文件內容，也可以改動原文件內容SAX解析 線性解析，不能隨機訪問，也沒法改動原文件Dom解析要先用SAX解析建立DOM樹
{
a: 兩種形式dtd schema。b:本質差異:schema自己是xml的。可以被XML解析器解析(這也是從DTD上發展schema的根本目的)，c:有DOM,SAX,STAX等
DOM:處理大型文件時其性能降低的很厲害。這個問題是由DOM的樹結構所形成的，這樣的結構佔用的內存較多，而且DOM必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問
SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件。不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件。用戶經過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問
STAX:Streaming API for XML(StAX)
}
九、JAVA的四種基本權限的定義public private protected 默認
十、JAVA的國際化 答：Java 中提供了諾幹國際化明感類，來實現國際化的。
好比：dateformat timezone 等等。
{
國際化英文單詞爲：Internationalization。又稱I18N。I爲因爲單詞的第一個字母，18爲這個單詞的長度，而N表明這個單詞的最後一個字母。國際化又稱本地化（Localization,L10N）。
國際化相關的Java類
Java國際化主要經過例如如下3個類完畢
· java.util.ResourceBundle:用於載入一個資源包
· java.util.Locale：相應一個特定的國家/區域、語言環境。
· java.text.MessageFormat：用於將消息格式化
國際化資源文件
爲實現程序的國際化，必須提供程序所需要的資源文件。資源文件的內容由key-value對組成。
資源文件的命名可以有3種格式：
· basename_language_country.properties
· basename_language.properties
· basename_properties
若資源文件包括非西方字符，則需要用JDK自帶的工具來處理：native2ascii。這個工具的語法格式例如如下：
native2ascii 資源文件名稱目標資源文件名稱
如：
native2ascii mess_zh_XXX.proerties mess_zh_CN.proerties
Locale類可獲取各國區域環境(如：Locale.ENGLISH、Locale.CHINESE，這些常量返回一個Locale實例），也可以獲取當前系統所使用的區域語言環境。
ResourceBundle類可依據指定參數獲取對應的資源，常常用法例如如下
ResourceBundle.getBundle（basename）//獲取當前系統所使用的區域環境得到指定資源文件
ResourceBundle.getBundle（basename,locale）//依據指定的區域獲取相應的資源文件
語言環境
在 Java 語言中。語言環境（locale）不過一個標識符，而不是一組本地化的屬性。java.util.Locale類的一個實例表示一個特定的地理政治區域，使用表示語言、區域以及國家或地區的參數建立。
每個與語言環境相關的類都維護着它本身的一組本地化屬性，並且肯定怎樣對含有Locale 參數的方法請求作出響應。
Java支持的語言和國家
若要獲取Java所支持的語言和國家，可調用Locale類的getAvailableLocale方法獲取。該方法返回一個Locale數組，該數組裏包括了java所支持的語言和國家。
java代碼例如如下：
|
|
|
|
|
|
|
|
|
|
|
|
|
|
程序執行結果例如如下：
Japan=JP Japanese=ja
Peru=PE Spanish=es
= English=en
Japan=JP Japanese=ja
Panama=PA Spanish=es
Bosnia and Herzegovina=BA Serbian=sr
= Macedonian=mk
Guatemala=GT Spanish=es
United Arab Emirates=AE Arabic=ar
Norway=NO Norwegian=no
Albania=AL Albanian=sq
= Bulgarian=bg
Iraq=IQ Arabic=ar
Yemen=YE Arabic=ar
= Hungarian=hu
Portugal=PT Portuguese=pt
Cyprus=CY Greek=el
Qatar=QA Arabic=ar
Macedonia=MK Macedonian=mk
= Swedish=sv
Switzerland=CH German=de
United States=US English=en
Finland=FI Finnish=fi
= Icelandic=is
= Czech=cs
Malta=MT English=en
Slovenia=SI Slovenian=sl
Slovakia=SK Slovak=sk
= Italian=it
Turkey=TR Turkish=tr
= Chinese=zh
= Thai=th
Saudi Arabia=SA Arabic=ar
= Norwegian=no
United Kingdom=GB English=en
Serbia and Montenegro=CS Serbian=sr
= Lithuanian=lt
= Romanian=ro
New Zealand=NZ English=en
Norway=NO Norwegian=no
Lithuania=LT Lithuanian=lt
Nicaragua=NI Spanish=es
= Dutch=nl
Ireland=IE Irish=ga
Belgium=BE French=fr
Spain=ES Spanish=es
Lebanon=LB Arabic=ar
= Korean=ko
Canada=CA French=fr
Estonia=EE Estonian=et
Kuwait=KW Arabic=ar
Serbia=RS Serbian=sr
United States=US Spanish=es
Mexico=MX Spanish=es
Sudan=SD Arabic=ar
Indonesia=ID Indonesian=in
= Russian=ru
= Latvian=lv
Uruguay=UY Spanish=es
Latvia=LV Latvian=lv
= Hebrew=iw
Brazil=BR Portuguese=pt
Syria=SY Arabic=ar
= Croatian=hr
= Estonian=et
Dominican Republic=DO Spanish=es
Switzerland=CH French=fr
India=IN Hindi=hi
Venezuela=VE Spanish=es
Bahrain=BH Arabic=ar
Philippines=PH English=en
Tunisia=TN Arabic=ar
= Finnish=fi
Austria=AT German=de
= Spanish=es
Netherlands=NL Dutch=nl
Ecuador=EC Spanish=es
Taiwan=TW Chinese=zh
Jordan=JO Arabic=ar
= Belarusian=be
Iceland=IS Icelandic=is
Colombia=CO Spanish=es
Costa Rica=CR Spanish=es
Chile=CL Spanish=es
Egypt=EG Arabic=ar
South Africa=ZA English=en
Thailand=TH Thai=th
Greece=GR Greek=el
Italy=IT Italian=it
= Catalan=ca
Hungary=HU Hungarian=hu
= French=fr
Ireland=IE English=en
Ukraine=UA Ukrainian=uk
Poland=PL Polish=pl
Luxembourg=LU French=fr
Belgium=BE Dutch=nl
India=IN English=en
Spain=ES Catalan=ca
Morocco=MA Arabic=ar
Bolivia=BO Spanish=es
Australia=AU English=en
= Serbian=sr
Singapore=SG Chinese=zh
= Portuguese=pt
= Ukrainian=uk
El Salvador=SV Spanish=es
Russia=RU Russian=ru
South Korea=KR Korean=ko
= Vietnamese=vi
Algeria=DZ Arabic=ar
Vietnam=VN Vietnamese=vi
Montenegro=ME Serbian=sr
= Albanian=sq
Libya=LY Arabic=ar
= Arabic=ar
China=CN Chinese=zh
Belarus=BY Belarusian=be
Hong Kong=HK Chinese=zh
= Japanese=ja
Israel=IL Hebrew=iw
Bulgaria=BG Bulgarian=bg
= Indonesian=in
Malta=MT Maltese=mt
Paraguay=PY Spanish=es
= Slovenian=sl
France=FR French=fr
Czech Republic=CZ Czech=cs
Switzerland=CH Italian=it
Romania=RO Romanian=ro
Puerto Rico=PR Spanish=es
Canada=CA English=en
Germany=DE German=de
= Irish=ga
Luxembourg=LU German=de
= German=de
Argentina=AR Spanish=es
= Slovak=sk
Malaysia=MY Malay=ms
Croatia=HR Croatian=hr
Singapore=SG English=en
= Danish=da
= Maltese=mt
= Polish=pl
Oman=OM Arabic=ar
= Turkish=tr
Thailand=TH Thai=th
= Greek=el
= Malay=ms
Sweden=SE Swedish=sv
Denmark=DK Danish=da
Honduras=HN Spanish=es
經過該程序。咱們就可以得到Java程序所支持的國家/語言環境。
JAVA程序的國際化
原始程序：
system.out.println("Hello");
當中Hello字符串需國際化，定義資源文件，文件名稱分別爲base_zh_CN.properties和base_en_US
base_zh_CN.properties文件內容例如如下：
hello=你好
base_en_US.properties文件內容例如如下：
hello=Hello
將這兩個文件放入某個包中，如「com.jj.test」，用native2ascii又一次生成資源文件
改動程序：
Locale myLocale = Locale.getDefault();//得到系統默認的國家/語言環境
ResourceBundle bundle =ResourceBundle.getBundle("base",myLocale);//依據指定的國家/語言環境載入相應的資源文件
System.out.println(bundle.getString(hello"));//得到本地化字符串
JAVA國際化流程
ResourceBundle依據Locale載入資源文件->返回一個ResourceBundle實例->ResourceBundle調用getString方法返回指定key相應的字符串
帶佔位符的消息
上面的輸出消息是一個間的的消息。若要輸出的消息中必須包括動態的內容，這些內容必須是從程序中獲取的，可利用帶佔位符的國際化資源文件來實現。
好比如下的字符串：
你好。Eason!今天是07-5-30下午 13:00
Eason是瀏覽者的姓名，必須動態改變，後面的時間也必須動態改變。則此處需要2個佔位符。
資源文件演示樣例：
msg=你好，{0}!今天是{1}
程序中需要使用MessageFormat類
該類有個靜態方法：
format(String pattern,Object … values)
上例相應的JAVA中的字符串輸出代碼例如如下：
ResourceBundle bundle =ResourceBundle.getBundle("MyResource", currentLocale);
String msg = bundle.getString("msg");
System.out.println(MessageFormat.format(msg,"Eason",new Date()));
使用類文件取代資源文件
Java贊成使用類文件來取代資源文件，即手動書寫代碼來實現國際化。
· 該類要求繼承於ListResourceBundle,並重寫getContents方法該方法返回Object數組，該數組的每一個項都是key-value對。
· 類的名字必須爲basename_language_contry，這與屬性文件的命名類似。
如：
public class MyResource_zh_CNextends ListResourceBundle {
private final Object myData[][]= {
{"msg","{0},Hello"}
};
public Object[][] getContents() {return myData;}
}
上面這個是中文簡體語言環境下的資源文件。該類可以替換MyResource_zh_CN.properties屬性文件。
假設系統同一時候存在資源文件、類文件。系統將以類文件爲主，而不會調用資源文件。
好比對於basename爲MyResourse的這一系列中文資源文件，系統搜索順序例如如下：
· MyResourse_zh_CN。class
· MyResourse_zh_CN.properties
· MyResourse_zh.class
· MyResourse_zh.properties
· MyResourse.class
· MyResourse.properties
}
十一、 forward和rederect的差異答：redirect重定向到另一個頁面，又一次開始一個請求forward跳轉到另一個頁面， 請求不斷開
12 jsp的常用的命令答：page, include, talib, forward,
1三、 什麼狀況下調用doget()和什麼狀況dopost答：當表單提交時method設置的 是 get 就調用 doget 方法，假設是post 就調用 dopost方法。 http get方法請求一頁面，調用doget()http post方法請求一頁面，調用dopost()
1四、 servlet的init()方法和service()方法的差異答：初始化時調用init()方法有請求到達時調用service()方法，service()依據請求的類型。調用doget()或depost()等方法
1五、 servlet的配置
<web-app>
<servlet>
<servlet-name>Admin</servlet-name>
<servlet-class>jb-aptech.adminservlet</servlet-class>
<init-param>
<param-name>email</param-name>
<param-value>admin@jb-aptech.com.cn</param-value>
</init-param>
</servlet>
</web-app>
1六、 remote接口和home接口主要做用remote接口定義了業務方法，用於EJBclient調用業務方法home接口是EJB工廠用於建立和移除查找EJB實例
1七、 客服port調用EJB對象的幾個基本步驟答;設置JNDI服務工廠以及JNDI服務地址系統屬性，查找Home接口，從Home接口調用Create方法建立Remote接口經過Remote接口調用其業務方法
1八、java的調試怎樣進行。
答：jdb 是java的調試器，相似於 UNIX系統的調試器 dbx,jdb 使用 Java調試器應用程序接口來完畢對本地或遠程的Java調試器的調用工做。
一般是在要測試的代碼段想控制檯打印消息。
1九、 java中對象之間的通信採用什麼方法。答：直接調用還有一對象方法來進行通信以及數據的交換。
20、tcp/ip在鏈接是有幾回握手？釋放是有幾回握手？答：創建鏈接是2次,釋放是3次。
{
第一步是請求端（client）發送一個包括SYN即同步（Synchronize）標誌的TCP報文。SYN同步報文會指明client使用的port以及TCP鏈接的初始序號。
第二步。server在收到client的SYN報文後，將返回一個SYN+ACK的報文。表示client的請求被接受，同一時候TCP序號被加一，ACK即確認（Acknowledgement）。
第三步。client也返回一個確認報文ACK給server端，相同TCP序列號被加一。到此一個TCP鏈接完畢。 而後才開始通訊的第二步：數據處理。
TCP/IP協議的三次握手及實現原理
時間:2004-08-19 08:00來源:中國網管聯盟 做者:BitsCN整理點擊:830次
TCP/IP是很是多的不一樣的協議組成。其實是一個協議組。TCP用戶數據報表協議(也稱做TCP傳輸控制協議，TransportControl Protocol。可靠的主機到主機層協議。
這裏要先強調一下。傳輸控制協議是OSI網絡的第四層的叫法，TCP傳輸控制協議是TCP/IP傳輸的6個基本協議的一種。
兩個TCP意思非一樣。)。TCP是一種可靠的面向鏈接的傳送服務。它在傳送數據時是分段進行的。主機交換數據必須創建一個會話。
它用比特流通訊。即數據被做爲無結構的字節流。
經過每個TCP傳輸的字段指定順序號。以得到可靠性。
是在OSI參考模型中的第四層，TCP是使用IP的網間互聯功能而提供可靠的傳輸數據，IP不停的把報文放到 網絡上，而TCP是負責確信報文到達。
在協同IP的操做中TCP負責：握手過程、報文管理、流量控制、錯誤檢測和處理（控制），可以依據必定的編號順序對非正常順序的報文給予重新排列順序。關於TCP的RFC文檔有RFC79三、RFC79一、RFC1700。
在TCP會話初期，有所謂的「三握手」：對每次發送的數據量是如何跟蹤進行協商使數據段的發送和接收同步，依據所接收到的數據量而肯定的數據確認數及數據發送、接收完成後什麼時候撤消聯繫。並創建虛鏈接。爲了提供可靠的傳送，TCP在發送新的數據以前，以特定的順序將數據包的序號，並需要這些包傳送給目標機以後的確認消息。
TCP老是用來發送大批量的數據。
當應用程序在收到數據後要作出確認時也要用到TCP。由於TCP需要時刻跟蹤，這需要額外開銷，使得TCP的格式有些顯得複雜。如下就讓咱們看一個TCP的經典案例，這是後來被稱爲MITNICK攻擊中KEVIN開創了兩種攻擊技術：
TCP會話劫持
SYN FLOOD（同步洪流）
在這裏咱們討論的時TCP會話劫持的問題。
先讓咱們明確TCP創建鏈接的基本簡單的過程。爲了建設一個小型的模仿環境咱們若是有3臺接入互聯網的機器。A爲攻擊者操縱的攻擊機。
B爲中介跳板機器（受信任的server）。C爲受害者使用的機器（可能是server），這裏把C機器鎖定爲目標機器。A機器向B機器發送SYN包，請求創建鏈接，這時已經響應請求的B機器會向A機器迴應SYN/ACK代表容許創建鏈接，當A機器接受到B機器發送的SYN/ACK迴應時，發送應答ACK創建A機器與B機器的網絡鏈接。這樣一個兩臺機器之間的TCP通話信道就創建成功了。
B終端受信任的server向C機器發起TCP鏈接。A機器對server發起SYN信息。使C機器不能響應B機器。在同一時候A機器也向B機器發送虛假的C機器迴應的SYN數據包，接收到SYN數據包的B機器（被C機器信任）開始發送應答鏈接創建的SYN/ACK數據包，這時C機器正在忙於響應曾經發送的SYN數據而無暇迴應B機器。而A機器的攻擊者預測出B機器包的序列號（現在的TCP序列號預測難度有所加大）假冒C機器向B機器發送應答ACK這時攻擊者騙取B機器的信任。假冒C機器與B機器創建起TCP協議的對話鏈接。這個時候的C機器仍是在響應攻擊者A機器發送的SYN數據。網管聯盟www.bitsCN.com
TCP協議棧的弱點：TCP鏈接的資源消耗。當中包含：數據包信息、條件狀態、序列號等。經過有益不完畢創建鏈接所需要的三次握手過程，形成鏈接一方的資源耗盡。
經過攻擊者有意的不完畢創建鏈接所需要的三次握手的全過程，從而形成了C機器的資源耗盡。序列號的可預測性，目標主機應答鏈接請求時返回的SYN/ACK的序列號時可預測的。（早期TCP協議棧，詳細的可以參見1981年出的關於TCP雛形的RFC793文檔）
TCP頭結構
TCP協議頭最少20個字節。包含下面的區域（由於翻譯不由一樣，文章中給出對應的英文單詞）：
TCP源port(SourcePort)：16位的源port當中包括初始化通訊的port。源port和源IP地址的做用是標示報問的返回地址。
TCP目的port(Destinationport)：16位的目的port域定義傳輸的目的。這個port指明報文接收計算機上的應用程序地址接口。
TCP序列號（序列碼,SequenceNumber）：32位的序列號由接收端計算機使用，又一次分段的報文成最初形式。
當SYN出現，序列碼其實是初始序列碼（ISN）。而第一個數據字節是ISN+1。這個序列號（序列碼）是可以補償傳輸中的 不一致。
TCP應答號(AcknowledgmentNumber)：32位的序列號由接收端計算機使用，重組分段的報文成最初形式。
，假設設置了ACK控制位，這個值表示一個準備接收的包的序列碼。
數據偏移量(HLEN)：4位包含TCP頭大小，指示何處數據開始。
保留(Reserved)：6位值域，這些位必須是0。爲了未來定義新的用途所保留。
標誌(Code Bits)：6位標誌域。表示爲：緊急標誌、有意義的應答標誌、推、重置鏈接標誌、同步序列號標誌、完畢發送數據標誌。依照順序排列是：URG、ACK、PSH、RST、SYN、FIN。
窗體(Window)：16位，用來表示想收到的每個TCP數據段的大小。
校驗位(Checksum)：16位TCP頭。
源機器基於數據內容計算一個數值，收信息機要與源機器數值 結果全然同樣，從而證實數據的有效性。
優先指針（緊急,Urgent Pointer）：16位，指向後面是優先數據的字節。在URG標誌設置了時纔有效。假設URG標誌沒有被設置，緊急域做爲填充。加快處理標示爲緊急的數據段。
選項(Option)：長度不定。但長度必須以字節。假設沒有 選項就表示這個一字節的域等於0。
填充：不定長。填充的內容必須爲0，它是爲了數學目的而存在。目的是確保空間的可預測性。
保證包頭的結合和數據的開始處偏移量能夠被32整除，通常額外的零以保證TCP頭是32位的整數倍。
標誌控制功能
URG：緊急標誌
緊急(The urgent pointer) 標誌有效。緊急標誌置位，
ACK：確認標誌
確認編號(Acknowledgement Number)欄有效。
大多數狀況下該標誌位是置位的。
TCP報頭內的確認編號欄內包括的確認編號(w+1。Figure：1)爲下一個預期的序列編號，同一時候提示遠端系統已經成功接收所有數據。
PSH：推標誌
該標誌置位時。接收端不將該數據進行隊列處理，而是儘量快將數據轉由應用處理。在處理 telnet 或rlogin 等交互模式的鏈接時，該標誌老是置位的。
RST：復位標誌
復位標誌有效。用於復位對應的TCP鏈接。
SYN：同步標誌
同步序列編號(Synchronize Sequence Numbers)欄有效。
該標
志僅在三次握手創建TCP鏈接時有效。
它提示TCP鏈接的服務端檢查序列編號，該序列編號爲TCP鏈接初始端(一般是client)的初始序列編號。在這裏，可以把TCP序列編號看做是一個範圍從0到4，294，967，295的32位計數器。經過TCP鏈接交換的數據中每一個字節都通過序列編號。在TCP報頭中的序列編號欄包含了TCP分段中第一個字節的序列編號。
FIN：結束標誌
帶有該標誌置位的數據包用來結束一個TCP回話，但相應port仍處於開放狀態，準備接收興許數據。網管網bitsCN_com
服務端處於監聽狀態，client用於創建鏈接請求的數據包(IP packet)依照TCP/IP協議堆棧組合成爲TCP處理的分段(segment)。
分析報頭信息： TCP層接收到對應的TCP和IP報頭。將這些信息存儲到內存中。
檢查TCP校驗和(checksum)：標準的校驗和位於分段之中(Figure：2)。
假設檢驗失敗，不返回確認，該分段丟棄，並等待client進行重傳。
查找協議控制塊(PCB{})：TCP查找與該鏈接相關聯的協議控制塊。假設沒有找到，TCP將該分段丟棄並返回RST。(這就是TCP處理沒有port監聽狀況下的機制)假設該協議控制塊存在，但狀態爲關閉。服務端不調用connect()或listen()。
該分段丟棄，但不返回RST。client會嘗試又一次創建鏈接請求。
創建新的socket：當處於監聽狀態的socket收到該分段時。會創建一個子socket。同一時候還有socket{}。tcpcb{}和pub{}創建。這時假設有發生錯誤。會經過標誌位來拆除對應的socket和釋放內存，TCP鏈接失敗。
假設緩存隊列處於填滿狀態。TCP以爲有發生錯誤。所有的興許鏈接請求會被拒絕。這裏可以看出SYN Flood攻擊是怎樣起做用的。
丟棄：假設該分段中的標誌爲RST或ACK，或者沒有SYN標誌，則該分段丟棄。並釋放對應的內存。
發送序列變量
SND.UNA ： 發送未確認
SND.NXT ： 發送下一個
SND.WND ： 發送窗體
SND.UP ： 發送優先指針
SND.WL1 ： 用於最後窗體更新的段序列號
SND.WL2 ： 用於最後窗體更新的段確認號
ISS ： 初始發送序列號
接收序列號
RCV.NXT ： 接收下一個
RCV.WND ： 接收下一個
RCV.UP ： 接收優先指針
IRS ： 初始接收序列號
當前段變量
SEG.SEQ ： 段序列號
SEG.ACK ： 段確認標記
SEG.LEN ： 段長
SEG.WND ： 段窗體
SEG.UP ： 段緊急指針
SEG.PRC ： 段優先級
CLOSED表示沒有鏈接，各個狀態的意義例如如下：
LISTEN ： 監聽來自遠方TCPport的鏈接請求。
SYN-SENT ： 在發送鏈接請求後等待匹配的鏈接請求。
SYN-RECEIVED ：在收到和發送一個鏈接請求後等待對鏈接請求的確認。
ESTABLISHED ：表明一個打開的鏈接，數據可以傳送給用戶。
FIN-WAIT-1 ： 等待遠程TCP的鏈接中斷請求，或先前的鏈接中斷請求的確認。
FIN-WAIT-2 ： 從遠程TCP等待鏈接中斷請求。
CLOSE-WAIT ： 等待從本地用戶發來的鏈接中斷請求。
CLOSING ：
文章轉載自網管之家：http://www.bitscn.com/network/tcpip/200604/15008.html
【揭祕TCP/IP協議簇】——TCP/IP的三次握手創建鏈接
2009-05-11 21:47:44| 分類：computer|標籤：|字號大中小訂閱
PS：主要看看抓包怎樣看。
Internet是使用TCP/IP協議簇。互聯網發展之因此迅猛，恐怕得益於TCP/IP協議簇吧。Internet發展到今天，TCP/IP協議也顯示出它的缺憾之處。爲了保障信息安全，大量新的安全協議增長到TCP/IP協議你們庭裏。無論是技術人員仍是維護人員。都要熟悉、甚至精通於TCP/IP協議。最起碼要對TCP/IP協議簇中最基礎、最重要的協議，如：TCP、IP、ARP、HTTp、FTP等協議瞭如指掌。
因而，爲了我本身更深刻地學習、幫助那些像我同樣熱愛計算機網絡而自學的朋友們，我決定在個人百度空間裏搞一個「揭祕TCP/IP協議簇」系列文章。不是系統解說（我也沒那個本事），抓協議中的某幾個關鍵點進行探討。
錯誤之處，敬請朋友們斧正。
在TCP/IP協議簇中第三層運輸層中。有兩種運輸層協議：UDP、TCP。當中TCP是面向鏈接的。
經過三次握手，client與服務端創建TCP鏈接。
圖一 TCP三次手鍊接
使用GreenBrowser網頁瀏覽器鏈接GNU的站點：http://www.gnu.org。應用層Http協議使用TCP協議創建鏈接，而後利用http協議在client與Webserver之間傳遞網頁數據。
使用Sniffer Pro 4.0抓取三次握手的數據包:
圖二
在上圖中client：Lenovo-3a3db1b1，server是gnu.org，client發起的第一次鏈接數據包具體內容：
圖三
鏈接的目的port是80，表示鏈接的是Webserver（server中Web服務進程）。client隨機選擇一個初始序列號。並把SYN置爲1，表示發起TCP鏈接。
圖四 Web服務進程應答client的鏈接
web服務進程也隨機選擇一串數字做爲鏈接序列號，ACK數爲client發起鏈接的初始序列號加1。Webserver進行可以與多個Webclient創建鏈接，提供服務，這樣可以把每一個鏈接差異開。
ACK置爲1。表示是應答是數據包。
圖五
向Web服務進程發起鏈接的Webclient應答Webserver對本身鏈接的應答的應答。這時TCP鏈接成功了，接下Webclient可以用HTTP協議請求Web網頁數據。這三次鏈接中有一個鏈接錯誤。就不能創建TCP鏈接。通訊中斷。假設。通訊要繼續。還要進行三次握手鍊接
}
2一、 談談你對swing mvc模式的理解？
答：Swing號稱是全然依照MVC的思路來進行設計的。在設計開始前。Swing的但願能夠達到的目標就包含：
模型驅動（Model-Driven）的編程方式。 提供一套單一的API，但是能夠支持多種視感（look-and-feel）。爲用戶提供不一樣的界面。
嚴格的說。Swing中的MVC其實是MVC的一個變體：M-VC。Swing中僅僅顯示的定義了Model接口，而在一個UI對象中集成了視圖和控制器的部分機制。View和Control比較鬆散的交叉組合在一塊兒，而不少其它的控制邏輯是在事件監聽者部分引入的。 但是，這並無妨礙在Swing中體現MVC的精髓。其實，在Swing的開發初期，Swing確實是依照標準的MVC模式來設計的，但是很是快的問題就出現了：View和Controller其實是緊密耦合的，很是難做出一個能夠適應不一樣View的通常化的Controller來，而且，通常也沒有很是大的必要。
2二、Java中線程間怎麼通信？什麼叫僵死線程？答：線程之間可以經過管道進行通信。
{
Java中線程間通信可以用共享變量。或者管道。
在多線程中，線程會sleep,當程序中止時,線程仍然處於sleep中,就出現了僵死線程
}
2三、 Java程序怎麼優化？答：提升JAVA的性能。通常考慮例如如下的四個主要方面：
（1） 程序設計的方法和模式 （2）JAVA佈署的環境。 （3） JAVA應用程序的實現(4) 硬件和操做系統 爲了提升JAVA程序的性能。需要遵循例如如下的六個步驟。a) 明白對性能的詳細要求 b) 瞭解當前程序的性能 c) 找到程序的性能瓶頸 d) 採取適當的措施來提升性能 e) 僅僅進行某一方面的改動來提升性能 f) 返回到步驟c,繼續做相似的工做。一直達到要求的性能爲止。
2四、 在java中怎樣進行socket編程。答：Sockets有兩種基本的操做方式:面向鏈接的和無鏈接的。
無鏈接的操做使用數據報協議.這個模式下的socket不需要鏈接一個目的的socket,它僅僅是簡單地投出數據報.無鏈接的操做是高速的和高效的,但是數據安全性不佳.面向鏈接的操做使用TCP協議.一個這個模式下的socket必須在發送數據以前與目的地的socket取得一個鏈接.一旦鏈接創建了,sockets就可以使用一個流接口:打開-讀-寫-關閉.所有的發送的信息都會在還有一端以相同的順序被接收.面向鏈接的操做比無鏈接的操做效率更低,但是數據的安全性更高.
在server，使用ServerSocket監聽指定的port，port可以任意指定（由於1024下面的port一般屬於保留port，在一些操做系統中不可以任意使用，因此建議使用大於1024的port）。等待客戶鏈接請求，客戶鏈接後，會話產生；在完畢會話後。關閉鏈接。在client，使用Socket對網絡上某一個server的某一個port發出鏈接請求。一旦鏈接成功，打開會話；會話完畢後，關閉Socket。client不需要指定打開的port。一般暫時的、動態的分配一個1024以上的port。
2五、 用java如何實現多線程？線程有那些狀態？答：Java 中實現多線程的方法有兩種，一是繼承 java.lang 包中的 Thread 類,二是用戶本身的類實現Runnable 接口。初始狀態，就緒狀態，堵塞狀態，執行狀態，死亡狀態。
2六、 編譯java用那些命令？答：javac編譯命令。Help命令可以幫助你獲得你想要的命令。
2七、 同一時候編譯java兩個類應帶什麼參數？答：CLASSPATH
{
?
??
??????????
?????
????????
???
???
?????
}
28.動態查詢怎樣實現？表的結構變化後，假設不需要改動程序，怎樣設計和實現查詢？答：講查詢封裝進存儲過程當中，經過調用存儲過程實現動態調用。表結構發生變化後改動對應的存儲過程就能夠再不改動程序的狀況下實現查詢。
2九、 怎樣優化數據庫。怎樣提升數據庫的性能？答：優化數據庫主要是優化查詢語句，經過高性能的查詢語句提升數據庫的性能。
30、 設計數據庫應注意那些問題答：首先應儘可能知足三範式的要求。在必定程度上打破3範式的要求以提升數據庫的性能。
{
轉：輕鬆學習三範式
一範式1NF
1、數據庫表的每一行都是不可切割的基本數據項，同一列中不能有多個值，即實體中的某個屬性不能有多個值或不能有反覆的屬性。
假設出現反覆的屬性。就可能需要定義一個新的實體，新的實體由反覆的屬性構成，新實體與原實體之間爲一對多關係。
2、表的每一行包括一個實例的信息。
2.2. 第二範式2NF
1、要求數據庫表中的每個實例或行必須是惟一的。爲實現區分。一般需要爲表加一個列，以存儲各個實例的惟一標識（即主鍵）。
2、實體的屬性全然依賴於主keyword。所謂全然依賴指不能存在僅依賴主keyword一部分的屬性。假設存在，那麼這個屬性和主keyword的這一部分應該分離出來造成一個新的實體，新實體與原實體之間是一對多的關係。爲實現區分一般需要爲表加上一個列。以存儲各個實例的惟一標識。
總之第二範式就是非主屬性非部分依賴於主keyword。
2.3. 第三範式3NF
一個數據庫表中不包括已在其它表中已包括的非主keyword信息。好比存在一個部門信息表。當中每個部門有部門編號DEPT_ID、部門名稱、部門簡單介紹等信息。那麼在員工信息表中列出的部門編號DEPT_ID後，就不能再有關於部門的其它信息，不然就會形成數據冗餘。
第一範式（1NF）：在關係模式R中的每一個詳細關係r中，假設每一個屬性值都是不可再分的最小數據單位，則稱R是第一範式的關係。例：如職工號，姓名，電話號碼組成一個表（一我的可能有一個辦公室電話和一個家裏電話號碼）規範成爲1NF有三種方法：
一是反覆存儲職工號和姓名。這樣。keyword僅僅能是電話號碼。
二是職工號爲keyword，電話號碼分爲單位電話和住宅電話兩個屬性
三是職工號爲keyword，但強制每條記錄僅僅能有一個電話號碼。
以上三個方法，第一種方法最不可取，按實際狀況選取後兩種狀況。
第二範式（2NF）：假設關係模式R（U，F）中的所有非主屬性都全然依賴於隨意一個候選keyword，則稱關係R是屬於第二範式的。
例：選課關係 SCI（SNO，CNO，GRADE，CREDIT）當中SNO爲學號， CNO爲課程號，GRADEGE爲成績。CREDIT爲學分。由以上條件，keyword爲組合keyword（SNO，CNO）
在應用中使用以上關係模式有下面問題：
a.數據冗餘，若是同一門課由40個學生選修。學分就反覆40次。
b.更新異常，若調整了某課程的學分，對應的元組CREDIT值都要更新，有可能會出現同一門課學分不一樣。
c.插入異常。如計劃開新課，由於沒人選修，沒有學號keyword。僅僅能等有人選修才幹把課程和學分存入。
d.刪除異常，若學生已經結業，從當前數據庫刪除選修記錄。某些門課程新生還沒有選修，則此門課程及學分記錄沒法保存。
緣由：非keyword屬性CREDIT僅函數依賴於CNO，也就是CREDIT部分依賴組合keyword（SNO。CNO）而不是全然依賴。
解決方法：分紅兩個關係模式 SC1（SNO，CNO，GRADE），C2（CNO。CREDIT）。
新關係包含兩個關係模式。它們之間經過SC1中的外keywordCNO相聯繫，需要時再進行天然聯接。恢復了原來的關係
第三範式（3NF）：假設關係模式R（U。F）中的所有非主屬性對不論什麼候選keyword都不存在傳遞信賴，則稱關係R是屬於第三範式的。
例：如S1（SNO。SNAME，DNO，DNAME，LOCATION）各屬性分別表明學號，
姓名，所在系。系名稱，系地址。
keywordSNO決定各個屬性。
由於是單個keyword。沒有部分依賴的問題。確定是2NF。但這關係確定有大量的冗餘。有關學生所在的幾個屬性DNO，DNAME，LOCATION將反覆存儲，插入，刪除和改動時也將產生相似以上例的狀況。
緣由：關係中存在傳遞依賴形成的。
即SNO ->DNO。
而DNO -> SNO卻不存在，DNO -> LOCATION, 所以關鍵遼 SNO對 LOCATION函數決定是經過傳遞依賴 SNO -> LOCATION實現的。也就是說，SNO不直接決定非主屬性LOCATION。
解決目地：每個關係模式中不能留有傳遞依賴。
解決方法：分爲兩個關係 S（SNO。SNAME。DNO）。D（DNO，DNAME，LOCATION）
注意：關係S中不能沒有外keywordDNO。
不然兩個關係之間失去聯繫。
BCNF：假設關係模式R（U，F）的所有屬性（包括主屬性和非主屬性）都不傳遞依賴於R的不論什麼候選keyword。那麼稱關係R是屬於BCNF的。
或是關係模式R。假設每個決定因素都包括keyword（而不是被keyword所包括）。則RCNF的關係模式。
例：配件管理關係模式 WPE（WNO，PNO，ENO。QNT）分別表倉庫號，配件號。職工號。數量。有下面條件
a.一個倉庫有多個職工。
b.一個職工僅在一個倉庫工做。
c.每個倉庫裏一種型號的配件由專人負責。但一我的可以管理幾種配件。
d.同一種型號的配件可以分放在幾個倉庫中。
分析：由以上得 PNO不能肯定QNT，由組合屬性（WNO，PNO）來決定，存在函數依賴（WNO，PNO） -> ENO。由於每個倉庫裏的一種配件由專人負責，而一我的可以管理幾種配件，因此有組合屬性（WNO。PNO）才幹肯定負責人，有（WNO。PNO）-> ENO。
因爲一個職工僅在一個倉庫工做，有ENO -> WNO。因爲每個倉庫裏的一種配件由專人負責，而一個職工僅在一個倉庫工做，有（ENO，PNO）-> QNT。
找一下候選keyword，因爲（WNO。PNO） -> QNT。（WNO，PNO）-> ENO 。所以（WNO，PNO）可以決定整個元組，是一個候選keyword。依據ENO->WNO，（ENO。PNO）->QNT，故（ENO，PNO）也能決定整個元組，爲還有一個候選keyword。屬性ENO，WNO。PNO均爲主屬性，僅僅有一個非主屬性QNT。它對不論什麼一個候選keyword都是全然函數依賴的，並且是直接依賴，因此該關係模式是3NF。
分析一下主屬性。因爲ENO->WNO，主屬性ENO是WNO的決定因素，但是它自己不是keyword，僅僅是組合keyword的一部分。這就形成主屬性WNO對另一個候選keyword（ENO，PNO）的部分依賴。因爲（ENO。PNO）-> ENO但反過來不成立。而P->WNO。故（ENO。PNO）-> WNO 也是傳遞依賴。
儘管沒有非主屬性對候選關鍵遼的傳遞依賴，但存在主屬性對候選keyword的傳遞依賴。相同也會帶來麻煩。如一個新職工分配到倉庫工做，但臨時處於實習階段，沒有獨立負責對某些配件的管理任務。由於缺乏keyword的一部分PNO而沒法插入到該關係中去。又如某我的改爲不管配件了去負責安全，則在刪除配件的同一時候該職工也會被刪除。
解決的方法：分紅管理EP（ENO，PNO，QNT），keyword是（ENO，PNO）工做EW（ENO，WNO）其keyword是ENO
缺點：分解後函數依賴的保持性較差。
如此例中，由於分解,函數依賴（WNO。PNO）-> ENO 丟失了, 於是對原來的語義有所破壞。沒有體現出每個倉庫裏一種部件由專人負責。有可能出現一部件由兩我的或兩個以上的人來同一時候管理。
所以，分解以後的關係模式減小了部分完整性約束。
一個關係分解成多個關係。要使得分解有意義，起碼的要求是分解後不丟失原來的信息。這些信息不只包含數據自己，而且包含由函數依賴所表示的數據之間的相互制約。
進行分解的目標是達到更高一級的規範化程度，但是分解的同一時候必須考慮兩個問題：無損聯接性和保持函數依賴。有時每每不可能作到既有無損聯接性，又全然保持函數依賴。
需要依據需要進行權衡。
1NF直到BCNF的四種範式之間有例如如下關係：
BCNF包括了3NF包括2NF包括1NF
小結：
目地：規範化目的是使結構更合理，消除存儲異常。使數據冗餘儘可能小。便於插入、刪除和更新
原則：聽從概念單一化 "一事一地"原則。即一個關係模式描寫敘述一個實體或實體間的一種聯繫。規範的實質就是概念的單一化。
方法：將關係模式投影分解成兩個或兩個以上的關係模式。
要求：分解後的關係模式集合應當與原關係模式"等價"，即通過天然聯接可以恢復原關係而不丟失信息，並保持屬性間合理的聯繫。
注意：一個關係模式結這分解能夠獲得不一樣關係模式集合，也就是說分解方法不是惟一的。
最小冗餘的要求必須以分解後的數據庫能夠表達原來數據庫全部信息爲前提來實現。
其根本目標是節省存儲空間，避免數據不一致性。提升對關係的操做效率，同一時候知足應用需求。實際上，並不必定要求全部模式都達到BCNF不可。有時有益保留部分冗餘可能更方便數據查詢。尤爲對於那些更新頻度不高，查詢頻度極高的數據庫系統更是如此。
在關係數據庫中，除了函數依賴以外還有多值依賴。聯接依賴的問題，從而提出了第四範式，第五範式等更高一級的規範化要求。在此，之後再談。
各位朋友，你看事後有何感想，事實上，不論什麼一本數據庫基礎理論的書都會講這些東西，考慮到很是多網友是半途出家。來作數據庫。特找一本書大抄特抄一把。各位有什麼問題，也別問我了，自已去找一本關係數據庫理論的書去看吧，說不定。對各位大有幫助。說是說以上是基礎理論的東西，請你們想一想，你在作數據庫設計的時候有沒有考慮過遵過以上幾個範式呢，有沒有在數據庫設計作得很差之時，想想。對照以上所講，到底是違反了第幾個範式呢？
我見過的數據庫設計，很是少有人作到很是符合以上幾個範式的，通常說來。第一範式你們都可以遵照。全然遵照第二第三範式的人很是少了，遵照的人必定就是設計數據庫的高手了。BCNF的範式出現機會較少，而且會破壞完整性，你可以在作設計之時不考慮它，固然在ORACLE中可經過觸發器解決其缺點。之後咱們共同作設計之時，也但願你們遵照以上幾個範式。
那些數據庫的書介紹的數據庫範式，實在是晦澀難懂，我在這裏給出一個通俗的描寫敘述：
1NF：一個table中的列是不可再分的（即列的原子性）
2NF：一個table中的行是可以惟一標示的，（即table中的行是不可以有反覆的）
3NF：一個table中列不依賴以還有一個table中的非主鍵的列，仍是不通俗！
巨寒！
。
舉個樣例吧：有一個部門的table，咱們叫它tbl_department,它有這麼幾列（dept_id(pk),dept_name,dept_memo...）有一個員工table。咱們叫它tbl_employee,在這個table中有一列dept_id(fk)描寫敘述關於部門的信息，若tbl_employee要知足3NF，則在tbl_employee中就不得再有除dept_id列的其餘有關部門信息的列！
通常數據庫的設計知足3NF就能夠！（我的認爲應該儘量的知足3NF。一家之言^_^）
BCNF：一般以爲BCNF是修正的第三範式。它比3NF又進一步。
4NF：
5NF：將一個table儘量的切割成小的塊，以排除在table中所有冗餘的數據
==============================
解釋1道數據庫規範化/範式的例題?
比方解釋例題:有屬性SNO(學生號),SNAM(學生姓名),DON(系) MAN(系主任),舍關係R的主鍵爲SNO,則R爲1NF\2NF\3NF?
答案是2NF
爲何?
學號是主屬性,姓名可以直接被學號給肯定,學號可以肯定學生所在的系,而系主任不是由主屬性學號來肯定的,是由系名來肯定的,因此問題就在系主任上,在這個關係裏學號和系主任之間不是直接肯定的而是間接肯定的,這就叫非主屬性對主屬性存在傳遞函數依賴,因此是2範式,1範式是把兩個或幾個事在一個關係裏說,這個就是略微好點,可以依據主碼肯定一個非主屬性,仍是間接的,因此是第2範式.
因爲僅僅要知道姓名就可以查到系。查到班主任，因此姓名並不是僅僅和學生號產生關係。
這是不符合第三範式的。
你去細緻研讀一下第三範式的定義就行想通了
事實上這樣的現象就被稱爲冗餘，而且屬於複式冗餘。因爲班主任甚至還和繫有關係。
因爲僅僅要知道姓名就可以查到系，查到班主任，因此姓名並不是僅僅和學生號產生關係。
這是不符合第三範式的。你去細緻研讀一下第三範式的定義就行想通了
事實上這樣的現象就被稱爲冗餘，而且屬於複式冗餘。因爲班主任甚至還和繫有關係。
============================
數據庫的規範化,1\2\3範式怎麼理解?
所謂1NF,2NF,3NF,各舉例說明下吧,讓我能理解....
1NF:字段具備原子性。不可再分；
比方說籍貫這個字段，裏面是「湖北武漢」的話。它就違反了原子性，因爲湖北武漢還可以再分的更詳細，分爲「湖北」和「武漢」
2NF:組合keyword的表。不存在組合keyword中的隨意字段決定其餘非keyword段的情部（也就是說不能有兩個組合鍵組成一個主鍵）
3NF:在2NF的基礎上。數據表中假設不存在非keyword段對任一候選字段的傳遞函數依賴則符合第三範式（也就是說違反了數據冗餘）
賬號身份證號姓名password
1001 410101001 李梅 100001
身份證號和姓名共同決定了password，姓名是依賴於身份證號的，這樣就違反了第三範式
典型的網絡結構莫過於MVC結構了，即視圖層-模型層-控制層。視圖層負責展現頁面。就是平時咱們上網看到的頁面。控制層負責邏輯控制，就是控制咱們點擊一個連接或點擊一個button以後，頁面要運行什麼操做、怎麼跳轉。業務層就是你所要運行的操做，比方說增、刪、改、查詢數據，這些操做都是由業務層來完畢的。
一個好的網絡結構通常業務層分爲業務層、VO層和數據持久層，業務層負責完畢邏輯操做，VO層負責存儲數據對象，數據持久層負責數據庫操做。因此，頁面的數據要通過視圖層——〉控制層——〉模型層——〉VO層——〉數據持久層——〉數據庫，這樣一個流程，數據是一層一層的傳遞的。不該該跨層操做。
PS：我所說的是一個典型的站點結構，實際上不論什麼一層都可以對數據庫進行操做，但是不建議這樣作。因爲這樣作會使層次模糊。不便於模糊與操做
}
3一、 表與表之間的關聯關係答：分爲3種：一對1、一對多、多對多。
3二、 主鍵和外鍵的差異答：主鍵在本表中是惟一的、不可惟空的，外鍵可以反覆可以惟空。外鍵和還有一張表的主鍵關聯，不能建立相應表中不存在的外鍵。
33.C++或Java中的異常處理機制的簡單原理和應用。當JAVA程序違反了JAVA的語義規則時。JAVA虛擬機就會將發生的錯誤表示爲一個異常。違反語義規則包含2種狀況。一種是JAVA類庫內置的語義檢查。好比數組下標越界,會引起IndexOutOfBoundsException;訪問null的對象時會引起NullPointerException。還有一種狀況就是JAVA贊成程序猿擴展這樣的語義檢查，程序猿可以建立本身的異常，並自由選擇在什麼時候用throwkeyword引起異常。所有的異常都是java.lang.Thowable的子類。
34. Java的接口和C++的虛類的一樣和不一樣處。因爲Java不支持多繼承。而有可能某個類或對象要使用分別在幾個類或對象裏面的方法或屬性，現有的單繼承機制就不能知足要求。與繼承相比，接口有更高的靈活性，因爲接口中沒有不論什麼實現代碼。
當一個類實現了接口之後，該類要實現接口裏面所有的方法和屬性。並且接口裏面的屬性在默認狀態如下都是public static,所有方法默認狀況下是public.一個類可以實現多個接口。
35. 垃圾回收的長處和原理。並考慮2種回收機制。Java語言中一個顯著的特色就是引入了垃圾回收機制，使c++程序猿最頭疼的內存管理的問題迎刃而解。它使得Java程序猿在編敲代碼的時候再也不需要考慮內存管理。由於有個垃圾回收機制，Java中的對象再也不有「做用域」的概念，僅僅有對象的引用纔有「做用域」。垃圾回收可以有效的防止內存泄露，有效的使用可以使用的內存。
垃圾回收器通常是做爲一個單獨的低級別的線程執行。不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收。程序猿不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。
回收機制有分代複製垃圾回收和標記垃圾回收，增量垃圾回收。
36. 請說出你所知道的線程同步的方法。wait():使一個線程處於等待狀態，並且釋放所持有的對象的lock。
sleep():使一個正在執行的線程處於睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException異常。
notify():喚醒一個處於等待狀態的線程。注意的是在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM肯定喚醒哪一個線程。而且不是按優先級。Allnotity():喚醒所有處入等待狀態的線程。注意並不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。
37. Error與Exception有什麼差異？Error表示系統級的錯誤和程序沒必要處理的異常，Exception表示需要捕捉或者需要程序進行處理的異常。
38. 在java中一個類被聲明爲final類型，表示了什麼意思？
表示該類不能被繼承，是頂級類。
39. heap和stack有什麼差異。棧是一種線形集合，其加入和刪除元素的操做應在同一段完畢。棧依照後進先出的方式進行處理。堆是棧的一個組成元素
40．寫一個方法，實現字符串的反轉，如：輸入abc。輸出cba
public static Stringreverse(String s){int length=s.length();StringBuffer result=newStringBuffer(length);for(inti=length-1;i>=0;i--)result.append(s.charAt(i));return result.toString();}
41. 數據類型之間的轉換 怎樣將數值型字符轉換爲數字（Integer，Double） 怎樣將數字轉換爲字符 怎樣去小數點前兩位，並四捨五入。
42. 日期和時間 怎樣取得年月日，小時分秒Date dat=newDate();dat.getYear();dat.getMonth();dat.getDay();dat.getHours();...
怎樣取得從1970年到現在的毫秒數long now=dat.getTime();怎樣獲取某個日期是當月的最後一天怎樣格式化日期
DateFormatedf=DateFormate.getInstance();df.Format(dat);
43. 文件和文件夾（I/O）操做 怎樣列出某個文件夾下的所有文件 怎樣列出某個文件夾下的所有子文件夾 推斷一個文件或文件夾是否存在 怎樣讀寫文件
44. Java中訪問數據庫的步驟。Statement和PreparedStatement之間的差異。PreparedStatement對象與Statement對象的不一樣點在於它的SQL語句是預編譯過的，並且可以有佔位符使用執行時參數。
{
關於PreparedStatement和Statement詳細差異
1：
咱們先從這兩個單詞進行初步的解說，Prepared（準備好的, 精製的）。從這裏可以知道PreparedStatement是預先編譯的語句。而Statement則不是預先編譯的，在DBMS中處理管理中Statement是要進行語法、語義的，而PreparedStatement則不要。
2：
PrepareStatement中運行的SQL語句中是可以帶參數的，而Statement則不可以。
比方：
PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES
SET SALARY = ? WHERE ID = ?
");
pstmt.setBigDecimal(1, 153833.00);
pstmt.setInt(2, 110592);
pstmt. executeUpdate();
3：
當處理批量SQL語句時，這個時候就可以體現PrepareStatement的優點。由於採用Cache機制。則預先編譯的語句，就會放在Cache中，下次運行一樣SQL語句時，則可以直接從Cache中取出來
假設是JDBC的話，會比較煩瑣，代碼例如如下(注意凝視)：
Class.forName("com.mysql.jdbc.Driver"); // 先註冊驅動
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost/mysql?characterEncoding=UTF8", "root", ""); // 取到鏈接
stmt = conn.createStatement(); // 準備語句
rs = stmt.executeQuery("SELECT * FROM " + args[0] + " WHERE 1 = 0"); // 運行語句
} finally { // 釋放資源
try {
rs.close();
} catch (Exception e) {
}
try {
stmt.close();
} catch (Exception e) {
}
try {
conn.close();
} catch (Exception e) {
}
}
你最好是用框架訪問DB，如Spring的JDBCTemplate等，那樣要省事很是多
Statement是直接運行的語氣，也就是SQL語句裏面沒有問號的。
PreparedStatement是帶問號的SQL語句
比方
select * from student where id = 1
select * from student where id = 2
statement直接運行兩句。prepared則要先prepare：select * from student where id = ?。而後分別傳1和2給prepared好的句柄。顯而後者要比前者高效很是多
}
45.在Web開發中需要處理HTML標記時，應作什麼樣的處理，要篩選那些字符（<> & 「」）
5. 列出Jsp中包括外部文件的方式。二者有何差異。
假設include2.html的內容變化了。那麼使用包括指令方式瀏覽器請求jsp頁面顯示的仍是曾經的內容，但是使用包括動做方式。瀏覽器請求jsp頁面顯示的就是新的內容。
7. 介紹在Jsp中怎樣使用JavaBeans。 一、使用動做元素 <use bean> 二、在腳本中調用JavaBeans
9.Jsp和Servlet中的請求轉派發分別怎樣實現。 Jsp實現轉派發一、在java腳本代碼中使用response.sendRedirect("favorite.jsp") 實現轉派發二、JSP標準動做： <jsp:forward> 好比： <jsp:forward page=」forward2.jsp」 />
Servlet實現轉派發一、代碼、response.sendRedirect(「/abc.html」);遇到該行代碼。會轉到abc.html頁面。二、ServletContext的getRequestDispatcher(Stringpath)方法 返回 與path相聯繫的RequestDispatcher對象
RequestDispatcher對象 調用 forward(ServletRequest request, ServletResponseresponse) 轉向 path
Html實現轉派發 一、使用"history.back()" 好比：<input type="button" name="Submit2"value="返回"onClick="history.back();">
二、使用"javascript:history.go(-1);" 好比：<a href="javascript:history.go(-1);">返回！
</a> 三、使用 href 超連接 實現轉派發 好比：<ahref="forward2.jsp">返回。</a> 四、使用 form 表單提交 實現轉派發五、使用 meta 好比：<meta http-equiv=refreshcontent='<%=aForwardInfo.getSecond()%>;url=<%=aForwardInfo.getUrl()%>'>
3. 簡介所瞭解的XML。
xml 可擴展標記語言 ； 是一種存儲數據標準格式，應用於數據交換、web服務、web集成、系統配置、可穿透防火牆。
8. 簡介JSP的標記庫JSTL
標籤庫（Taglibraries）提供了創建可重用代碼塊的簡單方式。但是和COM和J2EE不一樣的是。你不需要掌握不論什麼額外的技能就可以創建標籤庫：假設你會編寫JSP頁面。你就會創建標籤庫。最後，標籤庫還改進了Web應用程序的維護性。
這樣的對維護性的改進表現在：輕易地在JSP頁面上就實現了基於XML的可定製接口。
結果可想而知，Web設計人員可以創建JSP Web應用程序而無需知道JSP是怎麼回事。這樣一來。Web開發就成爲一項很富有效率的團隊開發任務了。JSP程序猿可以創建定製的標籤和後端代碼模塊，而Web設計人員則可以使用定製標籤而且全力關注於Web設計自己。標籤庫攻克了代碼混亂的問題，而且作得乾淨美麗（其實，XML纔是解決這些問題的本質所在，但是標籤庫仍是起到了至關關鍵的做用）。
46. 描寫敘述Cookie和Session的做用。差異和各自的應用範圍，Session工做原理。
Cookie是在client開闢的一塊可長期存儲用戶信息的地方。
{
詳細來講cookie機制採用的是在client保持狀態的方案，而session機制採用的是在server端保持狀態的方案。
同一時候咱們也看到，由於採用server端保持狀態的方案在client也需要保存一個標識，因此session機制可能需要藉助於cookie機制來達到保存標識的目的，但實際上它還有其它選擇。
cookie機制。
正統的cookie分發是經過擴展HTTP協議來實現的，server經過在HTTP的響應頭中加上一行特殊的指示以提示瀏覽器依照指示生成對應的cookie。然而純粹的client腳本如JavaScript或者VBScript也可以生成cookie。而cookie的使用是由瀏覽器依照必定的原則在後臺本身主動發送給server的。
瀏覽器檢查所有存儲的cookie。假設某個cookie所聲明的做用範圍大於等於將要請求的資源所在的位置，則把該cookie附在請求資源的HTTP請求頭上發送給server。
cookie的內容主要包含：名字，值。過時時間。路徑和域。路徑與域一塊兒構成cookie的做用範圍。若不設置過時時間，則表示這個cookie的生命期爲瀏覽器會話期間，關閉瀏覽器窗體。cookie就消失。這樣的生命期爲瀏覽器會話期的cookie被稱爲會話cookie。
會話cookie通常不存儲在硬盤上而是保存在內存裏，固然這樣的行爲並不是規範規定的。若設置了過時時間，瀏覽器就會把cookie保存到硬盤上。關閉後再次打開瀏覽器，這些cookie仍然有效直到超過設定的過時時間。存儲在硬盤上的cookie可以在不一樣的瀏覽器進程間共享，比方兩個IE窗體。而對於保存在內存裏的cookie。不一樣的瀏覽器有不一樣的處理方式
session機制。session機制是一種server端的機制。server使用一種相似於散列表的結構（也可能就是使用散列表）來保存信息。
當程序需要爲某個client的請求建立一個session時。server首先檢查這個client的請求裏是否已包括了一個session標識（稱爲session id），假設已包括則說明曾經已經爲此client建立過session。server就依照session id把這個session檢索出來使用（檢索不到。會新建一個），假設client請求不包括session id。則爲此client建立一個session並且生成一個與此session相關聯的session id。session id的值應該是一個既不會反覆，又不easy被找到規律以仿造的字符串，這個sessionid將被在本次響應中返回給client保存。
保存這個session id的方式可以採用cookie，這樣在交互過程當中瀏覽器可以本身主動的依照規則把這個標識發揮給server。
通常這個cookie的名字都是相似於SEEESIONID。但cookie可以被人爲的禁止，則必須有其它機制以便在cookie被禁止時仍然可以把session id傳遞迴server。
經常被使用的一種技術叫作URL重寫。就是把session id直接附加在URL路徑的後面。
另外一種技術叫作表單隱藏字段。就是server會本身主動改動表單，加入一個隱藏字段，以便在表單提交時能夠把sessionid傳遞迴server。比方：
<form name="testform" action="/xxx">
<input type="hidden" name="jsessionid"value="ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764">
<input type="text">
</form>
實際上這樣的技術可以簡單的用對action應用URL重寫來取代。
}
Session是在server內存中開闢的一塊存儲用戶信息的地方；當客戶第一次訪問server時。server在內存建立相應的Session給訪問客戶，當客戶離開或時間過時時；server本身主動銷燬Session；Session是由容器管理的。
47444447
描寫敘述一下你最常用的編程風格。
47.(1) 類名首字母應該大寫。字段、方法以及對象（句柄）的首字母應小寫。對於所有標識符。當中包括的所有單詞都應緊靠在一塊兒。而且大寫中間單詞的首字母。Java包（Package）屬於一種特殊狀況：它們全都是小寫字母。即使中間的單詞亦是如此。對於域名擴展名稱，如com。org，net或者edu等，所有都應小寫（這也是Java 1.1和Java 1.2的差異之中的一個）。(2) 爲了常規用途而建立一個類時，請採取「經典形式」。幷包括對下述元素的定義：equals()hashCode()toString()clone()（implement Cloneable）implementSerializable(3) 對於本身建立的每一個類，都考慮置入一個main()，當中包括了用於測試那個類的代碼。爲使用一個項目中的類。咱們不是必需刪除測試代碼。若進行了不論什麼形式的修改，可方便地返回測試。這些代碼也可做爲怎樣使用類的一個演示樣例使用。
(4)應將方法設計成簡要的、功能性單元，用它描寫敘述和實現一個不連續的類接口部分。理想狀況下。方法應簡明扼要。若長度很大，可考慮經過某種方式將其切割成較短的幾個方法。這樣作也便於類內代碼的反覆使用（有些時候，方法必須很大，但它們仍應僅僅作相同的一件事情）。
(5)設計一個類時，請設身處地爲客戶程序猿考慮一下（類的用法應該是很明白的）。
而後，再設身處地爲管理代碼的人考慮一下（估計有可能進行哪些形式的修改，想一想用什麼方法可把它們變得更簡單）。(6)使類儘量短小精悍，而且僅僅解決一個特定的問題。如下是對類設計的一些建議：■一個複雜的開關語句：考慮採用「多形」機制■數量衆多的方法涉及到類型區別極大的操做：考慮用幾個類來分別實現
■不少成員變量在特徵上有很是大的區別：考慮使用幾個類(7) 讓一切東西都儘量地「私有」——private。可以使庫的某一部分「公共化」（一個方法、類或者一個字段等等），就永遠不能把它拿出。
若強行拿出，就可能破壞其它人現有的代碼，使他們不得不又一次編寫和設計。若僅僅發佈本身必須發佈的，就可放心大膽地改變其它不論什麼東西。在多線程環境中，隱私是特別重要的一個因素——僅僅有private字段才幹在非同步使用的狀況下受到保護。
(8) 謹惕「巨大對象綜合症」。對一些習慣於順序編程思惟、且初涉OOP領域的新手。每每喜歡先寫一個順序運行的程序，再把它嵌入一個或兩個巨大的對象裏。
依據編程原理，對象表達的應該是應用程序的概念，而非應用程序自己。(9)若不得已進行一些不太雅觀的編程，至少應該把那些代碼置於一個類的內部。
(10) 不論何時僅僅要發現類與類之間結合得很是緊密。就需要考慮是否採用內部類，從而改善編碼及維護工做（參見第14章14.1.2小節的「用內部類改進代碼」）。(11) 儘量仔細地加上凝視，並用javadoc凝視文檔語法生成本身的程序文檔。(12) 避免使用「魔術數字」，這些數字很是難與代碼很是好地配合。如之後需要改動它，無疑會成爲一場噩夢，因爲根本不知道「100」到底是指「數組大小」仍是「其它徹底不一樣的東西」。
因此，咱們應建立一個常數，併爲其使用具備說服力的描寫敘述性名稱，並在整個程序中都採用常數標識符。
這樣可以使程序更易理解以及更易維護。(13)涉及構建器和異常的時候，一般但願又一次丟棄在構建器中捕獲的不論什麼異常——假設它形成了那個對象的建立失敗。
這樣一來，調用者就不會覺得那個對象已正確地建立。從而盲目地繼續。(14)當客戶程序猿用完對象之後，若你的類要求進行不論什麼清除工做，可考慮將清除代碼置於一個良好定義的方法裏，採用相似於cleanup()這種名字。明白代表本身的用途。除此之外，可在類內放置一個boolean（布爾）標記，指出對象是否已被清除。在類的finalize()方法裏，請肯定對象已被清除。並已丟棄了從RuntimeException繼承的一個類（假設尚未的話），從而指出一個編程錯誤。
在採取象這種方案以前，請肯定finalize()能夠在本身的系統中工做（可能需要調用System.runFinalizersOnExit(true)，從而確保這一行爲）。
(15) 在一個特定的做用域內，若一個對象必須清除（非由垃圾收集機制處理），請採用下述方法：初始化對象。若成功，則立刻進入一個含有finally從句的try塊，開始清除工做。(16) 若在初始化過程當中需要覆蓋（取消）finalize()，請記住調用super.finalize()（若Object屬於咱們的直接超類。則無此必要）。
在對finalize()進行覆蓋的過程當中，對super.finalize()的調用應屬於最後一個行動，而不該是第一個行動，這樣可確保在需要基礎類組件的時候它們依舊有效。
(17) 建立大小固定的對象集合時，請將它們傳輸至一個數組（若準備從一個方法裏返回這個集合。更應如此操做）。
這樣一來，咱們就可享受到數組在編譯期進行類型檢查的優勢。此外，爲使用它們，數組的接收者或許並不需要將對象「造型」到數組裏。
(18) 儘可能使用interfaces，不要使用abstract類。
若已知某樣東西準備成爲一個基礎類。那麼第一個選擇應是將其變成一個interface（接口）。
僅僅有在不得不用法定義或者成員變量的時候。才需要將其變成一個abstract（抽象）類。接口主要描寫敘述了客戶但願作什麼事情，而一個類則致力於（或贊成）具體的實施細節。
(19)在構建器內部，僅僅進行那些將對象設爲正確狀態所需的工做。
儘量地避免調用其它方法，因爲那些方法可能被其它人覆蓋或取消。從而在構建過程當中產生不可預知的結果（參見第7章的具體說明）。
(20) 對象不該僅僅是簡單地容納一些數據；它們的行爲也應獲得良好的定義。
(21)在現成類的基礎上建立新類時。請首先選擇「新建」或「創做」。
僅僅有本身的設計要求必須繼承時，才應考慮這方面的問題。若在原本贊成新建的場合使用了繼承，則整個設計會變得沒有必要地複雜。(22)用繼承及方法覆蓋來表示行爲間的差別，而用字段表示狀態間的差異。一個很極端的樣例是經過對不一樣類的繼承來表示顏色。這是絕相應該避免的：應直接使用一個「顏色」字段。(23) 爲避免編程時遇到麻煩。請保證在本身類路徑指到的不論什麼地方，每一個名字都僅相應一個類。不然，編譯器可能先找到同名的還有一個類，並報告出錯消息。若懷疑本身碰到了類路徑問題，請試試在類路徑的每一個起點。搜索一下同名的.class文件。
(24) 在Java 1.1 AWT中使用事件「適配器」時。特別easy碰到一個陷阱。若覆蓋了某個適配器方法，同一時候拼寫方法沒有特別講究，最後的結果就是新加入一個方法。而不是覆蓋現成方法。然而，由於這樣作是全然合法的。因此不會從編譯器或執行期系統得到不論什麼出錯提示——僅僅只是代碼的工做就變得不正常了。
(25) 用合理的設計方案消除「僞功能」。
也就是說。倘若僅僅需要建立類的一個對象，就不要提早限制本身使用應用程序，並加上一條「僅僅生成當中一個」凝視。請考慮將其封裝成一個「獨生子」的形式。若在主程序裏有大量散亂的代碼。用於建立本身的對象，請考慮採納一種創造性的方案，將些代碼封裝起來。(26)警戒「分析癱瘓」。請記住。無論怎樣都要提早了解整個項目的情況，再去考察當中的細節。由於把握了全局。可高速認識本身未知的一些因素，防止在考察細節的時候陷入「死邏輯」中。
(27) 警戒「過早優化」。
首先讓它執行起來，再考慮變得更快——但僅僅有在本身必須這樣作、而且經證明在某部分代碼中的確存在一個性能瓶頸的時候，才應進行優化。除非用專門的工具分析瓶頸，不然很是有多是在浪費本身的時間。性能提高的隱含代價是本身的代碼變得難於理解。而且難於維護。
(28)請記住。閱讀代碼的時間比寫代碼的時間多得多。
思路清晰的設計可得到易於理解的程序，但凝視、仔細的解釋以及一些演示樣例每每具備不可估量的價值。
無論對你本身。仍是對後來的人。它們都是至關重要的。如對此仍有懷疑，那麼請試想本身試圖從聯機Java文檔裏找出實用信息時碰到的挫折，這樣也許能將你說服。
48. 假設系統要使用超大整數（超過long長度範圍），請你設計一個數據結構來存儲這樣的超大型數字以及設計一種算法來實現超大整數加法運算）。public class BigInt(){int[] ArrOne = new ArrOne[1000];String intString="";public int[] Arr(String s){intString = s;for(int i=0;i<ArrOne.leght;i++){
{
假設系統要使用超大整數（超過long長度範圍）。請你設計一個數據結構來存儲這樣的超大型數字以及設計一種算法來實現超大整數加法運算）
博客分類：
/**
* 超大整數相加：
* 題目要求：假設系統要使用超大整數（超過long的範圍）。請你設計一個數據結構來存儲這樣的
* 超大型數字以及設計一種算法來實現超大整數的加法運算
* @author Administrator
*
*/
public class VeryBigNumAdd {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
String a="1223232";
for(int i=a.length()-1;i>=0;i--)
{
System.out.print(a.charAt(i));
}
*/
VeryBigNumAdd vbn=new VeryBigNumAdd();
Stringa="123453243455535634535252345234677576252241234123523453664563634";
String b="123453243455535634535252345234677576252241234123523453664563634";
String result=vbn.doAdd(a,b);
System.out.println("result:"+result);
}
/**
*
* @param a 加數字符串1
* @param b 加數字符串2
* @return 結果字符串
* 分析：
* 一、取得兩個字符串的長度
* 二、把兩個的長度作比較。並得出較長的長度，及較短的長度
* 三、把長度較短的加數字符串，在左面補0，使之與較長的字符串同樣長
* 四、從最高位，一個個數的取出來相加，固然首先得轉換爲整型
* 五、設置進位，假設兩個數相加及加上進位大於等於10，並且這不是最左邊一個字符相加，相加結果等於
* （取出1＋取出2＋進位）－10，並把進位設爲1；假設沒有大於10。就把進位設爲0，如些循環。把
* 相加的結果以字符串的形式結合起來，就獲得最後的結果
*/
String doAdd(String a,String b)
{
String str="";
int lenA=a.length();
int lenB=b.length();
int maxLen=(lenA>lenB) ?
lenA : lenB;
int minLen=(lenA<lenB) ?
lenA : lenB;
String strTmp="";
for(int i=maxLen-minLen;i>0;i--)
{
strTmp+="0";
}
//把長度調整到一樣
if(maxLen==lenA)
{
b=strTmp+b;
}else
a=strTmp+a;
int JW=0;//進位
for(int i=maxLen-1;i>=0;i--)
{
int tempA=Integer.parseInt(String.valueOf(a.charAt(i)));
int tempB=Integer.parseInt(String.valueOf(b.charAt(i)));
int temp;
if(tempA+tempB+JW>=10 && i!=0)
{
temp=tempA+tempB+JW-10;
JW=1;
}
else
{
temp=tempA+tempB+JW;
JW=0;
}
str=String.valueOf(temp)+str;
}
return str;
}
}
/**
* 超大整數相加：
* 題目要求：假設系統要使用超大整數（超過long的範圍），請你設計一個數據結構來存儲這樣的
* 超大型數字以及設計一種算法來實現超大整數的加法運算
* @author Administrator
*
*/
public class VeryBigNumAdd {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
String a="1223232";
for(int i=a.length()-1;i>=0;i--)
{
System.out.print(a.charAt(i));
}
*/
VeryBigNumAdd vbn=new VeryBigNumAdd();
String a="123453243455535634535252345234677576252241234123523453664563634";
Stringb="123453243455535634535252345234677576252241234123523453664563634";
String result=vbn.doAdd(a,b);
System.out.println("result:"+result);
}
/**
*
* @param a 加數字符串1
* @param b 加數字符串2
* @return 結果字符串
* 分析：
* 一、取得兩個字符串的長度
* 二、把兩個的長度作比較，並得出較長的長度，及較短的長度
* 三、把長度較短的加數字符串，在左面補0。使之與較長的字符串同樣長
* 四、從最高位，一個個數的取出來相加。固然首先得轉換爲整型
* 五、設置進位，假設兩個數相加及加上進位大於等於10。並且這不是最左邊一個字符相加，相加結果等於
* （取出1＋取出2＋進位）－10，並把進位設爲1；假設沒有大於10，就把進位設爲0，如些循環，把
* 相加的結果以字符串的形式結合起來，就獲得最後的結果
*/
String doAdd(String a,String b)
{
String str="";
int lenA=a.length();
int lenB=b.length();
int maxLen=(lenA>lenB) ?
lenA : lenB;
int minLen=(lenA<lenB) ? lenA : lenB;
String strTmp="";
for(int i=maxLen-minLen;i>0;i--)
{
strTmp+="0";
}
//把長度調整到一樣
if(maxLen==lenA)
{
b=strTmp+b;
}else
a=strTmp+a;
int JW=0;//進位
for(int i=maxLen-1;i>=0;i--)
{
int tempA=Integer.parseInt(String.valueOf(a.charAt(i)));
int tempB=Integer.parseInt(String.valueOf(b.charAt(i)));
int temp;
if(tempA+tempB+JW>=10 && i!=0)
{
temp=tempA+tempB+JW-10;
JW=1;
}
else
{
temp=tempA+tempB+JW;
JW=0;
}
str=String.valueOf(temp)+str;
}
return str;
}
}
}
49，談談final, finally, finalize的差異。final—修飾符（keyword）假設一個類被聲明爲final。意味着它不能再派生出新的子類，不能做爲父類被繼承。所以一個類不能既被聲明爲 abstract的，又被聲明爲final的。將變量或方法聲明爲final，可以保證它們在使用中不被改變。被聲明爲final的變量必須在聲明時給定初值，而在之後的引用中僅僅能讀取，不可改動。被聲明爲final的方法也相同僅僅能使用。不能重載。 finally—再異常處理時提供 finally 塊來運行不論什麼清除操做。假設拋出一個異常，那麼相匹配的 catch 子句就會運行。而後控制就會進入 finally 塊（假設有的話）。
finalize—方法名。Java 技術贊成使用 finalize() 方法在垃圾收集器將對象從內存中清除出去以前作必要的清理工做。這種方法是由垃圾收集器在肯定這個對象沒有被引用時對這個對象調用的。它是在 Object 類中定義的，所以所有的類都繼承了它。子類覆蓋 finalize() 方法以整理系統資源或者運行其它清理工做。finalize() 方法是在垃圾收集器刪除對象以前對這個對象調用的。
50，Anonymous Inner Class (匿名內部類) 可否夠extends(繼承)其餘類。可否夠implements(實現)interface(接口)?
匿名的內部類是沒有名字的內部類。不能extends(繼承) 其餘類，但一個內部類可以做爲一個接口，由還有一個內部類實現。
51，Static Nested Class 和 Inner Class的不一樣，說得越多越好(面試題有的很是籠統)Nested Class （一般是C++的說法），Inner Class (一般是JAVA的說法)。Java內部類與C++嵌套類最大的不一樣就在因而否有指向外部的引用上。詳細可見http: //www.frontfree.net/articles/services/view.asp?id=704&page=1 注： 靜態內部類（Inner Class）意味着1建立一個static內部類的對象。不需要一個外部類對象。2不能從一個static內部類的一個對象訪問一個外部類對象
52。何時用assert。斷言是一個包括布爾表達式的語句，在運行這個語句時假定該表達式爲 true。假設表達式計算爲 false。那麼系統會報告一個 Assertionerror。它用於調試目的：assert(a > 0); // throws an Assertionerror if a <= 0 斷言可以有兩種形式：
assert Expression1 ; assert Expression1 : Expression2 ; Expression1 應該老是產生一個布爾值。
Expression2 可以是得出一個值的隨意表達式。這個值用於生成顯示不少其它調試信息的 String 消息。
斷言在默認狀況下是禁用的。要在編譯時啓用斷言，需要使用 source 1.4 標記：javac -source 1.4 Test.java 要在執行時啓用斷言，可以使用 -enableassertions 或者 -ea 標記。要在執行時選擇禁用斷言，可以使用 -da 或者 -disableassertions 標記。
要系統類中啓用斷言，可以使用 -esa 或者 -dsa 標記。
還可以在包的基礎上啓用或者禁用斷言。 可以在估計正常狀況下不會到達的不論什麼位置上放置斷言。
斷言可以用於驗證傳遞給私有方法的參數。只是。斷言不該該用於驗證傳遞給公有方法的參數。因爲不管是否啓用了斷言，公有方法都必須檢查其參數。
只是。既可以在公有方法中，也可以在非公有方法中利用斷言測試後置條件。
另外。斷言不該該以不論什麼方式改變程序的狀態。
53，GC是什麼? 爲何要有GC? (基礎)。GC是垃圾收集器。Java 程序猿不用操心內存管理，因爲垃圾收集器會本身主動進行管理。
要請求垃圾收集，可以調用如下的方法之中的一個：System.gc() Runtime.getRuntime().gc()
54。String s = new String("xyz");建立了幾個String Object? 兩個對象，一個是「xyx」,一個是指向「xyx」的引用對象s。
55，Math.round(11.5)等於多少? Math.round(-11.5)等於多少? Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;
56。short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯? short s1 = 1; s1 = s1 + 1;有錯，s1是short型，s1+1是int型,不能顯式轉化爲short型。可改動爲s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正確。
57，sleep() 和 wait() 有什麼差異? 搞線程的最愛
sleep()方法是使線程中止一段時間的方法。在sleep 時間間隔期滿後。線程不必定立刻恢復運行。這是因爲在那個時刻，其餘線程可能正在運行而且沒有被調度爲放棄運行，除非(a)「醒來」的線程具備更高的優先級 (b)正在運行的線程因爲其餘緣由而堵塞。
wait()是線程交互時，假設線程對一個同步對象x 發出一個wait()調用，該線程會暫停運行。被調對象進入等待狀態。直到被喚醒或等待時間到。
58。Overload和Override的差異。Overloaded的方法可否夠改變返回值的類型?
方法的重寫Overriding和重載Overloading是Java多態性的不一樣表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。假設在子類中定義某方法與其父類有一樣的名稱和參數，咱們說該方法被重寫 (Overriding)。子類的對象使用這種方法時，將調用子類中的定義。對它而言，父類中的定義如同被「屏蔽」了。假設在一個類中定義了多個同名的方法，它們或有不一樣的參數個數或有不一樣的參數類型，則稱爲方法的重載(Overloading)。
Overloaded的方法是可以改變返回值的類型。
59，Set裏的元素是不能反覆的，那麼用什麼方法來區分反覆與否呢?是用==仍是equals()?
它們有何差異? Set裏的元素是不能反覆的，那麼用iterator()方法來區分反覆與否。equals()是判讀兩個Set是否相等。equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，爲的是當兩個分離的對象的內容和類型相配的話，返回真值。
60。abstract class和interface有什麼差異?聲明方法的存在而不去實現它的類被叫作抽象類（abstract class），它用於要建立一個體現某些基本行爲的類。併爲該類聲明方法，但不能在該類中實現該類的狀況。
不能建立abstract 類的實例。然而可以建立一個變量。其類型是一個抽象類。並讓它指向詳細子類的一個實例。不能有抽象構造函數或抽象靜態方法。
Abstract 類的子類爲它們父類中的所有抽象方法提供實現，不然它們也是抽象類爲。取而代之。在子類中實現該方法。知道其行爲的其餘類可以在類中實現這些方法。
接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可經過實現這種接口而得到。
接口中的所有方法都是抽象的，沒有一個有程序體。接口僅僅可以定義static final成員變量。接口的實現與子類類似。除了該實現類不能從接口定義中繼承行爲。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。而後，它可以在實現了該接口的類的不論什麼對象上調用接口的方法。由於有抽象類，它贊成使用接口名做爲引用變量的類型。
一般的動態聯編將生效。引用可以轉換到接口類型或從接口類型轉換。instanceof 運算符可以用來決定某對象的類是否實現了接口。
61，abstract的method是否可同一時候是static,是否可同一時候是native。是否可同一時候是synchronized? 都不能
62。啓動一個線程是用run()仍是start()? 啓動一個線程是調用start()方法。使線程所表明的虛擬處理機處於可執行狀態，這意味着它可以由JVM調度並執行。這並不意味着線程就會立刻執行。
run()方法可以產生必須退出的標誌來中止一個線程。
63，構造器Constructor是否可被override?構造器Constructor不能被繼承，所以不能重寫Overriding。但可以被重載Overloading。
64，當一個線程進入一個對象的一個synchronized方法後。其餘線程是否可進入此對象的其餘方法?
不能，一個對象的一個synchronized方法僅僅能由一個線程訪問。
65。try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被運行。何時被運行。在return前仍是後? 會運行，在return前運行。
38，編程題: 用最有效率的方法算出2乘以8等於幾? 有C背景的程序猿特別喜歡問這樣的問題。 2 << 3
66。兩個對象值一樣(x.equals(y) == true)，但卻可有不一樣的hash code，這句話對不正確?
不正確，有一樣的hash code。
67，當一個對象被看成參數傳遞到一個方法後，此方法可改變這個對象的屬性。並可返回變化後的結果，那麼這裏到底是值傳遞仍是引用傳遞? 是值傳遞。Java 編程語言僅僅由值傳遞參數。當一個對象實例做爲一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變。但對象的引用是永遠不會改變的。
68。swtich可否做用在byte上。可否做用在long上。可否做用在String上?
switch（expr1）中，expr1是一個整數表達式。所以傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte。long,string 都不能做用於swtich。
6九、在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>
70、列出某目錄下的所有文件。
{
public class FileFiterOperation {
public static voidmain(String[] args) {
File f=newFile("D:"+File.separatorChar+"java");
Filefs[]=f.listFiles(new Filters());
for (File file :fs) {
System.err.println(file.getName());
}
}
static classFilters implements FileFilter{
public booleanaccept(File fc) {
//推斷fs是否爲文件
if(fc.isFile())return true;
return false;
}
}
}
這個不包含子文件夾下的文件。。。
假設要包括子文件夾下的文件，可以改成遞歸方式。
}
7一、調用系統命令實現刪除文件的操做；
{
public class DSOOperation {
public static voidmain(String[] args) {
Runtimerun=Runtime.getRuntime();
try {
//cmd /c 如下這句就是刪除文件
run.exec("cmd /c delD:\\tt.txt");
//控制檯顯示信息
Processp=run.exec("cmd /c dir src");
InputStreamis=p.getInputStream();
BufferedReaderread=new BufferedReader(new InputStreamReader(is));
while(true){
Strings=read.readLine();
if(s==null)break;
System.err.println(s);
}
} catch(IOException e) {
e.printStackTrace();
}
}
}
}
7二、實現從文件裏一次讀出一個字符的操做。
{
BufferedReader reader = new BufferedReader(newFileReader("my.txt"));
int ch;
while((ch=reader.read())>0){
System.out.println((char)ch);
}
}
7三、列出一些控制流程的方法；????????
??
???
?????????????
?????
?????
??
???
?
?
7四、編寫了一個server端的程序實現在client輸入字符而後在控制檯上顯示，直到輸入"END"爲止，讓你寫出client的程序；
7五、做用域public,private,protected,以及不寫時的差異 答：差異例如如下：
做用域 當前類 同一package 子孫類 其它package public √ √ √ √ protected √ √ √ × friendly √ √ × ×
private √ × × × 不寫時默以爲friendly
7六、ArrayList和Vector的差異,HashMap和Hashtable的差異
答：就ArrayList與Vector主要從二方面來講. 一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的。不是同步的 二.數據增加:當需要增加時,Vector默認增加爲原來一培，而ArrayList倒是原來的一半
就HashMap與HashTable主要從三方面來講。 一.歷史緣由:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現 二.同步性:Hashtable是線程安全的，也就是說是同步的。而HashMap是線程序不安全的，不是同步的 三.值：僅僅有HashMap可以讓你將空值做爲一個表的條目的key或value
7七、char型變量中能不能存貯一箇中文漢字?爲何?
答：是能夠定義成爲一箇中文的，因爲java中以unicode編碼，一個char佔16個字節。因此放一箇中文是沒問題的
7八、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
答：多線程有兩種實現方法。各自是繼承Thread類與實現Runnable接口 同步的實現方面有兩種，各自是synchronized,wait與notify
7九、float型float f=3.4是否正確? 答:不對。精度不許確,應該用強制類型轉換。例如如下所看到的：float f=(float)3.4
80、介紹JAVA中的Collection FrameWork(包含怎樣寫本身的數據結構)?
答：Collection FrameWork例如如下： Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack
└Set Map ├Hashtable ├HashMap └WeakHashMap Collection是最主要的集合接口，一個Collection表明一組Object，即Collection的元素（Elements） Map提供key到value的映射
{
- Collection FrameWork例如如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最主要的集合接口。一個Collection表明一組Object，即Collection的元素（Elements）
Map提供key到value的映射 - 加入評論
評論讀取中...
- bigtoothh | 2009-09-22 19:14:24
- 有0人以爲這個回答不錯 | 有0人以爲這個回答沒有幫助
- COLLECTION：選集。又稱合集。大部分收錄的是所謂的「精華」。
ィメ－ジ·アルバム / IMAGE ALBUM印象集：不一樣於OST。當中的曲子並非是對原劇中的音樂忠實的再現，而是經過與原做有些不一樣的方式將原曲演奏出來，以便相對獨立的構成曲目（更適合像音樂會演奏的場合）。給人的感受是印象中的原曲。
[編輯本段]
計算機領域的定義
Collection 層次結構 中的根接口。Collection 表示一組對象，這些對象也稱爲 collection 的元素。一些 collection 贊成有反覆的元素，而還有一些則不一樣意。
一些 collection 是有序的，而還有一些則是無序的。JDK 不提供此接口的不論什麼直接 實現：它提供更詳細的子接口（如 Set 和 List）實現。此接口通常用來傳遞 collection。並在需要最大廣泛性的地方操做這些 collection。
包 (bag) 或多集合 (multiset)（可能包括反覆元素的無序 collection）應該直接實現此接口。
所有通用的 Collection 實現類（一般經過它的一個子接口間接實現 Collection）應該提供兩個「標準」構造方法：一個是 void（無參數）構造方法。用於建立空 collection；還有一個是帶有 Collection 類型單參數的構造方法。用於建立一個具備與其參數一樣元素新的 collection。實際上。後者贊成用戶複製不論什麼 collection，以生成所需實現類型的一個等效 collection。雖然沒法強制運行此約定（因爲接口不能包括構造方法）。但是 Java 平臺庫中所有通用的 Collection 實現都聽從它。
此接口中包括的「破壞性」方法，是指可改動其所操做的 collection 的那些方法，假設此 collection 不支持該操做，則指定這些方法拋出 UnsupportedOperationException。假設是這樣，那麼在調用對該 collection 無效時，這些方法可能，但並不必定拋出 UnsupportedOperationException。好比，假設要加入的 collection 爲空且不可改動。則對該 collection 調用 addAll(Collection) 方法時。可能但並不必定拋出異常。
一些 collection 實現對它們可能包括的元素有所限制。好比。某些實現禁止 null 元素，而某些實現則對元素的類型有限制。
試圖加入不合格的元素將拋出一個未經檢查的異常，通常是 NullPointerException 或 ClassCastException。試圖查詢是否存在不合格的元素可能拋出一個異常，或者僅僅是簡單地返回 false；某些實現將表現出前一種行爲，而某些實現則表現後一種。較爲常見的是。試圖對某個不合格的元素運行操做且該操做的完畢不會致使將不合格的元素插入 collection 中，將可能拋出一個異常，也可能操做成功，這取決於實現自己。
這種異常在此接口的規範中標記爲「可選」。
由每個 collection 來肯定其自身的同步策略。在沒有實現的強烈保證的狀況下，調用由還有一進程正在更改的 collection 的方法可能會出現不肯定行爲；這包含直接調用，將 collection 傳遞給可能運行調用的方法，以及使用現有迭代器檢查 collection。
Collections Framework 接口中的很是多方法是依據 equals 方法定義的。好比，contains(Object o) 方法的規範聲明：「當且僅當此 collection 包括至少一個知足 (o==null ? e==null :o.equals(e)) 的元素 e 時，返回 true。」不 應將此規範理解爲它暗指調用具備非空參數 o 的 Collection.contains 方法會致使爲隨意的 e 元素調用 o.equals(e) 方法。可隨意對各類實現運行優化，僅僅要避免調用 equals 就能夠，好比。經過首先比較兩個元素的哈希碼。（Object.hashCode() 規範保證哈希碼不相等的兩個對象不會相等）。較爲常見的是。各類 Collections Framework 接口的實現可任意利用底層 Object 方法的指定行爲。而不管實現程序以爲它是否合適。
集合的常用操做
boolean add(E e)
確保此 collection 包括指定的元素（可選操做）。
boolean addAll(Collection<? extends E> c)
將指定 collection 中的所有元素都加入到此 collection 中（可選操做）。
void clear()
移除此 collection 中的所有元素（可選操做）。
boolean contains(Object o)
假設此 collection 包括指定的元素，則返回 true。
boolean containsAll(Collection<?> c)
假設此 collection 包括指定 collection 中的所有元素，則返回 true。
boolean equals(Object o)
比較此 collection 與指定對象是否相等。
int hashCode()
返回此 collection 的哈希碼值。
boolean isEmpty()
假設此 collection 不包括元素，則返回 true。
Iterator<E> iterator()
返回在此 collection 的元素上進行迭代的迭代器。
boolean remove(Object o)
今後 collection 中移除指定元素的單個實例，假設存在的話（可選操做）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包括在指定 collection 中的所有元素（可選操做）。
boolean retainAll(Collection<?> c)
僅保留此 collection 中那些也包括在指定 collection 的元素（可選操做）。
int size()
返回此 collection 中的元素數。
Object[] toArray()
返回包括此 collection 中所有元素的數組。
<T> T[]toArray(T[] a)
返回包括此 collection 中所有元素的數組；返回數組的執行時類型與指定數組的執行時類型一樣。
[編輯本段]
Collection接口的各子類的深刻剖析
線性表，鏈表，哈希表是常用的數據結構，在進行Java開發時，JDK已經爲咱們提供了一系列對應的類來實現主要的數據結構。這些類均在java.util包中。本段落試圖經過簡單的描寫敘述，向讀者闡述各個類的做用以及怎樣正確使用這些類。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
Collection是最主要的集合接口。一個Collection表明一組Object，即 Collection的元素（Elements）。一些Collection贊成一樣的元素而還有一些不行。一些能排序而還有一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的「子接口」如List和Set。
所有實現Collection接口的類都必須提供兩個標準的構造函數：無參數的構造函數用於建立一個空的Collection，有一個Collection參數的構造函數用於建立一個新的Collection。這個新的Collection與傳入的Collection有一樣的元素。後一個構造函數贊成用戶複製一個Collection。
怎樣遍歷Collection中的每一個元素？不論Collection的實際類型怎樣，它都支持一個iterator()的方法。該方法返回一個迭代子。使用該迭代子就能夠逐一訪問Collection中每一個元素。典型的使用方法例如如下：
Iterator it = collection.iterator(); // 得到一個迭代子
while(it.hasNext()) {
Object obj = it.next(); // 獲得下一個元素
}
由Collection接口派生的兩個接口是List和Set。
List接口
List是有序的Collection，使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，相似於數組下標）來訪問List中的元素，這相似於Java的數組。
和如下要提到的Set不一樣，List贊成有一樣的元素。
除了具備Collection接口必備的iterator()方法外，List還提供一個 listIterator()方法。返回一個ListIterator接口，和標準的Iterator接口相比，ListIterator多了一些 add()之類的方法，贊成加入，刪除，設定元素，還能向前或向後遍歷。
實現List接口的常用類有LinkedList，ArrayList。Vector和Stack。
LinkedList類
LinkedList實現了List接口，贊成null元素。此外LinkedList提供額外的get，remove，insert方法在LinkedList的首部或尾部。這些操做使LinkedList可被用做堆棧（stack），隊列（queue）或雙向隊列（deque）。
注意LinkedList沒有同步方法。假設多個線程同一時候訪問一個List，則必須本身實現訪問同步。一種解決方法是在建立List時構造一個同步的List：
List list = Collections.synchronizedList(new LinkedList(...));
ArrayList類
ArrayList實現了可變大小的數組。它贊成所有元素。包含null。ArrayList沒有同步。
size，isEmpty，get，set方法執行時間爲常數。但是add方法開銷爲分攤的常數，加入n個元素需要O(n)的時間。其它的方法執行時間爲線性。
每個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨着不斷加入新元素而本身主動添加，但是增加算法並未定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來添加 ArrayList的容量以提升插入效率。
和LinkedList同樣。ArrayList也是非同步的（unsynchronized）。
Vector類
Vector很相似ArrayList，但是Vector是同步的。由Vector建立的 Iterator。儘管和ArrayList建立的Iterator是同一接口。但是，因爲Vector是同步的。當一個Iterator被建立而且正在被使用，還有一個線程改變了Vector的狀態（好比。加入或刪除了一些元素）。這時調用Iterator的方法時將拋出 ConcurrentModificationException，所以必須捕獲該異常。
Stack 類
Stack繼承自Vector，實現一個後進先出的堆棧。Stack提供5個額外的方法使得 Vector得以被看成堆棧使用。主要的push和pop方法，還有peek方法獲得棧頂的元素。empty方法測試堆棧是否爲空，search方法檢測一個元素在堆棧中的位置。Stack剛建立後是空棧。
Set接口
Set是一種不包括反覆的元素的Collection，即隨意的兩個元素e1和e2都有e1.equals(e2)=false，Set最多有一個null元素。
很是明顯，Set的構造函數有一個約束條件，傳入的Collection參數不能包括反覆的元素。
請注意：必須當心操做可變對象（Mutable Object）。假設一個Set中的可變元素改變了自身狀態致使Object.equals(Object)=true將致使一些問題。
Map接口
請注意，Map沒有繼承Collection接口，Map提供key到value的映射。一個 Map中不能包括一樣的key，每個key僅僅能映射一個value。Map接口提供3種集合的視圖。Map的內容可以被看成一組key集合，一組 value集合，或者一組key-value映射。
Hashtable類
Hashtable繼承Map接口，實現一個key-value映射的哈希表。不論什麼非空（non-null）的對象均可做爲key或者value。
加入數據使用put(key, value)，取出數據使用get(key)。這兩個基本操做的時間開銷爲常數。
Hashtable經過initial capacity和load factor兩個參數調整性能。一般缺省的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但對應的查找時間將增大，這會影響像get和put這種操做。
使用Hashtable的簡單示比例如如下，將1，2。3放到Hashtable中。他們的key各自是」one」，」two」，」three」：
Hashtable numbers = new Hashtable();
numbers.put(「one」, new Integer(1));
numbers.put(「two」, new Integer(2));
numbers.put(「three」, new Integer(3));
要取出一個數，比方2。用對應的key：
Integer n = (Integer)numbers.get(「two」);
System.out.println(「two = 」 + n);
由於做爲key的對象將經過計算其散列函數來肯定與之相應的value的位置。所以不論什麼做爲 key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object。假設你用本身定義的類看成key 的話，要至關當心，依照散列函數的定義。假設兩個對象一樣，即obj1.equals(obj2)=true，則它們的hashCode必須一樣，但假設兩個對象不一樣，則它們的hashCode不必定不一樣，假設兩個不一樣對象的hashCode一樣，這樣的現象稱爲衝突，衝突會致使操做哈希表的時間開銷增大，因此儘可能定義好的hashCode()方法，能加快哈希表的操做。
假設一樣的對象有不一樣的hashCode。對哈希表的操做會出現意想不到的結果（期待的get方法返回null）。要避免這樣的問題，僅僅需要牢記一條：要同一時候複寫equals方法和hashCode方法。而不要僅僅寫當中一個。
Hashtable是同步的。
HashMap類
HashMap和Hashtable相似，不一樣之處在於HashMap是非同步的，並且贊成 null。即null value和null key。，但是將HashMap視爲Collection時（values()方法可返回Collection），其迭代子操做時間開銷和HashMap 的容量成比例。所以。假設迭代操做的性能至關重要的話。不要將HashMap的初始化容量設得太高。或者load factor太低。
WeakHashMap類
WeakHashMap是一種改進的HashMap，它對key實行「弱引用」，假設一個key再也不被外部所引用。那麼該key可以被GC回收。
總結
假設涉及到堆棧。隊列等操做，應該考慮用List。對於需要高速插入。刪除元素，應該使用LinkedList，假設需要高速隨機訪問元素，應該使用ArrayList。
假設程序在單線程環境中，或者訪問只在一個線程中進行。考慮非同步的類。其效率較高，假設多個線程可能同一時候操做一個類，應該使用同步的類。
要特別注意對哈希表的操做。做爲key的對象要正確複寫equals和hashCode方法。
儘可能返回接口而非實際的類型。如返回List而非ArrayList，這樣假設之後需要將ArrayList換成LinkedList時，client代碼不用改變。這就是針對抽象編程。
同步性
Vector是同步的。這個類中的一些方法保證了Vector中的對象是線程安全的。而 ArrayList則是異步的，所以ArrayList中的對象並不是線程安全的。
因爲同步的要求會影響運行的效率，因此假設你不需要線程安全的集合那麼使用ArrayList是一個很是好的選擇。這樣可以避免因爲同步帶來的沒必要要的性能開銷。
數據增加
從內部實現機制來說ArrayList和Vector都是使用數組(Array)來控制集合中的對象。當你向這兩種類型中添加元素的時候。假設元素的數目超出了內部數組眼下的長度它們都需要擴展內部數組的長度，Vector缺省狀況下本身主動增加原來一倍的數組長度，ArrayList是原來的50%,因此最後你得到的這個集合所佔的空間老是比你實際需要的要大。因此假設你要在集合中保存大量的數據那麼使用Vector有一些優點，因爲你可以經過設置集合的初始化大小來避免沒必要要的資源開銷。
使用模式
在ArrayList和Vector中。從一個指定的位置（經過索引）查找數據或是在集合的末尾添加、移除一個元素所花費的時間是同樣的，這個時間咱們用O(1)表示。但是，假設在集合的其它位置添加或移除元素那麼花費的時間會呈線形增加：O(n-i)，當中n表明集合中元素的個數，i表明元素添加或移除元素的索引位置。爲何會這樣呢？覺得在進行上述操做的時候集合中第i和第i個元素以後的所有元素都要運行位移的操做。這一切意味着什麼呢？
這意味着，你僅僅是查找特定位置的元素或僅僅在集合的末端添加、移除元素，那麼使用Vector或 ArrayList都可以。假設是其它操做，你最好選擇其它的集合操做類。比方，LinkList集合類在添加或移除集合中不論什麼位置的元素所花費的時間都是同樣的?O(1)，但它在索引一個元素的使用缺比較慢－O(i),當中i是索引的位置.使用ArrayList也很是easy，因爲你可以簡單的使用索引來取代建立iterator對象的操做。LinkList也會爲每個插入的元素建立對象。所有你要明確它也會帶來額外的開銷。
最後，在《Practical Java》一書中Peter Haggar建議使用一個簡單的數組（Array）來取代Vector或ArrayList。尤爲是對於運行效率要求高的程序更應如此。因爲使用數組 (Array)避免了同步、額外的方法調用和沒必要要的又一次分配空間的操做。
}
8一、用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 接口
8二、編程：編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串。 但是要保證漢字不被截半個。如「我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(); } }
8三、JAVA SERVLET API中forward() 與redirect()的差異？
答:前者僅是容器中控制權的轉向，在client瀏覽器地址欄中不會顯示出轉向後的地址。後者則是全然的跳轉。瀏覽器將會獲得跳轉的地址，並又一次發送請求連接。這樣，從瀏覽器的地址欄中可以看到跳轉後的連接地址。因此。前者更加高效，在前者可以知足需要時。儘可能使用forward()方法，並且，這樣也有助於隱藏實際的連接。在有些狀況下。比方，需要跳轉到一個其餘server上的資源，則必須使用sendRedirect()方法。
8四、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 { } }
8五、可能會讓你寫一段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(); } } }
8六、Class.forName的做用?爲何要用? 答：調用該訪問返回一個以字符串指定類名的類的對象。
{
Class.forName(xxx.xx.xx)返回的是一個類
首先你要明確在java裏面不論什麼class都要裝載在虛擬機上才幹執行。這句話就是裝載類用的(和new不同。要分清楚)。
至於何時用，你可以考慮一下這個問題，給你一個字符串變量。它表明一個類的包名和類名，你怎麼實例化它？僅僅有你提到的這種方法了，只是要再加一點。
A a = (A)Class.forName("pacage.A").newInstance();
這和你
A a = new A()；
是同樣的效果。
關於補充的問題
答案是確定的。jvm會運行靜態代碼段，你要記住一個概念。靜態代碼是和class綁定的。class裝載成功就表示運行了你的靜態代碼了。
而且之後不會再走這段靜態代碼了。
Class.forName(xxx.xx.xx)返回的是一個類
Class.forName(xxx.xx.xx);的做用是要求JVM查找並載入指定的類。也就是說JVM會運行該類的靜態代碼段
動態載入和建立Class對象。比方想依據用戶輸入的字符串來建立對象
String str = 用戶輸入的字符串
Class t = Class.forName(str);
t.newInstance();
在初始化一個類。生成一個實例的時候。newInstance()方法和newkeyword除了一個是方法，一個是keyword外，最主要有什麼差異？它們的差異在於建立對象的方式不同，前者是使用類載入機制。後者是建立一個新類。
那麼爲何會有兩種建立對象方式？這主要考慮到軟件的可伸縮、可擴展和可重用等軟件設計思想。
Java中工廠模式經常使用newInstance()方法來建立對象，所以從爲何要使用工廠模式上可以找到詳細答案。好比：
class c = Class.forName(「Example」);
factory = (ExampleInterface)c.newInstance();
當中ExampleInterface是Example的接口，可以寫成例如如下形式：
String className = "Example";
class c = Class.forName(className);
factory = (ExampleInterface)c.newInstance();
進一步可以寫成例如如下形式：
String className = readfromXMlConfig;//從xml配置文件裏得到字符串
class c = Class.forName(className);
factory = (ExampleInterface)c.newInstance();
上面代碼已經不存在Example的類名稱，它的長處是，無論Example類怎麼變化，上述代碼不變，甚至可以更換Example的兄弟類Example2 , Example3 , Example4……，僅僅要他們繼承ExampleInterface就可以。
從JVM的角度看，咱們使用keywordnew建立一個類的時候。這個類可以沒有被載入。但是使用newInstance()方法的時候，就必須保證：1、這個類已經載入；2、這個類已經鏈接了。而完畢上面兩個步驟的正是Class的靜態方法forName()所完畢的。這個靜態方法調用了啓動類載入器，即載入java API的那個載入器。
現在可以看出。newInstance()其實是把new這個方式分解爲兩步。即首先調用Class載入方法載入某個類，而後實例化。
這樣分步的優勢是顯而易見的。咱們可以在調用class的靜態載入方法forName時得到更好的靈活性，提供給了一種降耦的手段。
最後用最簡單的描寫敘述來區分newkeyword和newInstance()方法的差異：
newInstance: 弱類型。
低效率。僅僅能調用無參構造。
new: 強類型。相對高效。能調用不論什麼public構造。
}
8七、你在項目中用到了xml技術的哪些方面?怎樣實現的? 答:用到了數據存貯。信息配置雙方面。在作數據交換平臺時，將不能數據源的數據組裝成XML文件。而後將XML文件壓縮打包加密後經過網絡傳送給接收者。接收解密與解壓縮後再同XML文件裏還原相關信息進行處理。在作軟件配置時。利用XML可以很是方便的進行，軟件的各類配置參數都存貯在XML文件裏。
8八、用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()); } } }
89、編程用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>
90、EJB2.0有哪些內容?分別用在什麼場合? EJB2.0和EJB1.1的差異? 答：規範內容包含Bean提供者，應用程序裝配者，EJB容器，EJB配置工具，EJB服務提供者，系統管理員。這裏面。EJB容器是EJB之因此能夠執行的核心。EJB容器管理着EJB的建立，撤消。激活。去活，與數據庫的鏈接等等重要的核心工做。JSP,Servlet,EJB,JNDI,JDBC,JMS.....
91、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組件。
9二、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 }
93、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屬性、國際化的提示和消息。
9四、開發中都用到了那些設計模式?用在什麼場合? 答：每個模式都描寫敘述了一個在咱們的環境中不斷出現的問題，而後描寫敘述了該問題的解決方式的核心。經過這樣的方式，你可以無數次地使用那些已有的解決方式。無需在反覆一樣的工做。主要用到了MVC的設計模式。用來開發JSP/Servlet或者J2EE的相關應用。
簡單工廠模式等。
JavaScript方面 一、怎樣校驗數字型? 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方面 一、CORBA是什麼?用途是什麼? 答：CORBA 標準是公共對象請求代理結構(Common Object Request Broker Architecture)。由對象管理組織 (Object Management Group，縮寫爲 OMG)標準化。它的組成是接口定義語言(IDL), 語言綁定(binding:也譯爲聯編)和贊成應用程序間互操做的協議。 其目的爲： 用不一樣的程序設計語言書寫 在不一樣的進程中執行 爲不一樣的操做系統開發
JAVA華爲面試題JAVA方面
95 說出ArrayList,Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便添加和插入元素。它們都贊成直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操做，因此索引數據快而插入數據慢。Vector由於使用了synchronized方法（線程安全），一般性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或後向遍歷。但是插入數據時僅僅需要記錄本項的先後項就能夠，因此插入速度較快。
96設計4個線程，當中兩個線程每次對j添加1，另外兩個線程對j每次下降1。寫出程序。
下面程序使用內部類實現線程，對j增減的時候沒有考慮順序問題。public class ThreadTest1{
private int j; public static void main(String args[]){ThreadTest1 tt=new ThreadTest1();Inc inc=tt.new Inc();
Dec dec=tt.new Dec();for(int i=0;i<2;i++){ Thread t=new Thread(inc);t.start();t=new Thread(dec);t.start();
}}private synchronized void inc(){j++;System.out.println(Thread.currentThread().getName()+"-inc:"+j); }
private synchronized void dec(){j--;System.out.println(Thread.currentThread().getName()+"-dec:"+j); }
class Inc implements Runnable{public void run(){for(int i=0;i<100;i++){inc();}}}class Dec implements Runnable{
public void run(){for(int i=0;i<100;i++){dec();}}}}
97說出Servlet的生命週期，並說出Servlet和CGI的差異。Servlet被server實例化後，容器執行其init方法，請求到達時執行其service方法。service方法本身主動派遣執行與請求相應的doXXX方法（doGet，doPost）等。當server決定將實例銷燬的時候調用其destroy方法。與cgi的差異在於servlet處於server進程中。它經過多線程方式執行其service方法，一個實例可以服務於多個請求，並且事實上例通常不會銷燬，而CGI對每個請求都產生新的進程。服務完畢後就銷燬，因此效率上低於servlet。
98.EJB是基於哪些技術實現的?並說出SessionBean和EntityBean的差異，StatefulBean和StatelessBean的差異。
99．EJB包含（SessionBean,EntityBean）說出他們的生命週期，及怎樣管理事務的？
100．說出數據鏈接池的工做機制是什麼?
101同步和異步有和異同。在什麼狀況下分別使用他們？舉例說明。
102應用server有那些？
103你所知道的集合類都有哪些？主要方法？
104給你一個:驅動程序A,數據源名稱爲B,username稱爲C,password爲D,數據庫表爲T。請用JDBC檢索出表T的所有數據。
105．說出在JSP頁面裏是怎麼分頁的?
頁面需要保存下面參數：總行數：依據sql語句獲得總行數 每頁顯示行數：設定值當前頁數：請求參數
頁面依據當前頁數和每頁行數計算出當前頁第一行行數，定位結果集到此行，對結果集取出每頁顯示行數的行就能夠。
數據庫方面：106.存儲過程和函數的差異存儲過程是用戶定義的一系列sql語句的集合，涉及特定表或其餘對象的任務。用戶可以調用存儲過程，而函數通常是數據庫已定義的方法，它接收參數並返回某種類型的值並且不涉及特定用戶表。
107事務是什麼？事務是做爲一個邏輯單元運行的一系列操做。一個邏輯工做單元必須有四個屬性。稱爲 ACID（原子性、一致性、隔離性和持久性）屬性，僅僅有這樣才幹成爲一個事務：原子性，事務必須是原子工做單元；對於其數據改動。要麼全都運行。要麼全都不運行。一致性，事務在完畢時，必須使所有的數據都保持一致狀態。在相關數據庫中，所有規則都必須應用於事務的改動，以保持所有數據的完整性。事務結束時，所有的內部數據結構（如 B 樹索引或雙向鏈表）都必須是正確的。隔離性。由併發事務所做的改動必須與不論什麼其餘併發事務所做的改動隔離。事務查看數據時數據所處的狀態。要麼是還有一併發事務改動它以前的狀態，要麼是還有一事務改動它以後的狀態，事務不會查看中間狀態的數據。
這稱爲可串行性，因爲它能夠又一次裝載起始數據，並且重播一系列事務，以使數據結束時的狀態與原始事務運行的狀態一樣。持久性，事務完畢以後，它對於系統的影響是永久性的。該改動即便出現系統故障也將一直保持。
108遊標的做用？怎樣知道遊標已經到了最後？遊標用於定位結果集的行，經過推斷全局變量@@FETCH_STATUS可以推斷是否到了最後。一般此變量不等於0表示出錯或到了最後。
109觸發器分爲事前觸發和過後觸發，這兩種觸發有和差異。語句級觸發和行級觸發有何差異。事前觸發器執行於觸發事件發生以前。而過後觸發器執行於觸發事件發生以後。一般事前觸發器可以獲取事件以前和新的字段值。語句級觸發器可以在語句執行前或後執行。而行級觸發在觸發器所影響的每一行觸發一次。
110你知道Object類中有那些方法？（任意說幾個就能夠）
1`把一個對象做爲一個方法的參數，在該方法中對該對象的屬性作了改動，請問在外部調用該方法後。傳入方法的對象是否發生了變化？好比：若是stephen是一個類intchange value(Stephen Stephen) Stephen a=Spublic static void main(stringc( )args)Stephen Stephen=new Stephen( )Int; P=change value (Stephen);請問對象stephen變化了嗎？
許天嶺面試題
1在Jdbc進行數據庫調用時，你經常採用什麼方式運行sql語句？爲何不用其它方式（比較一下就能夠）
一、 int類型在java中有多少位？（假設面試題目中有這種問題。不是公司太牛就是公司太差）
二、 你用過線程嗎？請啓動4個線程對一個靜態變量進行加1操做。
三、 線程是怎樣啓動的？
四、 每個類實力化時都調用父類的構造函數嗎？假設是。那麼都調用object類的構造函數嗎？
五、 你懂得Ftp協議嗎？假設不懂請問我告訴你Ftp協議命令格式及數據包的解析方法。你能用多長時間用java基本apI搞定一個ftpclient程序（是這種問題主要看你我的學習能力。通常也就是一人五天的工做量，沒必要要懼怕，通常他不會給你五天作的，就是想看一下你的自信心及對工做的理解能力）
六、 你知道java與C的通訊?嗎你會用那些協議進行通訊？（事實上也就是問socret通訊）
七、 請問java中的網絡通訊有那些方式，有什麼差異？
八、 String a=「」Forlimit I=0;I<100000;I++)A=a+「A」把字符串成「A」鏈接100000次，上面方法不夠好。請優化上面代碼？（採用stringBuffer進行優化）
九、 EJB的調用過程，請敘述一下。
對於EJB的面試，業界基本上是假的，我們學的東西是夠應付。但假設你能說的很是有條理。你的檔次就高了
十、 假設遇到英文試題，也就是平時經常見的調試信息不用懼怕
十一、 你在jsp中打印是怎樣實現的？還要說你用系統的打印方法，也就是說，在JSP中如有很是多內容，而我僅僅需要打印當中一個表格。是怎樣實現的？
十二、 你用java script作過樹型菜單嗎？（這種問題你應該說沒有作國。但是會用，固然你要是真作過也很是好。那麼未來你的就是作JSP界面的高手）
1三、 WEBserver啓動時，系統需要作一些初始化的工做，這些工做該怎麼處理，在structs下又該如何處理（不要僅僅會用structs。而忘記了傳統方式，外面還有很是多項目沒有人會用structs）
1四、 對structs，相信你們都很是熟悉，但不要忘記傳統的開發模式。
1五、 你寫過tag嗎？
1六、 你作過在jsp頁面上下載一個文本文件嗎？請描寫敘述你的方法？
1七、 你在數據庫編程過程當中，面臨的數據量有多大？假設有一個項目中天天有三張結構全然一樣的表，一個365每天天如此，每張表記錄在100萬條以上，現需要分頁查詢。依據這種項目，採用你用過的分頁原理，行嗎？（這是考的是性能。通常的分頁方式不行。遇到這種題，你可以說。你需要了解更具體的業務。認真的研究一下，是可以的，固然，假設你以爲你的方法可以。可以對這種問題進行交流。等等。
這種題，說很差也行。不影響你的面試，主要是看一下你對問題的態度）
1八、 你用java調用過的存儲過程嗎？當一個存儲過程有返回記錄集時。該如何在java中返回？
1九、 應該對oracle有所瞭解，對一些數據庫的名詞，應該知道詞的解釋。
託普集團程序猿面試試
1、選擇題(每題1分，共20分)1． 下列那種語言是面向對象的（C）
A. C B. PASCAL C. C++ D. FORTRAN77
2．在Windows9x 下。可以進入 MS-D0S 方式。當在DOS 提示符下鍵入 ( B ) 命令後。系統將退出MS-DOS方式，返回到 WIndows 方式。
A. CLOSE B. EXIT C. QUIT D. RETURN
3．如下哪些是面向對象的基本特性：(ABC)A 多態 B 繼承 C 封裝 D 接口
4．在C++中常常要進行異常處理。如下哪些是異常處理常用到的關鍵詞：(ABC)
A try B catch C throw D break E contiue
5．數據庫技術中的「髒數據',是指（C）的數據。A.錯誤B.回返C.未提交D.未提交的隨後又被撤消
6．TCP/IP是一種（A,B）A.標準 B.協議 C.語言 D.算法
7． 如下有關計算機操做系統的敘述中，不對的是(B) A 操做系統屬於系統軟件 B 操做系統僅僅負責管理內存儲器，而不管理外存儲器C UNIX 是一種操做系統 D計算機的處理器、內存等硬件資源也由操做系統管理
8．微機上操做系統的做用是(D) A 解釋運行源程序 B 編譯源程序
C 進行編碼轉換 D 控制和管理系統資源
9．下列存儲器中存取速度最快的是(A) A 內存 B 硬盤 C 光盤D 軟盤
10．在計算機中，—個字節是由多少個二進制位組成的(B) A. 4 B. 8 C. 16 D. 24
11. 存儲16×16點陣的一個漢字信息，需要的字節數爲( A )A 32 B 64 C 128 D 256
12. 下面選項中合法的字符常量是（BC）A."B" B.'\010' C. 68 D. D
13. 假定x和y爲double型，則表達式x=2,y=x+3/2的值是（D）A. 3.500000 B. 3 C. 2.000000 D. 3.000000
14. 下面合法的賦值語句是（BCD）//In C++ ,choice D also is correct, but in C language, D is wrong.
A. x=y=100 B. d--; C. x+y; D. c=int(a+b);
15. 設正x、y均爲整型變量，且x=10 y=3，則下面語句pprintf("%d,%d\n",x--,--y);的輸出結果是（D）
A.10,3 B. 9,3 C. 9,2 D.10,2
16. x、y、z被定義爲int型變量，若從鍵盤給x、y、z輸入數據。正確的輸入語句是（B）
A .INPUT x、y、z; B.scanf("%d%d%d",&x,&y,&z);C.scanf("%d%d%d",x,y,z); D.read("%d%d%d",&x,&y,&z);
17.下面數組定義中不對的是（D）A) int a[2][3]; B) int b[][3]={0,1,2,3};C) int c[100][100]={0}; D) int d[3][]={{1,2},{1,2,3},{1,2,3,4}};
18. 下面程序的輸出結果是（A）main(){ int a[4][4]={{1,3,5},{2,4,6},{3,5,7}};
printf("%d%d%d%d\n",a[0][3],a[1][2],a[2][1],a[3][0];
}A) 0650 B) 1470 C) 5430 D) 輸出值不定
19 下面程序的輸出結果是（B）main(){char st[20]= "hello\0\t\\\";printf(%d %d\n",strlen(st),sizeof(st));
}A) 9 9 B) 5 20 C) 13 20 D) 20 20
20. 當調用WindowsAPI函數InvalidateRect,將會產生什麼消息（A）A:WM_PAINT B:WM_CREATE C:WM_NCHITTEST D:WM_SETFOCUS
2、填空題(每題3分，共30分)
1．請列舉當前一些當前流行的數據庫引擎,SQLSERVER,ORACLE,BDE,Microsoft Jet。
2． 爲了將當前盤當前文件夾中的所有文本文件（擴展名爲.TXT）的內容打印輸出，正確的單條DOS命令爲COPY *.TXT PRN。
3． 計算機網絡分爲局域網和廣域網，因特網屬於廣域網。
4. 設y是int型變量。請寫出推斷y爲奇效的關係表達y%2。=0。
5. 設有下面程序:main(){int n1,n2;scanf("%d",&n2);while(n2!=0){n1=n2%10;n2=n2/10;printf("%d",n1);}}
程序執行後，假設從鍵盤上輸入1298。則輸出結果爲8921。
6．下面程序執行後的輸出結果是:9876 876
main(){ char s[]="9876",*p;for ( p=s ; p<s+2 ; p++) printf("%s\n", p);}
7．下面函數的功能是：求x的y次方。請填空。
double fun( double x, inty){ int i;double z;for(i=1, z=x; i<y;i++) z=z* x ;return z;}
8．下面程序段打開文件後。先利用fseek函數將文件位置指針定位在文件末尾，而後調用ftell函數返回當前文件位置指針的詳細位置，從而肯定文件長度，請填空。FILE*myf; long f1;myf= fopen ("test.t","rb");
fseek(myf,0,SEEK_END);f1=ftell(myf);fclose(myf);printf("%d\n",f1);
9. 下面程序輸出的最後一個值是120。
int ff(int n){ static intf=l;f=f*n;return f;}main(){ int i;for(I=1;I<=5;I++printf("%d\n",ff(i));)
10. 下面程序執行後的輸出結果是52 main(){ int i=10, j=0;do{ j=j+i;i--;while(i>2);printf("%d\n",j);}
3、推斷題(每題2分，共20分)
1：動態鏈結庫不能靜態調用。 錯誤
2：UDP是面向無鏈接的網絡鏈接 正確
3：ASP是一種數據庫引擎 錯誤
4：隊列是先進後出。
錯誤
5：Weblogic是分佈式應用server。 正確
6：TCP,UDP都是傳輸層的協議。
正確
7: 兩個線程不能共存於同一地址空間 錯誤
8: JAVA是一種跨平臺的開發工具 正確
9．在WINDOWS操做系統中對外設是以文件的方式進行管理 正確
10. 虛擬內存實際是建立在硬盤上的 正確
4、問答題(每題10分。共30分)
1． 寫出從數據庫表Custom中查詢No、Name、Num一、Num2並將Name以姓名顯示、計算出的和以總和顯示的SQL。SELECT No , Name AS ‘姓名’ 。Num1，Num2，（Num1+Num2） AS ‘總和’
FROM Custom
2. 何爲「事務處理」。談談你對它的理解。事務處理是指一個單元的工做，這些工做要麼全作。要麼所有不作。做爲一個邏輯單元，必須具有四個屬性：本身主動性、一致性、獨立性和持久性。
本身主動性是指事務必須是一個本身主動的單元工做。要麼運行所有數據的改動，要麼所有數據的改動都不運行。一致性是指當事務完畢時，必須使所有數據都具備一致的狀態。在關係型數據庫中。所有的規則必須應用到事務的改動上，以便維護所有數據的完整性。所有的內部數據結構，在事務結束以後，必須保證正確。
獨立性是指並行事務的改動必須與其它並行事務的改動相互獨立。一個事務看到的數據要麼是另一個事務改動這些事務以前的狀態，要麼是第二個事務已經改動完畢的數據。但是這個事務不能看到正在改動的數據。
3. 常用的數據結構有哪些？請枚舉一些。（很多於5個）鏈表、堆棧、二叉樹、隊列、圖、堆。集合。
4. 什麼是OOP？什麼是類？請對照類和對象實例之間的關係。OOP是Object_oriented Programming(面向對象編程)的縮寫。這主要是爲了差異於曾經的面向過程的程序設計。指的是用對象的觀點來組織與構建系統，它綜合了功能抽象和數據抽象。這樣可以下降數據之間的耦合性和代碼的出錯概率。使用面向對象編程技術可以使得軟件開發人員依照現實世界裏人們思考問題的模式編寫代碼,可以讓軟件開發人員更好地利用代碼直接表達現實中存在的對象,將問題空間直接映射到解空間!類：即class 在面向對象的程序設計中，專門用「類」來表示用戶定義的抽象數據類型（user_definedabstract type）。它將具備一樣狀態、操做和訪問機制的多個對象進行了抽象。類具備繼承、數據隱藏和多態三種主要特性。
利用類的這三種特性可以更好地表示現實世界中事物。類是同一類對象實例的共性的抽象，對象是類的實例化。
對象一般做爲計算機模擬思惟，表示真實世界的抽象，一個對象就像一個軟件模塊，可以爲用戶提供一系列的服務---可以改變對象的狀態、測試、傳遞消息等。類定義了對象的實現細節或數據結構。類是靜態的。對象是動態的，對象可以看做是執行中的類。
類負責產生對象，可以將類當成生產對象的工廠（Objectfactory）.
connection connconn.setAuto(false)//表示手動提交
conn.commit// 提交
conn.rollback();//事務回滾
-內聯接use pubsselect a.au_fname,a.au_lname, p.pub_name from authors ainner join publishers p on a.city = p.city order by p.pub_name asc, a.au_lnameasc, a.au_fname asc
--左外聯接use pubs select a.au_fname, a.au_lname, p.pub_name from authors a left join publishers p
on a.city = p.city order by p.pub_name asc, a.au_lname asc, a.au_fname asc
-使用子查詢USE pubs GO SELECTdistinct pub_name FROM publishers WHERE pub_id IN (SELECT pub_idFROM titlesWHERE type ='business') GO
--假設平均價格少於$30，WHILE 循環就將價格加倍，而後選擇最高價。
--假設最高價少於或等於$50，WHILE 循環又一次啓動並再次將價格加倍。
--該循環不斷地將價格加倍直到最高價格超過$50 USE pubs GO
WHILE (SELECT AVG(price) FROMtitles) < $30
BEGIN
UPDATE titles
SET price = price * 2
SELECT MAX(price) FROM titles
IF (SELECT MAX(price) FROM titles) > $50
BREAK
ELSE
CONTINUE
END
---假設平均價格少於$30。WHILE 循環就將價格加倍，而後選擇最高價。
--假設最高價少於或等於$50。WHILE 循環又一次啓動並再次將價格加倍。
--該循環不斷地將價格加倍直到最高價格超過$50
USE pubs
GO
WHILE (SELECT AVG(price) FROMtitles) < $30
BEGIN
UPDATE titles
SET price = price * 2
SELECT MAX(price) FROM titles
IF (SELECT MAX(price) FROM titles) > $50
BREAK
ELSE
CONTINUE
END
CREATE PROCEDURE au_info
@lastname varchar(40),
@firstname varchar(20)
AS
SELECT au_lname, au_fname,title, pub_name
FROM authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t.title_id = ta.title_id INNER JOINpublishers p
ON t.pub_id = p.pub_id
WHERE au_fname = @firstname
AND au_lname = @lastname
GO
EXECUTE au_info 'Dull', 'Ann'--或者
EXECUTE au_info @lastname = 'Dull', @firstname = 'Ann'--建立存儲過程CREATE PROCEDURE titles_sum @TITLE varchar(40),@SUMmoney OUTPUT
AS
SELECT @SUM = SUM(price)
FROM titles
WHERE title LIKE @TITLE
GO
DECLARE @TOTALCOST money
EXECUTE titles_sum 'The%',@TOTALCOST OUTPUT
select @TOTALCOST
go
CREATE PROCEDUREOakland_authors
AS
SELECT au_fname, au_lname,address, city, zip
FROM authors
WHERE city = 'Oakland'
and state = 'CA'
ORDER BY au_lname, au_fname
GO
--sp_helptext Oakland_authors
ALTER PROCEDUREOakland_authors
AS
SELECT au_fname, au_lname,address, city, zip
FROM authors
WHERE state = 'CA'
ORDER BY au_lname, au_fname
GO
--sp_helptext Oakland_authors
--提交事務後，所有書籍支付的版稅添加10%。
begin transactionMyTransaction
update roysched
set royalty = royalty * 1.10
commit transactionMyTransaction
--rollback transactionMyTransaction
select royalty from roysched
--select @@trancount
--1.建立試驗實驗表
create table temptrigger
( id_temp varchar(2) not nullprimary key,
temp_name varchar(10) null,
temp_age int null)go
insert temptriggervalues('01','張三','10')
insert temptriggervalues('02','李四','11')
insert temptriggervalues('03','王五','12')
insert temptriggervalues('04','趙六','11')
select * from temptrigger go
--2.建立insert, update觸發器
create trigger temptrigger_modify
on temptrigger
for insert,update
as
begin
if (select temp_age from inserted) > 15
begin
rollback transaction
print '年齡不能超過15歲！'
end
end
--insert temptriggervalues('04','大朋','17')
--insert temptriggervalues('05','大朋','17')
--insert temptriggervalues('05','大朋','14')
--update temptrigger settemp_age='18' where id_temp = '01'
--update temptrigger settemp_age='9' where id_temp = '01'
-3.建立delete觸發器--drop trigger temptrigger_delete
create triggertemptrigger_delete
on temptrigger
for delete
as
begin
print @@rowcount
if @@rowcount > 1
begin
rollback transaction
print '一次刪除記錄不能多於1條'
end
end
--delete from temptrigger
--delete from temptrigger where id_temp='01'
--建立彙集索引create clustered indexclindx_titleid on roysched(title_id)--sp_helproysched
--建立非彙集索引create nonclustered indexunclindx_titleid onroysched(title_id)--sp_help roysched
--查看索引統計dbccshow_statistics(roysched,titleidind)
--更新索引統計update statistics authors
--重建索引dbccdbreindex('roysched',unclindx_titleid)
--刪除索引drop indexroysched.unclindx_titleid-sp_help roysched
1--建立ssn(社會保險號)的基於varchar的本身定義數據類型。
--用於存儲11位社會保險號（999-99-999）的列。該列不能
--爲null。use pubs exec sp_addtypessn , 'varchar(11)' , 'NOT NULL'
--查看建立的數據類型--sp_help ssn
--使用建立的數據類型create table mytable( myidvarchar(2) primary key, myssn ssn)
4-刪除建立的數據類型--drop table mytable--execsp_droptype ssn
•批是包括一個或多個 Transact-SQL 語句的組，從應用程序一次性地發送到 Microsoft SQL Server 運行。
批做爲一個整體運行。以GO命令結束。
批處理是client做爲一個單元發出的一個或多個 SQL 語句的集合。
每個批處理編譯爲一個運行計劃。
觸發器•觸發器是在對錶進行插入、更新或刪除操做時本身主動運行的存儲過程•觸發器通常用於強制業務規則•觸發器可以確保數據的完整性和一致性
事務是用戶定義的一個操做序列。這些操做要麼全作要麼全不作。是一個不可切割的工做單位(構成單一邏輯工做單元的操做集合)假設某一事務成功，則在該事務中進行的所有數據更改均會提交。成爲數據庫中的永久組成部分。
假設事務遇到錯誤且必須取消或回滾，則所有數據更改均被清除
•鎖是在多用戶環境中對數據訪問的限制封鎖就是事務 T 在對某個數據對象（如表、記錄等）操做以前，先向系統發出請求，對其加鎖。
加鎖後事務T 就對該數據對象有了必定的控制，在事務T釋放它的鎖以前，其餘的事務不能更新此數據對象。（鎖蘊含的基本概念是用戶需要對錶的排它訪問）•從程序猿的角度看：分爲樂觀鎖和悲觀鎖。
樂觀鎖：全然依靠數據庫來管理鎖的工做。悲觀鎖：程序猿本身管理數據或對象上的鎖處理。
子查詢：一個 SELECT 語句嵌套在還有一個 SELECT 語句中。
—索引—是一個數據庫對象。它是某個表中一列或若干列值的集合和對應的指向表中物理標識這些值的數據頁的邏輯指針清單,而後依據指定的排序次序排列這些指針 —長處提升查詢運行的速度。
強制實施數據的惟一性。 提升表之間聯接的速度。
缺點 存儲索引要佔用磁盤空間。
數據改動需要更長的時間，因爲索引也要更新。
•視圖•是一種虛擬表，通常是做爲來自一個或多個表的行或列的子集建立的。
•視圖本質上講，就是保存在數據庫中的select查詢•視圖並不是數據庫中存儲的數據值的集合。
•對終於用戶的優勢–結果更easy理解–得到數據更easy
•對開發者的優勢–限制數據檢索更easy–維護應用程序更方便
存儲過程•使用一個名稱存儲的預編譯T-SQL語句和流程控制語句的集合•由數據庫開發者或數據庫管理員編寫
•用來運行管理任務或應用複雜的業務規則 長處•運行速度更快•首次運行時，進行優化和編譯獲得運行計劃並將該計劃存儲在系統表中，之後直接運行。•實現多個程序共享應用程序邏輯•組件式編程•能夠屏蔽數據庫的結構，實現更高的安全性
•下降網絡流通量
數據庫設計和建模必要性•好的數據庫結構有利於：-節省數據的存儲空間-能夠保證數據的完整性-方便進行數據庫應用系統的開發•設計很差的數據庫結構將致使-數據冗餘、存儲空間浪費-內存空間浪費
不管數據庫的大小和複雜程度怎樣。可以用下列基本步驟來設計數據庫：–收集信息–標識對象–設計數據模型–標識每個對象 存儲的信息類型–標識對象之間的關係
•數據模型是一種標識實體類型及事實上體間聯繫的模型。典型的數據模型由網狀模型、層次模型和關係模型。
什麼是規範化從關係數據庫的表中，除去冗餘數據的過程稱爲規範化。—精簡數據庫的結構—從表中刪除冗餘的列—標識所有依賴於其餘數據的數據
三級範式
第一範式的定義：假設一個表中沒有反覆組（即行與列的交叉點上僅僅有一個值，而不是一組值），則這個表屬於第一範式（常記成1NF）。簡而言之："每一字段僅僅存儲一個值"。好比:職工號，姓名，電話號碼組成一個表（一我的可能有一個辦公室電話和一個家裏電話號碼）
第二範式的定義：假設一個表屬於1NF。不論什麼屬性僅僅依賴於keyword。則這個表屬於第二範式（常記成2NF ）。簡而言之：必須先符合1NF的條件，且每一行都能被惟一的識別。 將1NF轉換成2NF的方法是加入主鍵。
學號,課程名,成績
第三範式的定義：假設一個表屬於2NF，且不包括傳遞依賴性，則這個表是第三範式（常記成3NF）。知足3NF的表中不包括傳遞依賴。
簡而言之：沒有一個非關鍵屬性依賴於還有一個非關鍵屬性。
學號，課程號，成績，學分學號，姓名。所在系，系名稱，系地址1、鏈接各類數據庫方式速查表
如下羅列了各類數據庫使用JDBC鏈接的方式，可以做爲一個手冊使用。
一、Oracle8/8i/9i數據庫（thin模式）
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
Stringurl="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl爲數據庫的SID
Stringuser="test";
Stringpassword="test";
Connection conn=DriverManager.getConnection(url,user,password);
二、DB2數據庫
Class.forName("com.ibm.db2.jdbc.app.DB2Driver").newInstance();
Stringurl="jdbc:db2://localhost:5000/sample"; //sample爲你的數據庫名
Stringuser="admin";
Stringpassword="";
Connection conn=DriverManager.getConnection(url,user,password);
三、SqlServer7.0/2000數據庫
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
Stringurl="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
//mydb爲數據庫
Stringuser="sa";
Stringpassword="";
Connection conn=DriverManager.getConnection(url,user,password);
四、Sybase數據庫
Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url ="jdbc:sybase:Tds:localhost:5007/myDB";//myDB爲你的數據庫名
PropertiessysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn=DriverManager.getConnection(url, SysProps);
五、Informix數據庫
Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url =
"jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword";//myDB爲數據庫名
Connection conn=DriverManager.getConnection(url);
六、MySQL數據庫
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url="jdbc:mysql://localhost/myDB?
user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//myDB爲數據庫名
Connection conn=DriverManager.getConnection(url);
七、PostgreSQL數據庫
Class.forName("org.postgresql.Driver").newInstance();
String url="jdbc:postgresql://localhost/myDB" //myDB爲數據庫名
Stringuser="myuser";
Stringpassword="mypassword";
Connection conn=DriverManager.getConnection(url,user,password);
八、access數據庫直連用ODBC的
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Stringurl="jdbc:odbc:Driver={MicroSoft Access Driver(*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb");
Connection conn =DriverManager.getConnection(url,"","");
Statement stmtNew=conn.createStatement() ;
- 1. Java面試題--java基礎
- 2. java基礎面試題
- 3. Java基礎面試題(1)
- 4. Java基礎面試題(一)
- 5. 面試題—java基礎
- 6. JAVA基礎面試題
- 7. Java 基礎面試題
- 8. Java基礎之面試題
- 9. Java面試題基礎
- 10. Java基礎面試題
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • ☆基於Java Instrument的Agent實現
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. python的安裝和Hello，World編寫
- 2. 重磅解讀：K8s Cluster Autoscaler模塊及對應華爲雲插件Deep Dive
- 3. 鴻蒙學習筆記2（永不斷更）
- 4. static關鍵字 和構造代碼塊
- 5. JVM筆記
- 6. 無法啓動 C/C++ 語言服務器。IntelliSense 功能將被禁用。錯誤: Missing binary at c:\Users\MSI-NB\.vscode\extensions\ms-vsc
- 7. 【Hive】Hive返回碼狀態含義
- 8. Java樹形結構遞歸（以時間換空間）和非遞歸（以空間換時間）
- 9. 數據預處理---缺失值
- 10. 都要2021年了，現代C++有什麼值得我們學習的？
- 1. Java面試題--java基礎
- 2. java基礎面試題
- 3. Java基礎面試題(1)
- 4. Java基礎面試題(一)
- 5. 面試題—java基礎
- 6. JAVA基礎面試題
- 7. Java 基礎面試題
- 8. Java基礎之面試題
- 9. Java面試題基礎
- 10. Java基礎面試題