java物件導向面試題

來源:互聯網
上載者:User

標籤:物件導向 面試題

面試題目錄:
 
   一、JAVASE常見面試題

         1、 static和final區別?使用final關鍵字修飾一個變數時,
           是引用不能變,還是引用的對象不能變?
         2、 "=="和equals方法究竟有什麼區別?
         3、  靜態變數和執行個體變數的區別?
         4、請說出範圍public,private,protected,以及不寫時的區別
            這四個範圍的可見範圍如下表所示。
         5、Overload和Override的區別。
         6、類有哪三個基本特性?各特性的優點?
         7、java中實現多態的機制是什嗎?
         8、abstract class和interface有什麼區別? 
         9、下面這條語句一共建立了多少個對象:String s="a"+"b"+"c"+"d";
         10、ArrayList和Vector的區別,
             HashMap和Hashtable的區別
         11、談談final, finally, finalize的區別
         12、String,  StringBuffer  StringBuilder的區別。
         13、Collection 和 Collections的區別?
         14、請說出ArrayList,Vector, LinkedList的儲存效能和特性
         15、HashMap和Hashtable的區別?
         16、JAVA語言如何進行異常處理,
            關鍵字:throws,throw,try,catch,finally分別代表什麼意義?
            在try塊中可以拋出異常嗎?
         17、java的8種基本類型
         18、 一個".java"源檔案中是否可以包括多個類(不是內部類)?有什麼限制?
         19、什麼是java序列化,如何?java序列化?或者請解釋Serializable介面的作用。
         20、記憶體回收的優點和原理。並考慮2種回收機制。
         21、java中會存在記憶體泄露嗎?請簡單描述。
         22、請試圖描述java語言中的GC(Gabage Collection)
         23、JDK1.5匯入了一些新的語言特性,
              更有利於代碼的書寫,如支援泛型、
             自動拆/裝箱、增強for迴圈等,請結合代碼給出樣本。
         24、 anonymous Inner Class (匿名內部類)
               是否可以extends(繼承)其它類,是否可以implement
               (實現)interface(介面)?

     
         25、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?
         26、char型變數中能不能存貯一個中文漢字?為什麼?
         27、構造器Constructor是否可被override?
         28、介面是否可繼承介面? 抽象類別是否可實現(implements)介面?
               抽象類別是否可繼承具體類(concrete class)?
               抽象類別中是否可以有靜態main方法?
 
===================一、JAVASE常見面試題==============================

1、 static和final區別?使用final關鍵字修飾一個變數時,
是引用不能變,還是引用的對象不能變?

static和final區別:
static:static 靜態 關鍵字, 修飾: 屬性, 方法, 內部類, 代碼塊
  static修飾的資源屬於類層級, 是全體對象執行個體共用的資源
  (屬性, 方法, 內部類)
 1) 靜態屬性, 使用static修飾的屬性, 是在類的載入期間初始化
  是屬於類的, 全體類的執行個體共用的變數, 使用類名訪問屬性.
    執行個體變數: 屬於對象的屬性.
 2) static 方法, 使用static聲明的方法, 屬於類的方法, 一般
  用來表示工具方法. 在類載入以後就可以自己調用, 不需要建立任何
  類的執行個體.
  Math.sqrt() Math.pow() Math.sin()...
  Integer.toHexString()
 3) 靜態代碼塊,是在類載入期間啟動並執行代碼塊,由於類只載入
 一次,所以靜態代碼塊只執行一次!
 用途不是很常見,一般用來在類載入以後初始化一些靜態資源
 時候使用,如:載入設定檔。
 
 4) 靜態內部類
final: final 最終的
 1) final 修飾的類,不能再被繼承。
 2) final修飾的方法,不能再被覆蓋。
  在實際項目開發中,原則上不允許使用final方法!
 
 3) final 修飾的變數,初始化以後不允許再修改了。
   a final 局部變數
   b final 方法參數
   c final 的成員變數
 4) final static -- Java使用final static修飾的變數作為常量。
    一般要求常量名都有大寫字母。

