2019年最新50道java基礎部分面試題（三）

2二、面向對象的特徵有哪些方面
計算機軟件系統是現實生活中的業務在計算機中的映射，而現實生活中的業務其實就是一個個對象協做的過程。面向對象編程就是按現實業務同樣的方式將程序代碼按一個個對象進行組織和編寫，讓計算機系統可以識別和理解用對象方式組織和編寫的程序代碼，這樣就能夠把現實生活中的業務對象映射到計算機系統中。
面向對象的編程語言有封裝、繼承 、抽象、多態等4個主要的特徵。
1封裝：
封裝是保證軟件部件具備優良的模塊性的基礎，封裝的目標就是要實現軟件部件的「高內聚、低耦合」，防止程序相互依賴性而帶來的變更影響。在面向對象的編程語言中，對象是封裝的最基本單位，面向對象的封裝比傳統語言的封裝更爲清晰、更爲有力。面向對象的封裝就是把描述一個對象的屬性和行爲的代碼封裝在一個「模塊」中，也就是一個類中，屬性用變量定義，行爲用方法進行定義，方法能夠直接訪問同一個對象中的屬性。一般狀況下，只要記住讓變量和訪問這個變量的方法放在一塊兒，將一個類中的成員變量所有定義成私有的，只有這個類本身的方法才能夠訪問到這些成員變量，這就基本上實現對象的封裝，就很容易找出要分配到這個類上的方法了，就基本上算是會面向對象的編程了。把握一個原則：把對同一事物進行操做的方法和相關的方法放在同一個類中，把方法和它操做的數據放在同一個類中。
例如，人要在黑板上畫圓，這一共涉及三個對象：人、黑板、圓，畫圓的方法要分配給哪一個對象呢？因爲畫圓須要使用到圓心和半徑，圓心和半徑顯然是圓的屬性，若是將它們在類中定義成了私有的成員變量，那麼，畫圓的方法必須分配給圓，它才能訪問到圓心和半徑這兩個屬性，人之後只是調用圓的畫圓方法、表示給圓發給消息而已，畫圓這個方法不該該分配在人這個對象上，這就是面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態（屬性）由這個對象本身的行爲（方法）來讀取和改變。一個更便於理解的例子就是，司機將火車剎住了，剎車的動做是分配給司機，仍是分配給火車，顯然，應該分配給火車，由於司機自身是不可能有那麼大的力氣將一個火車給停下來的，只有火車本身才能完成這一動做，火車須要調用內部的離合器和剎車片等多個器件協做才能完成剎車這個動做，司機剎車的過程只是給火車發了一個消息，通知火車要執行剎車動做而已。

抽象：
抽象就是找出一些事物的類似和共性之處，而後將這些事物歸爲一個類，這個類只考慮這些事物的類似和共性之處，而且會忽略與當前主題和目標無關的那些方面，將注意力集中在與當前目標有關的方面。例如，看到一隻螞蟻和大象，你可以想象出它們的相同之處，那就是抽象。抽象包括行爲抽象和狀態抽象兩個方面。例如，定義一個Person類，以下：
class Person{
String name;
int age;
}
人原本是很複雜的事物，有不少方面，但由於當前系統只須要了解人的姓名和年齡，因此上面定義的類中只包含姓名和年齡這兩個屬性，這就是一種抽像，使用抽象能夠避免考慮一些與目標無關的細節。我對抽象的理解就是不要用顯微鏡去看一個事物的全部方面，這樣涉及的內容就太多了，而是要善於劃分問題的邊界，當前系統須要什麼，就只考慮什麼。

繼承：
在定義和實現一個類的時候，能夠在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容做爲本身的內容，並能夠加入若干新的內容，或修改原來的方法使之更適合特殊的須要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關係，提升了軟件的可重用性和可擴展性。

多態：
多態是指程序中定義的引用變量所指向的具體類型和經過該引用變量發出的方法調用在編程時並不肯定，而是在程序運行期間才肯定，即一個引用變量倒底會指向哪一個類的實例對象，該引用變量發出的方法調用究竟是哪一個類中實現的方法，必須在由程序運行期間才能決定。由於在程序運行時才肯定具體的類，這樣，不用修改源程序代碼，就可讓引用變量綁定到各類不一樣的類實現上，從而致使該引用調用的具體方法隨之改變，即不修改程序代碼就能夠改變程序運行時所綁定的具體代碼，讓程序能夠選擇多個運行狀態，這就是多態性。多態性加強了軟件的靈活性和擴展性。例如，下面代碼中的UserDao是一個接口，它定義引用變量userDao指向的實例對象由daofactory.getDao()在執行的時候返回，有時候指向的是UserJdbcDao這個實現，有時候指向的是UserHibernateDao這個實現，這樣，不用修改源代碼，就能夠改變userDao指向的具體類實現，從而致使userDao.insertUser()方法調用的具體代碼也隨之改變，即有時候調用的是UserJdbcDao的insertUser方法，有時候調用的是UserHibernateDao的insertUser方法：
UserDao userDao = daofactory.getDao();
userDao.insertUser(user);

比喻：人吃飯，你看到的是左手，仍是右手？
2三、java中實現多態的機制是什麼？
靠的是父類或接口定義的引用變量能夠指向子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。
2四、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 class BaseServlet extends HttpServlet{
   public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException {
   記錄訪問日誌
   進行權限判斷
   if(具備權限){
   try{
   doService(request,response);
   }
   catch(Excetpion e) {
   記錄異常信息
   }
   }
   }
   protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException;
   //注意訪問權限定義成protected，顯得既專業，又嚴謹，由於它是專門給子類用的
   }

