問題簡述:
Eclipse Java EE IDE for Web Developers. (Build id: 20090621-0832)
建立 web service後, 啟動 Tomcat 5.5 顯示錯誤訊息
java.lang.NoClassDefFoundError: org/apache/http/HttpResponseFactory
解決方法:
從 Apache Axis2 官網中下載 axis2-1.5-bin.zip, 從zip檔案的lib目錄中複製httpcore-4.0.jar 至
該專案的 WEB-INF/lib 目錄中
Interface | Implementation | Historical | |||
Set | HashSet | TreeSet | |||
List | ArrayList | LinkedList | Vector Stack | ||
Map | HashMap | Treemap | Hashtable Properties | ||
ArrayList是List（列表），数据是有序的，可以有重复元素 HashSet是Set（集合），数据没有顺序，没有重复元素，元素搜索速度快17. Is Iterator inthe Collections API a class or an interface?
Hashtable
Hashtable is basically a datastructure to retain values of key-value pair.
HashMap
Like Hashtable it also accepts key value pair.
HashSet
HashSet does not allow duplicate values. It provides add method rather put method. You also use its contain method to check whether the object is already available in HashSet. HashSet can be used where you want to maintain a unique list.
HashSet
int數值 = 100 ;
object o = 數值 ;
參考型別是擺在堆積裡，數值型別是擺在堆疊裡。那...Object指向數值型別到底該擺哪？
這個時候，就會將100從堆疊中複製一份到堆積中的盒子裡，然後o這個物件參考指向這個盒子。這種將堆疊中的值複製到堆積中的行為，就叫Boxing(裝箱)。反過來說，將堆積中的值，複製到堆疊中的行為，就叫Unboxing(拆箱)。
int 值 = (int) o ; // 將o拆箱
堆疊(stack)可以想像成一個一個疊起來的盒子，數值型別的變數就一個一個放在盒子內。當變數生命周期結束時，盒子就會被移走。
堆積(heap)就像一個空地內亂七八糟的擺了一堆盒子，然後盒子上有標明這個盒子目前是屬於誰在使用的(可以很多人使用同一個盒子)。每當new 出一個物件，例如: Customer c = new Customer(); 物件參照 c 就擺放在堆疊中的盒子裡，而new出來的物件Customer()就在堆積中找一個沒人用的空盒子來擺。當c的生命周期結束，也就是Customer()沒人使用時，堆積中的盒子就會被註明為沒人使用，系統會不定時的把沒人使用的盒子清空。
棧(stack): 是一個先進後出的數據結構,通常用於保存方法(函數)中的參數,局部變量.何謂thread-safe？ 這個問題我看過許多論壇都有討論過，都總讓人覺得不很滿意。在此，筆者想要用更logical的方式來把議題說清楚。首先，我要了解它的定義！ 定義若都不明白就難以判別安不安全了！
thread是什麼呢？ 可能也有人不太了解。就從這裡開始… 當cpu處理一段(區塊)的程式碼時，從開始的第一行程式碼來跑就算是thead的開始，直到區塊的最後一行程式結束，就算是thread的結束。所謂的「主thread」，在dos (或dos like)程式裡，就是指main( )這個函式的開始到結束的一個thread。而主thread以外的一個子thread則是指程式人員自行在主thread裡再定義一個「程式區塊」，並請cpu同步的去執行那個區塊。
由上面的thread的定義來看，我們可以進而推論所謂的multithread這個字其實是有三種情形的，哪三種呢？
1/ 相同的一個程式區塊，請cpu"分出多身"來執行它！
2/ 不同的程式區塊，請cpu各別分時的去執行每個區塊
3/ 混合以上二種情形
所以，當我們在討論多緒/多線程(multithread)的問題時，我們要先去了解問題是上面三類的哪一類。許多的情形下，都是指第一類！
我們再把「程式區塊」給解析一下。它可以是一個function，或是一個class，或是上述二者的混合體。因為function或是class都會使用到變數，於是多緒時變數的共享就成了一個很大的問題。這就是為什麼會有thread-safe的這個議題了！
到此為止，我們可以想像若一個程序(process / 主thread)裡，有大於等於一個子thread在跑，就會產生thread-safe的問題。以最簡單的情形來說，mainthread+user自定的一個thread。假設Button元件按下後會寫入一個item至memo元件裡，而同時間的一個thread則會取用memo裡的item。假想當thread在取用item做分析的時候，user不知情的按下button，那麼thread是否有可能會取到不正確的item？ 若不經過特別的安全設定，肯定「取用」時時而會出問題！
因此，到底安全或不安全的根源就在那執行的區塊程式碼上了(以上例就是取用的過程)。我要補充一個重要的事，其實每一個thread都有自己的一個專屬stack，所以auto級(local)的區域變數是不會有共享的問題，因為它們都是存放在thread各自的記憶體空間內，彼此不甘擾。也就是說，若你的程式區塊中，所有使用到的變數都是local(auto)變數，那你這個區塊，或說這個thread，就算是thread-safe！ 相反的，若你的區塊中有用到全域的變數，那麼你的這個thread就有可能是不安全。請注意看，是有可能，並非一定是。
如何把含有全域變數的thread分析出安全或不安全？其實這是很直覺的。比如說某全域變數int g被thread使用到，但整個thread裡只參考到一次，那算安全嗎？ 答案是…安全。因為單一基本變數的一次存取cpu處理極快，不太會有衝突。又，若是某全域變數 struct tag 被參考到一次，那算安全嗎？ 答案是…不太安全，因為一個結構體的存取可能涉及到多個微指令。進一步的用上面的例子來說，若int g被參考到2次(含)以上，那就肯定不安全了。比如說第一次是把g設成k，第二次把g再設給某變數i，若thread1正在處理第二次參考，而thread2在處理第一次參考。那thread1可能會得到意外的答案！
如何讓不安全的thread變成安全的？？ 其實主要的方法有二類。
1/ 存取共用全域變數時加上lock的機制，而這lock的機制在windows上可以使用mutex、criticalsection、event、semaphore等物件配合WaitForSingleObject或WaitForMultipleObject二個api來控制。其原理就是當某thread在取用資料時，其他的通通都停止並等待，直到該thread取用完。
class A{
}
class B{
/*
* B declare 'a' ---is Instance Variable and its Reference Type is A,
*
*/
A a;
public void setLocalVariable(int i){
int a=0;//a is Local Variables
a=i;
System.out.println(a);//印出來會是i的值不是null
}
}
Store_Information 表格
| |||||||||||||||
Geography 表格
|
而我們要知道每一區 (region_name) 的營業額 (sales)。 Geography 這個表格 告訴我們每一區有哪些店，而 Store_Information 告訴我們每一個店的營業額。 若我們要知道每一區的營業額，我們需要將這兩個不同表格中的資料串聯起來。當我們仔細瞭解這兩個 表格後，我們會發現它們可經由一個相同的欄位，store_name，連接起來。我們先將 SQL 句列出， 之後再討論每一個子句的意義：
SELECT A1.region_name REGION, SUM(A2.Sales) SALES
FROM Geography A1, Store_Information A2
WHERE A1.store_name = A2.store_name
GROUP BY A1.region_name
結果:
| REGION | SALES |
| East | $700 |
| West | $2050 |
在第一行中，我們告訴 SQL 去選出兩個欄位：第一個欄位是 Geography 表格中的 region_name 欄位 (我們取了一個別名叫做 REGION)；第二個欄位是 Store_Information 表格 中的 sales 欄位 (別名為 SALES)。請注意在這裡我們有用到表格別名：Geography 表格的 別名是 A1，Store_Information 表格的別名是 A2。若我們沒有用表格別名的話， 第一行就會變成
SELECT Geography.region_name REGION, SUM(Store_Information.Sales) SALES
很明顯地，這就複雜多了。在這裡我們可以看到表格別名的功用：它能讓 SQL 句容易被瞭解， 尤其是這個 SQL 句含蓋好幾個不同的表格時。
接下來我們看第三行，就是 WHERE 子句。 這是我們闡述連接條件的地方。在這裡，我們要確認 Geography 表格中 store_name 欄位的值與 Store_Information 表格中 store_name 欄位的值是相等的。 這個 WHERE 子句是一個連接的靈魂人物，因為它的角色是確定兩個 表格之間的連接是正確的。如果 WHERE 子句是錯誤的， 我們就極可能得到一個笛卡兒連接 (Cartesian join)。笛卡兒連接會造成我們得到所有兩個表格 每兩行之間所有可能的組合。在這個例子中，笛卡兒連接會讓我們得到 4 x 4 = 16 行的結果。外部連接的語法是依資料庫的不同而有所不同的。舉例來說，在 Oracle 上， 我們會在 WHERE 子句中要選出所有資料的那個表格之後加上一個 "(+)" 來代表說這個表格中的所有資料我們都要。
假設我們有以下的兩個表格：
| Store_Information 表格
| |||||||||||||||
Geography 表格
|
我們需要知道每一間店的營業額。如果我們用一個普通的連接，我們將會漏失掉 'New York'這個店，因為它並不存在於 Store_Information 這個表格。 所以，在這個情況下，我們需要用外部連接來串聯這兩個表格：
SELECT A1.store_name, SUM(A2.Sales) SALES
FROM Georgraphy A1, Store_Information A2
WHERE A1.store_name = A2.store_name (+)
GROUP BY A1.store_name
我們在這裡是使用了 Oracle 的外部連接語法。
結果:
| store_name | SALES |
| Boston | $700 |
| New York | |
| Los Angeles | $1800 |
| San Diego | $250 |
[SQL 語句 1]
UNION
[SQL 語句 2]
假設我們有以下的兩個表格，
Store_Information 表格
| store_name | Sales | Date |
| Los Angeles | $1500 | Jan-05-1999 |
| San Diego | $250 | Jan-07-1999 |
| Los Angeles | $300 | Jan-08-1999 |
| Boston | $700 | Jan-08-1999 |
Internet_Sales 表格
| Date | Sales |
| Jan-07-1999 | $250 |
| Jan-10-1999 | $535 |
| Jan-11-1999 | $320 |
| Jan-12-1999 | $750 |
而我們要找出來所有有營業額 (sales) 的日子。要達到這個目的，我們用以下的 SQL 語句：
SELECT Date FROM Store_Information
UNION
SELECT Date FROM Internet_Sales
結果:
| Date |
| Jan-05-1999 |
| Jan-07-1999 |
| Jan-08-1999 |
| Jan-10-1999 |
| Jan-11-1999 |
| Jan-12-1999 |
UNION ALL 的語法如下：
[SQL 語句 1]我們用和上一頁同樣的例子來顯示出 UNION ALL 和 UNION 的不同。同樣假設我們有以下兩個表格，
Store_Information 表格
| store_name | Sales | Date |
| Los Angeles | $1500 | Jan-05-1999 |
| San Diego | $250 | Jan-07-1999 |
| Los Angeles | $300 | Jan-08-1999 |
| Boston | $700 | Jan-08-1999 |
Internet_Sales 表格
| Date | Sales |
| Jan-07-1999 | $250 |
| Jan-10-1999 | $535 |
| Jan-11-1999 | $320 |
| Jan-12-1999 | $750 |
而我們要找出有店面營業額以及網路營業額的日子。要達到這個目的，我們用以下的 SQL 語句：
SELECT Date FROM Store_Information
UNION ALL
SELECT Date FROM Internet_Sales
結果:
| Date |
| Jan-05-1999 |
| Jan-07-1999 |
| Jan-08-1999 |
| Jan-08-1999 |
| Jan-07-1999 |
| Jan-10-1999 |
| Jan-11-1999 |
| Jan-12-1999 |
不管是 C++ 編譯器、或是 Java VM、或是 .NET CLR，內部都是以此方式來實現多型。儘管如此，這只能算是 black magic，對於 C++、Java 與 .NET 語言來說，函數指標「並未因此」和語言本身有直接相關。換句話說，C++ 和 Java 與 .NET 語言，就算語法本身不支援函數指標，照樣也能實現多型。事實上，C++ 固然支援函數指標，但不是爲了多型的關係，而是爲了和 C 相容 (畢竟 C++ 是 C 的 superset)；IL Asm (.NET 上的組合語言) 固然支援函數指標，但由於安全的理由，使用上受到相當大的限制，且不是爲了多型的關係。至於 Java 與 C# 則都不支援函數指標。
沒 錯，Java 與 C# 都不支援函數指標。雖然剛剛解釋過，這不會影響對於多型的支援，但是這會不會影響對於多緒 (multithreading) 與回呼 (call-back) 機制的支援呢？答案是：不會！因為 Java 可以利用多型或反映 (reflection) 來實現多緒與回呼，而 C#可 以利用多型或反映或委託 (delegate) 來實現多緒與回呼。
顧名思義，反映 (reflection) 機制就像是在吳承恩所著的西遊記中所提及的「照妖鏡」，可以讓類別或物件 (object) 在執行時期「現出原形」。我們可以利用反映機制來深入瞭解某類別 (class) 的建構子 (constructor)、方法 (method)、欄位 (field)，甚至可以改變欄位的值、呼叫方法、建立新的物件。有了反映機制，程式員即使對所欲使用的類別所知不多，也能照樣寫程式。反映機制能夠用來 呼叫方法，這正是反映機制能夠取代函數指標的原因。
以 Java 來說，java.lang.reflect.Method (以下簡稱 Method) 類別是用來表示某類別的某方法。我們可以透過 java.lang.Class (以下簡稱 Class) 類別的許多方法來取得 Method 物件。Method 類別提供 invoke() 方法，透過 invoke()，此 Method 物件所表示的方法可以被呼叫，所有的參數則是被組織成一個陣列，以方便傳入 invoke()。
舉個例子，下面是一個名為 Invoke 的程式，它會將命令列的 Java 類別名稱和要呼叫的方法名稱作為參數。為了簡單起見，我假定此方法是靜態的，且沒有參數：
=======================================
import java.lang.reflect.*;
class Invoke {
public static void main(String[] args ) {
try {
Class c = Class.forName( args[0] );
Method m = c.getMethod( args[1], new Class [] { } );
Object ret = m.invoke( null, null );
System.out.println(args[0] + "." + args[1] +"() = " + ret );
} catch ( ClassNotFoundException ex ) {
System.out.println("找不到此類別");
} catch (NoSuchMethodException ex ) {
System.out.println("此方法不存在");
} catch (IllegalAccessException ex ) {
System.out.println("沒有權限調用此方法");
} catch (InvocationTargetException ex ) {
System.out.println("調用此方法時發生下列例外:\n" +
ex.getTargetException() );
}
}
}
=======================================
我們的第一步就是用名稱去尋找指定的 Class。我們用類別名稱 (命令列的第一個參數) 去呼叫 forName() 方法，然後用方法名稱 (命令列的第二個參數) 去取得方法。getMethod() 方法有兩個參數：第一個是方法名稱 (命令列的第二個參數)，第二個是 Class 物件的陣列，這個陣例指明了方法的 signature (任何方法都可能會被多載，所以必須指定 signature 來分辨。) 因為我們的簡單程式只呼叫沒有參數的方法，我們建立一個 Class 物件的匿名空陣列。如果我們想要呼叫有參數的方法，我們可以傳遞一個類別陣列，陣列的內容是各個類別的型態，依順序排列。
一旦我們有了 Method 物件，就呼叫它的 invoke() 方法，這會造成我們的目標方法被調用，並且將結果以 Object 物件傳回。如果要對此物件做其他額外的事，你必須將它轉型為更精確的型態。
invoke() 方法的第一個參數就是我們想要呼叫目標方法的物件，如果該方法是靜態的，就沒有物件，所以我們把第一個參數設為 null，這就是我們範例中的情形。第二個參數是要傳給目標方法作為參數的物件陣列，它們的型態要符合呼叫 getMethod() 方法中所指定的型態。因為我們呼叫的方法沒有參數，所以我們傳遞 null 作為 invoke() 的第二個參數。
以上是 Java 的例子，事實上，.NET 的反映機制也相去不遠，不再贅述。反映機制是最動態的機制，比多型的功能更強大。然而，反映的速度比多型慢許多 (而且多型又比函數指標稍慢)，所以若非必要，應該少用反映機制。事實上，不管是 Java API 或 .NET Framework，都不使用反映機制來實現回呼與多緒。
Java沒有函數指標(為了系統安全)，也不用反映機制來處理多緒(一方面為了效率，二方面反映機制是在JDK1.1才開始支援)，而是使用多型的機制來處理多緒，作法如下：(另一種作法是實作java.lang.Runnable介面，與下面的作法雷同，不另說明。)
將執行緒的程式寫在下面的run()方法中：
class MyThread extends java.lang.Thread {
public void run() {
// ...
}
}
再利用下面的方式來啟動此執行緒：
MyThread thread = new MyThread();
thread.start();
start() 方法定義在 java.lang.Thread 類別內，start() 方法會請作業系統建立一個執行緒，再呼叫
run()，此時調用的並非在 java.lang.Thread 內定義的 run() (它是空的)，而是利用多型機制，調用到 MyThread
內定義的 run()。
通常回呼機制都是使用 publisher/subscriber (出版者/訂閱者) 的方式，必須先向系統註冊：
Java 也是使用類似的作法，差別在於 Java 無法利用函式指標，且採用物件導向的作法。Java 將出版者 (publisher) 稱爲事件來源 (event source)，將訂閱者 (subscriber) 稱爲事件傾聽者 (event listener)。大致的作法如下：
事件來源提供名爲 addXxxListener() 的方法來讓事件傾聽者註冊之用，此方法需要傳入事件傾聽者當參數。至於是何種事件，則由 Xxx 以爲識別。例如：addMouseListener() 表示註冊「滑鼠事件」的事件傾聽者。
利用 addXxxListener()，事件來源就可以將事件傾聽者記錄在欄位 (field) 中。當事件發生時，事件來源就可以從欄位中知道該通知和物件。可是應該呼叫該物件的那個方法呢？如果該物件沒有提供該方法呢？
想要解決此問題，事件來源就必須過濾註冊的對象，addXxxListener() 所需要的參數不可以是籠統的 java.lang.Object，而必須是一個實作 XxxListener 介面 (interface) 的物件。只要在 XxxListener 介面內宣告一個比方說 XxxEventHappened()，那麽任何實作 XxxListener 的物件，都必定有實現 XxxEventHappened()，所以事件來源就可以在事件發生時，呼叫事件傾聽者的 XxxEventHappened()。這正是依靠多型機制才能達成。
事件來源通知事件傾聽者時，往往需要夾帶一些額外的訊息，例如：事件來源是誰、事件發生於何時、事件發生的原因為何…。這些訊息被封裝成事件物件，當作參數傳給 XxxEventHappened()。
例如，我要向一個名為 jButton1 的 javax.swing.JButton 物件註冊，成為它的事件傾聽者，那麼就必須實作 java.awt.event.ActionListener 介面，提供 actionPerformed() 方法，如下所示：
class MyActionListener implements ActionListener {
public void actionPerformed(ActionEvent evt) {
// ...
}
}
註冊的方式如下：
MyActionListener mal = new MyActionListener();
jButton1.addActionListener(mal);
使用多型的機制來實現多緒和回呼，不但麻煩 (必須繼承)，也不能使用靜態方法，因為靜態方法本來就沒有多型的機制 (static 一定是 non-virtual)。順便一提，前面所提到的反映機制，可以支援靜態方法 (static method)。
********************** 我 是 分 隔 線 *************************
更多關於Polymorphsim
http://www.inote.tw/2008/02/java-polymorphism.html
Polymorphism又稱為多型，他的討論要在類別間有繼承關係才有意義，而他的定義很少發現有人能一次說得很清楚，所以海芋就以幾句話來帶過他。
簡單來說，多型是指子類別繼承父類別時，同時改寫父類別的函式或變數，而我們可以宣告一個屬於父類別的變數，去存取子類別中改寫自父類別的函式或變數，這我們稱之為多型。
舉個生活一點的例子，若有一個父類別是動物，那麼有一個子類別鳥繼承自動物這個類別，當我們看到鳥的時侯，可以說牠是一隻鳥，也可以說牠是一隻動物。同樣的東西，卻有不同的表示型態。而舉個程式碼而言：
而在此例子中，animal是宣告給父類別，所以他只能認識父類別擁有的函式或變數，所以他能存取「getLegs()」這個函式。而另一個要記的重點是，父類別若轉成子類別需要靠強迫轉型，子類別轉成父類別則是屬於自動轉型，而兄弟類別之類亦可以使用強迫的方式來轉型喔！
There are two types of methods.
Math class.From outside the defining class, an instance method is called by prefixing it with an object, which is then passed as an implicit parameter to the instance method, eg, inputTF.setText("");
A static method is called by prefixing it with a class name, eg, Math.max(i,j);. Curiously, it can also be qualified with an object, which will be ignored, but the class of the object will be used.
Here is a typical static method.
class MyUtils {
. . .
//================================================= mean
public static double mean(int[] p) {
int sum = 0; // sum of all the elements
for (int i=0; i The only data this method uses or changes is from parameters (or local variables of course).
staticThe above mean() method would work just as well if it wasn't declared static, as long as it was called from within the same class. If called from outside the class and it wasn't declared static, it would have to be qualified (uselessly) with an object. Even when used within the class, there are good reasons to define a method as static when it could be.
static method can't interact with instance variables, which makes reading and debugging easier. There are two cases.
// Called from inside the MyUtils class
double avgAtt = mean(attendance);
// Called from outside the MyUtils class.If an object is specified before it, the object value will be ignored and the the class of the object will be used.
double avgAtt = MyUtils.mean(attendance);
Altho a static method can't access instance variables, it can access static variables. A common use of static variables is to define "constants". Examples from the Java library are Math.PI or Color.RED. They are qualified with the class name, so you know they are static. Any method, static or not, can access static variables. Instance variables can be accessed only by instance methods.
What's a little peculiar, and not recommended, is that an object of a class may be used instead of the class name to access static methods. This is bad because it creates the impression that some instance variables in the object are used, but this isn't the case.
Java2WSDL vs WSDL2Java its a long debate.
Theory: People say, it is better to have contract first and develop XSD. later generate code.
Reality:
1. Working on XML tools and generating XSD is painful process.
2. We never use simple data types in real projects
3. Dont have much time to do small POCs, when depending on WSDL2Java (Proof of Concepts)
4. Difficult to handle frequent changes
Reality: Do your work using Java coding. Develop all business objects, ..etc.
Once you are confident and ready to interface with other applications go with Java2WSDL.
Java2WSDL wins and saves time for developers.
Here is the Maven Java2WSDL plugin (cxf-java2ws-plugin) for your reference.
cxf-java2ws-plugin : http://cwiki.apache.org/CXF20DOC/maven-java2ws-plugin.html
WSDL Document Structure: http://www.w3schools.com/WSDL/wsdl_documents.asp
(from blog http://polimetla.com/2009/09/16/java2wsdl-vs-wsdl2java/)
Question: How could Java classes direct program messages to the system console, but error messages, say to a file?
Answer: The class System has a variable out that represents the standard output, and the variable err that represents the standard error device. By default, they both point at the system console. This how the standard output could be re-directed:
Stream st = new Stream(new FileOutputStream("output.txt")); System.setErr(st); System.setOut(st);
Question: Why would you use a synchronized block vs. synchronized method?
Answer: Synchronized blocks place locks for shorter periods than synchronized methods.
Question: Explain the usage of the keyword transient?
Answer: This keyword indicates that the value of this member variable does not have to be serialized with the object. When the class will be de-serialized, this variable will be initialized with a default value of its data type (i.e. zero for integers).
Question: How can you force garbage collection?
Answer: You can't force GC, but could request it by calling System.gc(). JVM does not guarantee that GC will be started immediately.
Question: What's the difference between the methods sleep() and wait()
Answer: The code sleep(1000); puts thread aside for exactly one second. The code wait(1000), causes a wait of up to one second. A thread could stop waiting earlier if it receives the notify() or notifyAll() call. The method wait() is defined in the class Object and the method sleep() is defined in the class Thread.
Question: Can you call one constructor from another if a class has multiple constructors
Answer: Yes. Use this() syntax.
Question: How would you make a copy of an entire Java object with its state?
Answer: Have this class implement Cloneable interface and call its method clone().
clone() 預設是 重新配置一塊記憶體,並予以 copy ,
所以內容與原來的是一模一樣, 但是分屬不同的空間
所以 x.clone() 當然不等於 x
| Q: | |
| A: | With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchonization, it is possible for one thread to modify a shared variable while another thread is in the process of using or updating same shared variable. This usually leads to significant errors. |
| Q: | |
| A: | The thread could be implemented by using runnable interface or by inheriting from the Thread class. The former is more advantageous, 'cause when you are going for multiple inheritance..the only interface can help. |
| Q: | |
| A: | Interface Pass By Reference means the passing the address itself rather than passing the value. Pass By Value means passing a copy of the value to be passed. |
| Q: | |
| A: | Map is Interface and Hashmap is class that implements that. |
| Q: | |
| A: | The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls. (HashMap allows null values as key and value whereas Hashtable doesnt allow). HashMap does not guarantee that the order of the map will remain constant over time. HashMap is unsynchronized and Hashtable is synchronized. |
| Q: | |
| A: | Vector is synchronized whereas arraylist is not. |
| Q: | |
| A: | AWT are heavy-weight componenets. Swings are light-weight components. Hence swing works faster than AWT. |
| Q: | |
| A: | A constructor is a member function of a class that is used to create objects of that class. It has the same name as the class itself, has no return type, and is invoked using the new operator. A method is an ordinary member function of a class. It has its own name, a return type (which may be void), and is invoked using the dot operator. |
| Q: | |
| A: | Some of the collection classes provide traversal of their contents via a java.util.Iterator interface. This interface allows you to walk through a collection of objects, operating on each object in turn. Remember when using Iterators that they contain a snapshot of the collection at the time the Iterator was obtained; generally it is not advisable to modify the collection itself while traversing an Iterator. |
| Q: | |
| A: | Abstract class must be extended/subclassed (to be useful). It serves as a template. A class that is abstract may not be instantiated (ie, you may not call its constructor), abstract class may contain static data. Any class with an abstract method is automatically abstract itself, and must be declared as such. A class may be declared abstract even if it has no abstract methods. This prevents it from being instantiated. |
| Q: | |
| A: | Static means one per class, not one for each object no matter how many instance of a class might exist. This means that you can use them without creating an instance of a class.Static methods are implicitly final, because overriding is done based on the type of the object, and static methods are attached to a class, not an object. A static method in a superclass can be shadowed by another static method in a subclass, as long as the original method was not declared final. However, you can't override a static method with a nonstatic method. In other words, you can't change a static method into an instance method in a subclass. |
程式:
class Question30Super{
public static void printSomething(){
System.out.println("In Question30Super");
}
}
public class Question30 extends Question30Super {
public static void main(String[] args){
Question30Super q30 = new Question30();
q30.printSomething();
}
public static void printSomething(){
System.out.println("In Question30");
}
}
執行結果:
In Question30Super
| Q: | |
| A: | A final class can't be extended ie., final class may not be subclassed. A final method can't be overridden when its class is inherited. You can't change value of a final variable (is a constant). |