使用final關鍵字修飾一個變數時,是指引用變數不能變,
引用變數所指向的對象中的內容還是可以改變的。
例如,對於如下語句:
 final StringBuffer a=new StringBuffer("immutable");
執行如下語句將報告編譯期錯誤:
a=new StringBuffer("");
但是,執行如下語句則可以通過編譯:
a.append(" broken!");

有人在定義方法的參數時,可能想採用如下形式來阻止方法內部修改傳進來的參數對象:
 public void method(final  StringBuffer  param){
 }
實際上,這是辦不到的,在該方法內部仍然可以增加如下代碼來修改參數對象:
  param.append("a");

2、 "=="和equals方法究竟有什麼區別?

單獨把一個東西說清楚,然後再說清楚另一個,這樣,它們的區別自然就出來了,混在一起說,則很難說清楚)
==操作符專門用來比較兩個變數的值是否相等,也就是用於比較變數所對應的記憶體中所儲存的數值是否相同,要比較兩個基本類型的資料或兩個引用變數是否相等,只能用==操作符。
如果一個變數指向的資料是物件類型的,那麼,這時候涉及了兩塊記憶體,對象本身佔用一塊記憶體(堆記憶體),變數也佔用一塊記憶體,例如Objet obj = new Object();變數obj是一個記憶體,new Object()是另一個記憶體,此時,變數obj所對應的記憶體中儲存的數值就是對象佔用的那塊記憶體的首地址。對於指向物件類型的變數,如果要比較兩個變數是否指向同一個對象,即要看這兩個變數所對應的記憶體中的數值是否相等,這時候就需要用==操作符進行比較。
equals方法是用於比較兩個獨立對象的內容是否相同,就好比去比較兩個人的長相是否相同,它比較的兩個對象是獨立的。例如,對於下面的代碼:
String a=new String("foo");
String b=new String("foo");
兩條new語句建立了兩個對象,然後用a,b這兩個變數分別指向了其中一個對象,這是兩個不同的對象,它們的首地址是不同的,即a和b中儲存的數值是不相同的,所以,運算式a==b將返回false,而這兩個對象中的內容是相同的,所以,運算式a.equals(b)將返回true。

如果一個類沒有自己定義equals方法,那麼它將繼承Object類的equals方法,Object類的equals方法的實現代碼如下:
boolean equals(Object o){
return this==o;
}
這說明,如果一個類沒有自己定義equals方法,它預設的equals方法(從Object 類繼承的)就是使用==操作符,也是在比較兩個變數指向的對象是否是同一對象,這時候使用equals和使用==會得到同樣的結果,如果比較的是兩個獨立的對象則總返回false。如果你編寫的類希望能夠比較該類建立的兩個執行個體對象的內容是否相同,那麼你必須覆蓋equals方法,由你自己寫代碼來決定在什麼情況即可認為兩個對象的內容是相同的。


3、  靜態變數和執行個體變數的區別?
在文法定義上的區別:靜態變數前要加static關鍵字,
                                         而執行個體變數前則不加。
在程式運行時的區別:
          執行個體變數屬於某個對象的屬性,必須建立了執行個體對象,
        其中的執行個體變數才會被分配空間,才能使用這個執行個體變數。
靜態變數不屬於某個執行個體對象,而是屬於類,所以也稱為類變數,
只要程式載入了類的位元組碼,不用建立任何執行個體對象,靜態變數就會被分配空間,靜態變數就可以被使用了。總之,執行個體變數必須建立對象後才可以通過這個對象來使用,靜態變數則可以直接使用類名來引用。
例如,對於下面的程式,無論建立多少個執行個體對象,永遠都只分配了一個staticVar變數,並且每建立一個執行個體對象,這個staticVar就會加1;但是,每建立一個執行個體對象,就會分配一個instanceVar,即可能分配多個instanceVar,並且每個instanceVar的值都只自加了1次。
public class VariantTest{
  public static int staticVar = 0;
  public int instanceVar = 0;
  public VariantTest(){
   staticVar++;
   instanceVar++;
 System.out.println(“staticVar=”
                                   + staticVar + ”,instanceVar=” + instanceVar);
  }
}
備忘:這個解答除了說清楚兩者的區別外,最後還用一個具體的應用例子來說明兩者的差異,體現了自己有很好的解說問題和設計案例的能力,思維敏捷,超過一般程式員,有寫作能力!