public class MyServlet1 extends BaseServlet
{
protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException
{
本Servlet只處理的具體業務邏輯代碼
}

}
父類方法中間的某段代碼不肯定，留給子類幹，就用模板方法設計模式。
備註：這道題的思路是先從整體解釋抽象類和接口的基本概念，而後再比較二者的語法細節，最後再說二者的應用區別。比較二者語法細節區別的條理是：先從一個類中的構造方法、普通成員變量和方法（包括抽象方法），靜態變量和方法，繼承性等6個方面逐一去比較回答，接着從第三者繼承的角度的回答，特別是最後用了一個典型的例子來展示本身深厚的技術功底。
2五、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
abstract的method 不能夠是static的，由於抽象的方法是要被子類實現的，而static與子類扯不上關係！
native方法表示該方法要用另一種依賴平臺的編程語言實現的，不存在着被子類實現的問題，因此，它也不能是抽象的，不能與abstract混用。例如，FileOutputSteam類要硬件打交道，底層的實現用的是操做系統相關的api實現，例如，在windows用c語言實現的，因此，查看jdk 的源代碼，能夠發現FileOutputStream的open方法的定義以下：
private native void open(String name) throws FileNotFoundException;
若是咱們要用java調用別人寫的c語言函數，咱們是沒法直接調用的，咱們須要按照java的要求寫一個c語言的函數，又咱們的這個c語言函數去調用別人的c語言函數。因爲咱們的c語言函數是按java的要求來寫的，咱們這個c語言函數就能夠與java對接上，java那邊的對接方式就是定義出與咱們這個c函數相對應的方法，java中對應的方法不須要寫具體的代碼，但須要在前面聲明native。
關於synchronized與abstract合用的問題，我以爲也不行，由於在我幾年的學習和開發中，歷來沒見到過這種狀況，而且我以爲synchronized應該是做用在一個具體的方法上纔有意義。並且，方法上的synchronized同步所使用的同步鎖對象是this，而抽象方法上沒法肯定this是什麼。
2六、什麼是內部類？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 = new Outer.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修飾符。

備註：首先根據你的印象說出你對內部類的整體方面的特色：例如，在兩個地方能夠定義，能夠訪問外部類的成員變量，不能定義靜態成員，這是大的特色。而後再說一些細節方面的知識，例如，幾種定義方式的語法區別，靜態內部類，以及匿名內部類。
2七、內部類能夠引用它的包含類的成員嗎？有沒有什麼限制？
徹底能夠。若是不是靜態內部類，那沒有什麼限制！
若是你把靜態嵌套類看成內部類的一種特例，那在這種狀況下不能夠訪問外部類的普通成員變量，而只能訪問外部類中的靜態成員，例如，下面的代碼：
class Outer
{
static int x;
static class Inner
{
void test()
{
syso(x);
}
}
}

答題時，也要能察言觀色，揣摩提問者的心思，顯然人家但願你說的是靜態內部類不能訪問外部類的成員，但你一上來就頂牛，這很差，要先順着人家，讓人家滿意，而後再說特殊狀況，讓人家吃驚。

2八、Anonymous Inner Class (匿名內部類) 是否能夠extends(繼承)其它類，是否能夠implements(實現)interface(接口)?
能夠繼承其餘類或實現其餘接口。不只是能夠，而是必須!
2九、super.getClass()方法調用
下面程序的輸出結果是多少？
import java.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());
}

}

很奇怪，結果是Test
這屬於腦筋急轉彎的題目，在一個qq羣有個網友正好問過這個問題，我以爲挺有趣，就研究了一下，沒想到今天還被你面到了，哈哈。
在test方法中，直接調用getClass().getName()方法，返回的是Test類名
因爲getClass()在Object類中定義成了final，子類不能覆蓋該方法，因此，在
test方法中調用getClass().getName()方法，其實就是在調用從父類繼承的getClass()方法，等效於調用super.getClass().getName()方法，因此，super.getClass().getName()方法返回的也應該是Test。
若是想獲得父類的名稱，應該用以下代碼：
getClass().getSuperClass().getName();
30、String是最基本的數據類型嗎?
基本數據類型包括byte、int、char、long、float、double、boolean和short。
java.lang.String類是final類型的，所以不能夠繼承這個類、不能修改這個類。爲了提升效率節省空間，咱們應該用StringBuffer類
3一、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。

3二、是否能夠繼承String類?
String類是final類故不能夠繼承。

3三、String s = new String("xyz");建立了幾個String Object? 兩者之間有什麼區別？
兩個或一個，」xyz」對應一個對象，這個對象放在字符串常量緩衝區，常量」xyz」無論出現多少遍，都是緩衝區中的那一個。New String每寫一遍，就建立一個新的對象，它一句那個常量」xyz」對象的內容來建立出一個新String對象。若是之前就用過’xyz’，這句表明就不會建立」xyz」本身了，直接從緩衝區拿。
3四、String 和StringBuffer的區別
JAVA平臺提供了兩個類：String和StringBuffer，它們能夠儲存和操做字符串，即包含多個字符的字符數據。這個String類提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就可使用StringBuffer。典型地，你可使用StringBuffers來動態構造字符數據。另外，String實現了equals方法，new String(「abc」).equals(new String(「abc」)的結果爲true,而StringBuffer沒有實現equals方法，因此，new StringBuffer(「abc」).equals(new StringBuffer(「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的區別。

String覆蓋了equals方法和hashCode方法，而StringBuffer沒有覆蓋equals方法和hashCode方法，因此，將StringBuffer對象存儲進Java集合類中時會出現問題。3五、如何把一段逗號分割的字符串轉換成一個數組?若是不查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();}