18、Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?
Overload是重載的意思，Override是覆蓋的意思，也就是重寫。
重載Overload表示同一個類中可以有多個名稱相同的方法，但這些方法的參數列表各不相同（即參數個數或類型不同）。
重寫Override表示子類中的方法可以與父類中的某個方法的名稱和參數完全相同，通過子類創建的實例對象調用這個方法時，將調用子類中的定義方法，這相當於把父類中定義的那個完全相同的方法給覆蓋了，這也是面向對象編程的多態性的一種表現。子類覆蓋父類的方法時，只能比父類拋出更少的異常，或者是拋出父類拋出的異常的子異常，因爲子類可以解決父類的一些問題，不能比父類有更多的問題。子類方法的訪問權限只能比父類的更大，不能更小。如果父類的方法是private類型，那麼，子類則不存在覆蓋的限制，相當於子類中增加了一個全新的方法。
至於Overloaded的方法是否可以改變返回值的類型這個問題，要看你倒底想問什麼呢？這個題目很模糊。如果幾個Overloaded的方法的參數列表不一樣，它們的返回者類型當然也可以不一樣。但我估計你想問的問題是：如果兩個方法的參數列表完全一樣，是否可以讓它們的返回值不同來實現重載Overload。這是不行的，我們可以用反證法來說明這個問題，因爲我們有時候調用一個方法時也可以不定義返回結果變量，即不要關心其返回結果，例如，我們調用map.remove(key)方法時，雖然remove方法有返回值，但是我們通常都不會定義接收返回結果的變量，這時候假設該類中有兩個名稱和參數列表完全相同的方法，僅僅是返回類型不同，java
就無法確定編程者倒底是想調用哪個方法了，因爲它無法通過返回結果類型來判斷。
override可以翻譯爲覆蓋，從字面就可以知道，它是覆蓋了一個方法並且對其重寫，以求達到不同的作用。對我們來說最熟悉的覆蓋就是對接口方法的實現，在接口中一般只是對方法進行了聲明，而我們在實現時，就需要實現接口聲明的所有方法。除了這個典型的用法以外，我們在繼承中也可能會在子類覆蓋父類中的方法。在覆蓋要注意以下的幾點：
1、覆蓋的方法的標誌必須要和被覆蓋的方法的標誌完全匹配，才能達到覆蓋的效果；
2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；
3、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；
4、被覆蓋的方法不能爲private，否則在其子類中只是新定義了一個方法，並沒有對其進行覆蓋。
overload對我們來說可能比較熟悉，可以翻譯爲重載，它是指我們可以定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然後再調用時，VM就會根據不同的參數樣式，來選擇合適的方法執行。在使用重載要注意以下的幾點：
1、在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序（當然，同一方法內的幾個參數類型必須不一樣，例如可以是fun(int,float)，但是不能爲fun(int,int)）；
2、不能通過訪問權限、返回類型、拋出的異常進行重載；
3、方法的異常類型和數目不會對重載造成影響；
4、對於繼承來說，如果某一方法在父類中是訪問權限是priavte，那麼就不能在子類對其進行重載，如果定義的話，也只是定義了一個新方法，而不會達到重載的效果。
19、構造器Constructor是否可被override?
構造器Constructor不能被繼承，因此不能重寫Override，但可以被重載Overload。
20、接口是否可繼承接口?抽象類是否可實現(implements)接口?抽象類是否可繼承具體類(concrete class)?抽象類中是否可以有靜態的main方法？
接口可以繼承接口。抽象類可以實現(implements)接口，抽象類可以繼承具體類。抽象類中可以有靜態的main方法。
備註：只要明白了接口和抽象類的本質和作用，這些問題都很好回答，你想想，如果你是java語言的設計者，你是否會提供這樣的支持，如果不提供的話，有什麼理由嗎？如果你沒有道理不提供，那答案就是肯定的了。
只有記住抽象類與普通類的唯一區別：就是不能創建實例對象和允許有abstract方法。
21、寫clone()方法時，通常都有一行代碼，是什麼？
clone 有缺省行爲，
super.clone();
因爲首先要把父類中的成員複製到位，然後纔是複製自己的成員。
22、面向對象的特徵有哪些方面
計算機軟件系統是現實生活中的業務在計算機中的映射，而現實生活中的業務其實就是一個個對象協作的過程。面向對象編程就是按現實業務一樣的方式將程序代碼按一個個對象進行組織和編寫，讓計算機系統能夠識別和理解用對象方式組織和編寫的程序代碼，這樣就可以把現實生活中的業務對象映射到計算機系統中。
面向對象的編程語言有，嗎等4個主要的特徵。
封裝：
封裝是保證軟件部件具有優良的模塊性的基礎，封裝的目標就是要實現軟件部件的“高內聚、低耦合”，防止程序相互依賴性而帶來的變動影響。在面向對象的編程語言中，對象是封裝的最基本單位，面向對象的封裝比傳統語言的封裝更爲清晰、更爲有力。面向對象的封裝就是把描述一個對象的屬性和行爲的代碼封裝在一個“模塊”中，也就是一個類中，屬性用變量定義，行爲用方法進行定義，方法可以直接訪問同一個對象中的屬性。通常情況下，只要記住讓變量和訪問這個變量的方法放在一起，將一個類中的成員變量全部定義成私有的，只有這個類自己的方法纔可以訪問到這些成員變量，這就基本上實現對象的封裝，就很容易找出要分配到這個類上的方法了，就基本上算是會面向對象的編程了。把握一個原則：把對同一事物進行操作的方法和相關的方法放在同一個類中，把方法和它操作的數據放在同一個類中。
例如，人要在黑板上畫圓，這一共涉及三個對象：人、黑板、圓，畫圓的方法要分配給哪個對象呢？由於畫圓需要使用到圓心和半徑，圓心和半徑顯然是圓的屬性，如果將它們在類中定義成了私有的成員變量，那麼，畫圓的方法必須分配給圓，它才能訪問到圓心和半徑這兩個屬性，人以後只是調用圓的畫圓方法、表示給圓發給消息而已，畫圓這個方法不應該分配在人這個對象上，這就是面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態（屬性）由這個對象自己的行爲（方法）來讀取和改變。一個更便於理解的例子就是，司機將火車剎住了，剎車的動作是分配給司機，還是分配給火車，顯然，應該分配給火車，因爲司機自身是不可能有那麼大的力氣將一個火車給停下來的，只有火車自己才能完成這一動作，火車需要調用內部的離合器和剎車片等多個器件協作才能完成剎車這個動作，司機剎車的過程只是給火車發了一個消息，通知火車要執行剎車動作而已。
抽象：
抽象就是找出一些事物的相似和共性之處，然後將這些事物歸爲一個類，這個類只考慮這些事物的相似和共性之處，並且會忽略與當前主題和目標無關的那些方面，將注意力集中在與當前目標有關的方面。例如，看到一隻螞蟻和大象，你能夠想象出它們的相同之處，那就是抽象。抽象包括行爲抽象和狀態抽象兩個方面。例如，定義一個Person類，如下：
classPerson{
String name;
int age;
}
人本來是很複雜的事物，有很多方面，但因爲當前系統只需要瞭解人的姓名和年齡，所以上面定義的類中只包含姓名和年齡這兩個屬性，這就是一種抽像，使用抽象可以避免考慮一些與目標無關的細節。我對抽象的理解就是不要用顯微鏡去看一個事物的所有方面，這樣涉及的內容就太多了，而是要善於劃分問題的邊界，當前系統需要什麼，就只考慮什麼。
繼承：
在定義和實現一個類的時候，可以在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容作爲自己的內容，並可以加入若干新的內容，或修改原來的方法使之更適合特殊的需要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關係，提高了軟件的可重用性和可擴展性。
多態：
多態是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時並不確定，而是在程序運行期間才確定，即一個引用變量倒底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因爲在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。多態性增強了軟件的靈活性和擴展性。例如，下面代碼中的UserDao是一個接口，它定義引用變量userDao指向的實例對象由daofactory.getDao()在執行的時候返回，有時候指向的是UserJdbcDao這個實現，有時候指向的是UserHibernateDao這個實現，這樣，不用修改源代碼，就可以改變userDao指向的具體類實現，從而導致userDao.insertUser()方法調用的具體代碼也隨之改變，即有時候調用的是UserJdbcDao的insertUser
方法，有時候調用的是UserHibernateDao的insertUser 方法：
UserDao userDao =daofactory.getDao();
userDao.insertUser(user);
比喻：人吃飯，你看到的是左手，還是右手？
23、java中實現多態的機制是什麼？
靠的是父類或接口定義的引用變量可以指向子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。
24、abstract class和interface有什麼區別?
含有abstract修飾符的class即爲抽象類，abstract類不能創建的實例對象。含有abstract方法的類必須定義爲abstract class，abstract class類中的方法不必是抽象的。abstract class類中定義抽象方法必須在具體(Concrete)子類中實現，所以，不能有抽象構造方法或抽象靜態方法。如果的子類沒有實現抽象父類中的所有抽象方法，那麼子類也必須定義爲abstract類型。
接口（interface）可以說成是抽象類的一種特例，接口中的所有方法都必須是抽象的。接口中的方法定義默認爲public abstract類型，接口中的成員變量類型默認爲public static final。
下面比較一下兩者的語法區別：
1.抽象類可以有構造方法，接口中不能有構造方法。
2.抽象類中可以有普通成員變量，接口中沒有普通成員變量
3.抽象類中可以包含非抽象的普通方法，接口中的所有方法必須都是抽象的，不能有非抽象的普通方法。
4. 抽象類中的抽象方法的訪問類型可以是public，protected和（默認類型,雖然eclipse下不報錯，但應該也不行），但接口中的抽象方法只能是public 類型的，並且默認即爲public abstract類型。
5. 抽象類中可以包含靜態方法，接口中不能包含靜態方法
6. 抽象類和接口中都可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型可以任意，但接口中定義的變量只能是public static final類型，並且默認即爲public static final類型。
7. 一個類可以實現多個接口，但只能繼承一個抽象類。
下面接着再說說兩者在應用上的區別：
接口更多的是在系統架構設計方法發揮作用，主要用於定義模塊之間的通信契約。而抽象類在代碼實現方面發揮作用，可以實現代碼的重用，例如，模板方法設計模式是抽象類的一個典型應用，假設某個項目的所有Servlet類都要用相同的方式進行權限判斷、記錄訪問日誌和處理異常，那麼就可以定義一個抽象的基類，讓所有的Servlet都繼承這個抽象基類，在抽象基類的service方法中完成權限判斷、記錄訪問日誌和處理異常的代碼，在各個子類中只是完成各自的業務邏輯代碼，僞代碼如下：
public abstract classBaseServlet extends HttpServlet{
public final void service(HttpServletRequest request,HttpServletResponse
response) throws IOExcetion,ServletException {
記錄訪問日誌
進行權限判斷
if(具有權限){
try{
飛米網—java技術交流 java教程 www.feimy.com
doService(request,response);
}
catch(Excetpion e) {
記錄異常信息
}
}
}
protected abstract void doService(HttpServletRequest
request,HttpServletResponse response) throws IOExcetion,ServletException;
//注意訪問權限定義成protected，顯得既專業，又嚴謹，因爲它是專門給子類用的
}
public class MyServlet1 extendsBaseServlet
{
protected voiddoService(HttpServletRequest request, HttpServletResponse response)
throwsIOExcetion,ServletException
{
本Servlet只處理的具體業務邏輯代碼
}
}
父類方法中間的某段代碼不確定，留給子類幹，就用模板方法設計模式。
備註：這道題的思路是先從總體解釋抽象類和接口的基本概念，然後再比較兩者的語法細節，最後再說兩者的應用區別。比較兩者語法細節區別的條理是：先從一個類中的構造方法、普通成員變量和方法（包括抽象方法），靜態變量和方法，繼承性等6個方面逐一去比較回答，接着從第三者繼承的角度的回答，特別是最後用了一個典型的例子來展現自己深厚的技術功底。
25、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
abstract的method不可以是static的，因爲抽象的方法是要被子類實現的，而static與子類扯不上關係！
native方法表示該方法要用另外一種依賴平臺的編程語言實現的，不存在着被子類實現的問題，所以，它也不能是抽象的，不能與abstract混用。例如，FileOutputSteam類要硬件打交道，底層的實現用的是操作系統相關的api實現，例如，在windows用c語言實現的，所以，查看jdk 的源代碼，可以發現FileOutputStream的open方法的定義如下：
private native void open(Stringname) throws FileNotFoundException;
如果我們要用java 調用別人寫的c語言函數，我們是無法直接調用的，我們需要按照java的要求寫一個c語言的函數，又我們的這個c語言函數去調用別人的c語言函數。由於我們
的c語言函數是按java 的要求來寫的，我們這個c語言函數就可以與java 對接上，java 那邊的對接方式就是定義出與我們這個c函數相對應的方法，java 中對應的方法不需要寫具
體的代碼，但需要在前面聲明native。
關於synchronized與abstract合用的問題，我覺得也不行，因爲在我幾年的學習和開發中，從來沒見到過這種情況，並且我覺得synchronized應該是作用在一個具體的方法上纔有意義。而且，方法上的synchronized同步所使用的同步鎖對象是this，而抽象方法上無法確定this是什麼。
26、什麼是內部類？Static Nested Class和Inner Class的不同。
內部類就是在一個類的內部定義的類，內部類中不能定義靜態成員（靜態成員不是對象的特性，只是爲了找一個容身之處，所以需要放到一個類中而已，這麼一點小事，你還要把它放到類內部的一個類中，過分了啊！提供內部類，不是爲讓你幹這種事情，無聊，不讓你幹。我想可能是既然靜態成員類似c語言的全局變量，而內部類通常是用於創建內部對象用的，所以，把“全局變量”放在內部類中就是毫無意義的事情，既然是毫無意義的事情，就應該被禁止），內部類可以直接訪問外部類中的成員變量，內部類可以定義在外部類的方法外面，也可以定義在外部類的方法體中，如下所示：
public class Outer
{
int out_x = 0;
public void method()
{
Inner1 inner1 = new Inner1();
public class Inner2 //在方法體內部定義的內部類
{
public method()
{
out_x = 3;
}
}
Inner2 inner2 = new Inner2();
}
public class Inner1 //在方法體外面定義的內部類
{
}
}
在方法體外面定義的內部類的訪問類型可以是public,protecte,默認的，private等4種類型，這就好像類中定義的成員變量有4種訪問類型一樣，它們決定這個內部類的定義對其他類是否可見；對於這種情況，我們也可以在外面創建內部類的實例對象，創建內部類的實例對象時，一定要先創建外部類的實例對象，然後用這個外部類的實例對象去創建內部類的實例對象，代碼如下：
Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Innner1();
在方法內部定義的內部類前面不能有訪問類型修飾符，就好像方法中定義的局部變量一樣，但這種內部類的前面可以使用final或abstract修飾符。這種內部類對其他類是不可見的其他類無法引用這種內部類，但是這種內部類創建的實例對象可以傳遞給其他類訪問。這種內部類必須是先定義，後使用，即內部類的定義代碼必須出現在使用該類之前，這與方法中的局部變量必須先定義後使用的道理也是一樣的。這種內部類可以訪問方法體中的局部變量，但是，該局部變量前必須加final修飾符。對於這些細節，只要在eclipse寫代碼試試，根據開發工具提示的各類錯誤信息就可以馬上瞭解到。在方法體內部還可以採用如下語法來創建一種匿名內部類，即定義某一接口或類的子類的同時，還創建了該子類的實例對象，無需爲該子類定義名稱：
public class Outer
{
public void start()
{
new Thread(
new Runable(){
public void run(){};
}
).start();
}
}
最後，在方法外部定義的內部類前面可以加上static關鍵字，從而成爲Static Nested Class，它不再具有內部類的特性，所有，從狹義上講，它不是內部類。Static Nested Class與普通類在運行時的行爲和功能上沒有什麼區別，只是在編程引用時的語法上有一些差別，它可以定義成public、protected、默認的、private等多種類型，而普通類只能定義成public和默認的這兩種類型。在外面引用Static Nested Class類的名稱爲“外部類名.內部類名”。在外面不需要創建外部類的實例對象，就可以直接創建Static
Nested Class，例如，假設Inner是定義在Outer類中的Static Nested Class，那麼可以使用如下語句創建Inner類：
Outer.Inner inner = newOuter.Inner();
由於static Nested Class不依賴於外部類的實例對象，所以，static Nested Class能訪問外部類的非static成員變量(不能直接訪問，需要創建外部類實例才能訪問非靜態變量)。當在外部類中訪問Static Nested Class時，可以直接使用Static Nested Class的名字，而不需要加上外部類的名字了，在Static Nested Class中也可以直接引用外部類的static的成員變量，不需要加上外部類的名字。在靜態方法中定義的內部類也是Static Nested
Class，這時候不能在類前面加static關鍵字，靜態方法中的Static Nested Class與普通方法中的內部類的應用方式很相似，它除了可以直接訪問外部類中的static的成員變量，還可以訪問靜態方法中的局部變量，但是，該局部變量前必須加final修飾符。
備註：首先根據你的印象說出你對內部類的總體方面的特點：例如，在兩個地方可以定義，可以訪問外部類的成員變量，不能定義靜態成員，這是大的特點。然後再說一些細節方面的知識，例如，幾種定義方式的語法區別，靜態內部類，以及匿名內部類。
27、內部類可以引用它的包含類的成員嗎？有沒有什麼限制？
完全可以。如果不是靜態內部類，那沒有什麼限制！如果你把靜態嵌套類當作內部類的一種特例，那在這種情況下不可以訪問外部類的普通成員變量，而只能訪問外部類中的靜態成員，例如，下面的代碼：
class Outer
{
static int x;
static class Inner
{
void test()
{
syso(x);
}
}
}
答題時，也要能察言觀色，揣摩提問者的心思，顯然人家希望你說的是靜態內部類不能訪問外部類的成員，但你一上來就頂牛，這不好，要先順着人家，讓人家滿意，然後再說特殊情況，讓人家吃驚。
28、Anonymous Inner Class (匿名內部類)是否可以extends(繼承)其它類，是否可以implements(實現)interface(接口)?
可以繼承其他類或實現其他接口。不僅是可以，而是必須!
29、super.getClass()方法調用下面程序的輸出結果是多少？
importjava.util.Date;
public class Test extends Date{
public static void main(String[] args) {
new Test().test();
}
public void test(){
System.out.println(super.getClass().getName());
}
}
很奇怪，結果是Te s t
這屬於腦筋急轉彎的題目，在一個qq羣有個網友正好問過這個問題，我覺得挺有趣，就研究了一下，沒想到今天還被你面到了，哈哈。
在test方法中，直接調用getClass().getName()方法，返回的是Te s t類名由於getClass()在Object類中定義成了final，子類不能覆蓋該方法，所以，在test方法中調用getClass().getName()方法，其實就是在調用從父類繼承的getClass()方法，等效於調用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也應該是Te s t。如果想得到父類的名稱，應該用如下代碼：getClass().getSuperClass().getName();
30、String是最基本的數據類型嗎?
基本數據類型包括byte、int、char、long、float、double、boolean和short。
java.lang.String 類是final類型的，因此不可以繼承這個類、不能修改這個類。爲了提高效率節省空間，我們應該用StringBuffer類
31、String s = "Hello";s = s + " world!";這兩行代碼執行後，原始的String對象中的內容到底變了沒有？
沒有。因爲String被設計成不可變(immutable)類，所以它的所有對象都是不可變對象。在這段代碼中，s原先指向一個String對象，內容是 "Hello"，然後我們對s進行了+操作，那麼s所指向的那個對象是否發生了改變呢？答案是沒有。這時，s不指向原來那個對象了，而指向了另一個 String對象，內容爲"Hello world!"，原來那個對象還存在於內存之中，只是s這個引用變量不再指向它了。
通過上面的說明，我們很容易導出另一個結論，如果經常對字符串進行各種各樣的修改，或者說，不可預見的修改，那麼使用String來代表字符串的話會引起很大的內存開銷。因爲String對象建立之後不能再改變，所以對於每一個不同的字符串，都需要一個String對象來表示。這時，應該考慮使用StringBuffer類，它允許修改，而不是每個不同的字符串都要生成一個新的對象。並且，這兩種類的對象轉換十分容易。同時，我們還可以知道，如果要使用內容相同的字符串，不必每次都new一個String。例如我們要在構造器中對一個名叫s的String引用變量進行初始化，把它設置爲初始值，應當這樣做：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
後者每次都會調用構造器，生成新對象，性能低下且內存開銷大，並且沒有意義，因爲String對象不可改變，所以對於內容相同的字符串，只要一個String對象來表示就可以了。也就說，多次調用上面的構造器創建多個對象，他們的String類型屬性s都指向同一個對象。上面的結論還基於這樣一個事實：對於字符串常量，如果內容相同，Java認爲它們代表同一個String對象。而用關鍵字new調用構造器，總是會創建一個新的對象，無論內容是否相同。
至於爲什麼要把String類設計成不可變類，是它的用途決定的。其實不只String，很 多Java標準類庫中的類都是不可變的。在開發一個系統的時候，我們有時候也需要設計不可變類，來傳遞一組相關的值，這也是面向對象思想的體現。不可變類有一些優點，比如因爲它的對象是隻讀的，所以多線程併發訪問也不會有任何問題。當然也有一些缺點，比如每個不同的狀態都要一個對象來代表，可能會造成性能上的問題。所以Java標準類庫還提供了一個可變版本，即 StringBuffer。
32、是否可以繼承String類?
String類是final類故不可以繼承。
33、String s = new String("xyz");創建了幾個String Object?二者之間有什麼區別？
兩個或一個，”xyz”對應一個對象，這個對象放在字符串常量緩衝區，常量”xyz”不管出現多少遍，都是緩衝區中的那一個。New String每寫一遍，就創建一個新的對象，它一句那個常量”xyz”對象的內容來創建出一個新String對象。如果以前就用過’xyz’，這句代表就不會創建”xyz”自己了，直接從緩衝區拿。
34、String和StringBuffer的區別
JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數據。這個String類提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就可以使用StringBuffer。典型地，你可以使用StringBuffers來動態構造字符數據。另外，String實現了equals方法，new String(“abc”).equals(newString(“abc”)的結果爲true,而StringBuffer沒有實現equals方法，所以，new
StringBuffer(“abc”).equals(newStringBuffer(“abc”)的結果爲false。
接着要舉一個具體的例子來說明，我們要把1到100的所有數字拼起來，組成一個串。
StringBuffer sbf = new StringBuffer();
for(int i=0;i<100;i++)
{
sbf.append(i);
}
上面的代碼效率很高，因爲只創建了一個StringBuffer對象，而下面的代碼效率很低，因爲創建了101個對象。
String str = new String();
for(int i=0;i<100;i++)
{
str = str + i;
}
在講兩者區別時，應把循環的次數搞成10000，然後用endTime-beginTime來比較兩者執行的時間差異，最後還要講講StringBuilder與StringBuffer的區別。
1. 在執行速度方面的比較：StringBuilder > StringBuffer
2. StringBuffer與StringBuilder，他們是字符串變量，是可改變的對象，每當我們用它們對字符串做操作時，實際上是在一個對象上操作的，不像String一樣創建一些對象進行操作，所以速度就快了。
3. StringBuilder：線程非安全的
StringBuffer：線程安全的
當我們在字符串緩衝去被多個線程使用是，JVM不能保證StringBuilder的操作是安全的，雖然他的速度最快，但是可以保證StringBuffer是可以正確操作的。當然大多數情況下就是我們是在單線程下進行的操作，所以大多數情況下是建議用StringBuilder而不用StringBuffer的，就是速度的原因。
對於三者使用的總結：1.如果要操作少量的數據用 = String
2.單線程操作字符串緩衝區 下操作大量數據 = StringBuilder
3.多線程操作字符串緩衝區 下操作大量數據 = StringBuffer
String覆蓋了equals方法和hashCode方法，而StringBuffer沒有覆蓋equals方法和hashCode方法，所以，將StringBuffer對象存儲進Java集合類中時會出現問題。
35、如何把一段逗號分割的字符串轉換成一個數組?
如果不查jdk api，我很難寫出來！我可以說說我的思路：
1 用正則表達式，代碼大概爲：String [] result = orgStr.split(“,”);
2 用 StingTokenizer ,代碼爲：StringTokenizer tokener =
StringTokenizer(orgStr,”,”);
String [] result =new String[tokener .countTokens()];
Int i=0;
while(tokener.hasNext(){result[i++]=toker.nextToken();}
36、數組有沒有length()這個方法? String有沒有length()這個方法？
數組沒有length()這個方法，有length 的屬性。String有有length()這個方法。
37、下面這條語句一共創建了多少個對象：String s="a"+"b"+"c"+"d";
答：對於如下代碼：
String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
System.out.println(s2 == "ab");
System.out.println(s3 == "ab");
第一條語句打印的結果爲false，第二條語句打印的結果爲true，這說明javac 編譯可以對字符串常量直接相加的表達式進行優化，不必要等到運行期去進行加法運算處理，而是在編譯時去掉其中的加號，直接將其編譯成一個這些常量相連的結果。題目中的第一行代碼被編譯器在編譯時優化後，相當於直接定義了一個”abcd”的字符串，所以，上面的代碼應該只創建了一個String對象。寫如下兩行代碼，
String s ="a" + "b" + "c" + "d";
System.out.println(s== "abcd");
最終打印的結果應該爲true。