4、請說出範圍public,private,protected,
      以及不寫時的區別
這四個範圍的可見範圍如下表所示。
說明:如果在修飾的元素上面沒有寫任何存取修飾詞,則表示default。

範圍    當前類          同一package         子類    其他package
public    √                   √              √         √
protected  √                 √               √          ×
default   √                   √              ×          ×
private    √                   ×              ×         ×

5、Overload和Override的區別。

Overload是重載的意思,Override是覆蓋的意思,
也就是重寫。
重載Overload表示同一個類中可以有
多個名稱相同的方法,
但這些方法的參數列表各不相同
(即參數個數或類型不同)。
重寫Override表示子類中的方法可以
與父類中的某個方法的名稱和參數完全相同,
通過子類建立的執行個體對象調用這個方法時,
將調用子類中的定義方法
,這相當於把父類中定義的那個完全相同的方法給覆蓋了,
這也是物件導向編程的多態性的一種表現。
子類覆蓋父類的方法時,只能比父類拋出更少的異常,
或者是拋出父類拋出的異常的子異常,
因為子類可以解決父類的一些問題,
不能比父類有更多的問題。
子類方法的存取權限只能比父類的更大,不能更小。
如果父類的方法是private類型,那麼,
子類則不存在覆蓋的限制,
相當於子類中增加了一個全新的方法。
至於Overloaded的方法是否可以改變傳回值的類型

如果兩個方法的參數列表完全一樣,
是否可以讓它們的傳回值不同來實現重載Overload。
這是不行的,我們可以用反證法來說明這個問題,
因為我們有時候調用一個方法時也可以不定義返回結果變數,
即不要關心其返回結果,
例如,我們調用map.remove(key)方法時,
雖然remove方法有傳回值,
但是我們通常都不會定義接收返回結果的變數,
這時候假設該類中有兩個名稱和參數列表完全
相同的方法,僅僅是傳回型別不同,
java就無法確定編程者倒底是想調用哪個方法了,
因為它無法通過返回結果類型來判斷。


override可以翻譯為覆蓋,從字面就可以知道,
它是覆蓋了一個方法並且對其重寫,
以求達到不同的作用。
對我們來說最熟悉的覆蓋就是對介面方法的實現,
在介面中一般只是對方法進行了聲明,
而我們在實現時,就需要實現介面聲明的所有方法。
除了這個典型的用法以外,
我們在繼承中也可能會在子類覆蓋父類中的方法。
在覆蓋要注意以下的幾點:
1、覆蓋的方法的標誌必須要和被覆蓋的方法的標誌
完全符合,才能達到覆蓋的效果;
2、覆蓋的方法的傳回值必須和
    被覆蓋的方法的返回一致;
3、覆蓋的方法所拋出的異常必須和
      被覆蓋方法的所拋出的異常一致,或者是其子類;
4、被覆蓋的方法不能為private,
否則在其子類中只是新定義了一個方法,
並沒有對其進行覆蓋。

overload對我們來說可能比較熟悉,
可以翻譯為重載,
它是指我們可以定義一些名稱相同的方法,
通過定義不同的輸入參數來區分這些方法,
然後再調用時,JVM就會根據不同的參數樣式,
來選擇合適的方法執行。
在使用重載要注意以下的幾點:
1、在使用重載時只能通過不同的參數樣式。
例如,不同的參數類型,不同的參數個數,
不同的參數順序
(當然,同一方法內的幾個參數類型必須不一樣,
例如可以是fun(int,float),但是不能為fun(int,int));
2、不能通過存取權限、傳回型別、拋出的異常
進行重載;
3、方法的異常類型和數目不會對重載造成影響;
4、對於繼承來說,
如果某一方法在父類中是存取權限是priavte,
那麼就不能在子類對其進行重載,
如果定義的話,也只是定義了一個新方法,
而不會達到重載的效果。


6、類有哪三個基本特性?各特性的優點?

類具有封裝性、繼承性和多態性。
封裝性:類的封裝性為類的成員提供公有、預設、
保護和私人等多級存取權限,目的是隱藏類中的私
有變數和類中方法的實現細節。
繼承性:類的繼承性提供從已存在的類建立新類的機制,
繼承(inheritance)使一個新類自動擁有
被繼承類(父類)的全部可繼承的成員。
多態性:類的多態性提供類中方法執行的多樣性
,多態性有兩種表現形式:重載和覆蓋。


7、java中實現多態的機制是什嗎?

是父類或介面定義的引用變數可以指向子類
或具體實作類別的執行個體對象,
而程式調用的方法在運行期才動態綁定,
就是引用變數所指向的具體執行個體對象的方法,
也就是記憶體裡正在啟動並執行那個對象的方法,
而不是引用變數的類型中定義的方法。

8、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類型。


9、下面這條語句一共建立了多少個對象:
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。

10、ArrayList和Vector的區別,
    HashMap和Hashtable的區別

  就ArrayList與Vector主要從二方面來說.
一.同步性:Vector是安全執行緒的,
也就是說是同步的,
而ArrayList是線程式不安全的,
不是同步的
二.資料增長:當需要增長時,Vector預設增長為原來一培
,而ArrayList卻是原來的一半
就HashMap與HashTable主要從三方面來說。
一.曆史原因:Hashtable是基於陳舊的Dictionary類的,
HashMap是Java 1.2 引進的Map介面的一個實現
二.同步性:Hashtable是安全執行緒的,
也就是說是同步的,
而HashMap是線程式不安全的,不是同步的
三.值:只有HashMap可以讓你將空值作為
一個表的條目的key或value 

11、談談final, finally, finalize的區別

final?修飾符(關鍵字)如果一個類被聲明為final,意味著它不能再派生出新的子類,不能作為父類被繼承。
因此一個類不能既被聲明為  abstract的,
又被聲明為final的。將變數或方法聲明為final,
可以保證它們在使用中不被
改變。
被聲明為final的變數必須在聲明時給定初值,
而在以後的引用中只能讀取,不可修改。
被聲明為final的方法也
同樣只能使用,不能重載
finally?再異常處理時提供  finally 塊
來執行任何清除操作。如果拋出一個異常,
那麼相匹配的  catch 子句就會執行,然
後控制就會進入  finally 塊(如果有的話)
finalize?方法名。
Java 技術允許使用  finalize() 方法在
垃圾收集器將對象從記憶體中清除出去
之前做必要的清理工作。這
個方法是由垃圾收集器在確定這個對象
沒有被引用時對這個對象調用的。
它是在  Object 類中定義的,因此所有的類都
繼承了它。
子類覆蓋  finalize() 方法以整理系統資源或者
執行其他清理工作。
finalize() 方法是在垃圾收集器刪除對象
之前對這個對象調用的

12、String,  StringBuffer  StringBuilder的區別。

String是不可變的字串,對象不可改變;
    StringBuffer是可變的字串,
如果你對字串中的內容經常進行操作,
特別是內容要修改時,那麼使用StringBuffer,
如果最後需要String,
那麼使用StringBuffer的toString()方法;安全執行緒;
    StringBuilder是從 JDK 5 開始,
為StringBuffer該類補充了一個單個線程使用的等價類別;
通常應該優先使用 StringBuilder 類,
因為它支援所有相同的操作,
但由於它不執行同步,所以速度更快。

13、Collection 和 Collections的區別?

Collection是java.util下的介面,
它是各種集合的父介面,
繼承於它的介面主要有Set 和List;
Collections是個java.util下的類,
是針對集合的協助類,提供一系列靜態方法實現對各種
集合的搜尋、排序、安全執行緒化等操作。

14、請說出ArrayList,Vector, LinkedList的儲存效能和特性

ArrayList和Vector都是使用數組方式儲存資料,
此數組元素數大於實際儲存的資料以便增加
和插入元素,它們都允許直接按序號索引元素,
但是插入元素要涉及數組元素移動等記憶體操作,
所以索引資料快而插入資料慢,
Vector 由於使用了synchronized 方法(安全執行緒),
通常效能上較ArrayList差,
而LinkedList使用雙向鏈表實現儲存,
按序號索引資料需要進行前向或後向遍曆,但
是插入資料時只需要記錄本項的前後項即可,
所以插入速度較快。

15、HashMap和Hashtable的區別?

HashMap是Hashtable的輕量級實現
(非安全執行緒的實現),他們都實現了Map介面,
主要區別
在於HashMap允許空(null)索引值(key),
由於非安全執行緒,效率上高於Hashtable。
HashMap允許
將null作為一個entry的key或者value,而Hashtable不允許。
HashMap把Hashtable的contains
方法去掉了,改成containsvalue和containsKey。
因為contains方法容易讓人引起誤解。Hashtable
繼承自Dictionary類,
而HashMap是Java1.2引進的Map interface的一個實現。
最大的不同是,
Hashtable的方法是synchronize的,
而HashMap不是,在多個線程訪問Hashtable時,
不需要自己為
它的方法實現同步,而HashMap 就必須為之提供同步。 

16、JAVA語言如何進行異常處理,
關鍵字:throws,throw,try,catch,finally分別代表什麼意義?
在try塊中可以拋出異常嗎?

Java 通過物件導向的方法進行異常處理,
把各種不同的異常進行分類,並提供了良好的介面。
在Java中,每個異常都是一個對象,
它是Throwable類或其它子類的執行個體。
當一個方法出現異常後便拋出一個異常對象,
該對象中包含有異常資訊,
調用這個對象的方法可以捕獲到這個異常並進行處理。
Java的異常處理是通過5個關鍵詞來實現的:
try、catch、throw、throws和finally。
一般情況下是用try來執行一段程式,
如果出現異常,系統會拋出(throws)一個異常,
這時候你可以通過它的類型來捕捉(catch)它,
或最後(finally)由預設處理器來處理。
用try來指定一塊預防所有"異常"的程式。
緊跟在try程式後面,
應包含一個catch子句來指定你想要捕捉的"異常"的類型。

throw語句用來明確地拋出一個"異常"。
throws用來標明一個成員函數可能拋出的各種"異常"。
Finally為確保一段代碼不管發生什麼"異常"都被執行一段代碼。
可以在一個成員函數調用的外面寫一個try語句,
在這個成員函數內部寫另一個try語句保護其他代碼。
每當遇到一個try語句,"異常"的架構就放到堆棧上面,
直到所有的try語句都完成。
如果下一級的try語句沒有對某種"異常"進行處理,
堆棧就會展開,直到遇到有處理這種"異常"的try語句。

17、什麼是java序列化,如何?java序列化?
或者請解釋Serializable介面的作用。

我們有時候將一個java對象變成位元組流的形式傳出去
或者從一個位元組流中恢複成一個java對象,
例如,要將javaObject Storage Service到硬碟或者傳送給網路上的
其他電腦,這個過程我們可以自己寫代碼去把一個
java對象變成某個格式的位元組流再傳輸,
但是,jre本身就提供了這種支援,
我們可以調用OutputStream的writeObject方法來做,
如果要讓java 幫我們做,
要被傳輸的對象必須實現serializable介面,
這樣,javac編譯時間就會進行特殊處理,
編譯的類才可以被writeObject方法操作,
這就是所謂的序列化。
需要被序列化的類必須實現Serializable介面,
該介面是一個mini介面,其中沒有需要實現的方法,
implements Serializable只是為了標註該對象是可被序列化的。


例如,在web開發中,如果對象被儲存在了Session中,
tomcat在重啟時要把Session對象序列化到硬碟,
這個對象就必須實現Serializable介面。
如果對象要經過分布式系統進行網路傳輸或通過rmi等
遠程調用,這就需要在網路上傳輸對象,
被傳輸的對象就必須實現Serializable介面。


18、記憶體回收的優點和原理。並考慮2種回收機制。

Java語言中一個顯著的特點就是引入了記憶體回收機制,
使c++程式員最頭疼的記憶體管理的問題迎刃而解,
它使得Java程式員在編寫程式的時候不再需要考慮記憶體管理。
由於有個記憶體回收機制,Java中的對象不再有"範圍"的概念,
只有對象的引用才有"範圍"。
記憶體回收可以有效防止記憶體泄露,
有效使用可以使用的記憶體。
記憶體回收行程通常是作為一個單獨的低層級的線程運行,
不可預知的情況下對記憶體堆中已經死亡的或者長時間
沒有使用的對象進行清楚和回收,
程式員不能即時的調用記憶體回收行程對某個對象或所有
對象進行記憶體回收。回收機制有分代複製記憶體回收和
標記記憶體回收,增量記憶體回收。

19、java中會存在記憶體泄露嗎?請簡單描述。

記憶體泄露是指系統中存在無法回收的記憶體,
有時候會造成記憶體不足或系統崩潰。Java存在記憶體
泄露。Java中的記憶體泄露當然是指:存在無用但是
記憶體回收行程無法回收的對象。而且即使有記憶體泄露
問題存在,也不一定會表現出來。自己實現堆棧的
資料結構時有可能會出現記憶體泄露。

20、請試圖描述java語言中的GC(Gabage Collection)

GC是垃圾收集器。Java程式員不用擔心記憶體管理,
因為垃圾收集器會自動進行管理。要請求垃圾收集,
可以調用下面的方法之一:
System.gc() ;Runtime.getRuntime().gc(),
Java語言沒有提供釋放已指派記憶體的顯示操作方法。

21、JDK1.5匯入了一些新的語言特性,
更有利於代碼的書寫,如支援泛型、
自動拆/裝箱、增強for迴圈等,請結合代碼給出樣本。

泛型: 
List<String> list = new ArrayList<String>();
    String s = list.get(0);
  自動拆/裝箱:
  在基本類型和基本類型對象之間自動轉換。
  Int a = new Integer(5);
  Integer b = a;
  增強for迴圈:
    …
    for(String s:list){
     …
}
    …
 

22、 anonymous Inner Class (匿名內部類)
是否可以extends(繼承)其它類,是否可以implement
(實現)interface(介面)?

匿名內部類是可以繼承其它類,同樣也可以去實現介面的,用法為:
JButton button = new JButton(); 
button.addActionListener(new ActionListener() 

public void actionPerformed(ActionEvent e){//some mothod...} 
});
這樣的用法在swing編程中是經常使用的,就是因為它需要用到註冊監聽器機制,而該監聽類如果只
服務於一個組件,那麼,將該類設定成內部類/匿名類是最方便的

23、java的8種基本類型
    整數類型:byte short int long
    浮點類型:float double
    字元型:char
    布爾類型:boolean

24、一個".java"源檔案中是否可以包括多個類(不是內部類)?有什麼限制?
可以有多個類,但只能有一個public的類,並且public的類名必須與檔案名稱相一致。


25、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?
對於short s1 = 1; s1 = s1 + 1; 由於s1+1運算時會自動提升運算式的類型,所以結果是int型,
再賦值給short類型s1時,編譯器將報告需要強制轉換類型的錯誤。
對於short s1 = 1; s1 += 1;由於 += 是java語言規定的運算子,java編譯器會對它進行特殊處理,因此可以正確編譯。

26、char型變數中能不能存貯一個中文漢字?為什麼?
char型變數是用來儲存Unicode編碼的字元的,unicode編碼字元集中包含了漢字,所以,char型變數中當然
可以儲存漢字啦。不過,如果某個特殊的漢字沒有被包含在unicode編碼字元集中,那麼,這個char型變數中
就不能儲存這個特殊漢字。補充說明:unicode編碼佔用兩個位元組,所以,char類型的變數也是佔用兩個位元組。


27、構造器Constructor是否可被override?
構造器Constructor不能被繼承,因此不能重寫Override,但可以被重載Overload。

28、介面是否可繼承介面? 抽象類別是否可實現(implements)介面? 抽象類別是否可繼承具體類(concrete class)?
抽象類別中是否可以有靜態main方法?
介面可以繼承介面。抽象類別可以實現(implements)介面,抽象類別是否可繼承具體類。抽象類別中可以有靜態main方法。


java物件導向面試題

相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.