java小問題的相關文章推薦（java小問題的相關文章推薦理由）

本文目錄一覽：

• 1、問一個JAVA的小問題
• 2、關於如何學好JAVA的文章
• 3、Java 中的一些小問題~

問一個JAVA的小問題

這個教程向您介紹java的泛型(generic)。你可能熟悉其他語言的泛型，最著名的是C++的模板(templates)。 如果這樣，你很快就會看到兩者的相似之處和重要差異。如果你不熟悉相似的語法結構，那麼更好，你可以從頭開始而不需要忘記誤解。

Generics允許對類型進行抽象(abstract over types)。最常見的例子是集合類型(Container types)，Collection的類樹中任意一個即是。

下面是那種典型用法：

List myIntList = new LinkedList();// 1

myIntList.add(new Integer(0));// 2

Integer x = (Integer) myIntList.iterator().next();// 3

第3行的類型轉換有些煩人。通常情況下，程序員知道一個特定的list裡邊放的是什麼類型的數據。但是，這個類型轉換是必須

的(essential)。編譯器只能保證iterator返回的是Object類型。為了保證對Integer類型變量賦值的類型安全，必須進行類型轉換。

當然，這個類型轉換不僅僅帶來了混亂，它還可能產生一個運行時錯誤(run time error)，因為程序員可能會犯錯。 程序員如何才能明確表示他們的意圖，把一個list中的內容限制為一個特定的數據類型呢？這是generics背後的核心思想。 這是上面程序片斷的一個泛型版本:

List myIntList = new LinkedList(); // 1

myIntList.add(new Integer(0)); // 2

Integer x = myIntList.iterator().next(); // 3

注意變量myIntList的類型聲明。它指定這不是一個任意的List，而是一個Integer的List，寫作：List。

我們說List是一個帶一個類型參數的泛型接口(a generic interface that takes a type parameter)，本例中，類型參數是Integer。我們在創建這個List對象的時候也指定了一個類型參數。

另一個需要注意的是第3行沒了類型轉換。現在，你可能認為我們已經成功地去掉了程序里的混亂。我們用第1行的類型參數取代了第3行的類型轉換。然而，這裡還有個很大的不同。編譯器現在能夠在編譯時檢查程序的正確性。當我們說myIntList被聲明為List類型，這告訴我們無論何時何地使用myIntList變量，編譯器保證其中的元素的正確的類型。與之相反，一個類型轉換說明程序員認為在那個代碼點上它應該是那種類型。實際結果是，這可以增加可讀性和穩定性 (robustness)，尤其在大型的程序中。

2. 定義簡單的泛型

下面是從java.util包中的List接口和Iterator接口的定義中摘錄的片斷：

public interface List {

void add(E x);

Iterator iterator();

}

public interface Iterator {

E next();

boolean hasNext();

}

這些都應該是很熟悉的，除了尖括號中的部分，那是接口List和Iterator中的形式類型參數的聲明(the declarations of the formal type parameters of the interfaces List and Iterator)。類型參數在整個類的聲明中可用，幾乎是所有可以使用其他普通類型的地方(但是有些重要的限制，請參考第7部分)

在介紹那一節我們看到了對泛型類型聲明List(the generic type declaration List)的調用，如List。

在這個調用中(通常稱作一個參數化類型a parameterized type)，所有出現形式類型參數(formal type parameter,這裡是E)的地方

都被替換成實體類型參數(actual type argument)(這裡是Integer)。 你可能想象,List代表一個E被全部替換成Integer的版本：

public interface IntegerList {

void add(Integer x)

Iterator iterator();

}

這種直覺可能有幫助，但是也可能導致誤解。 它有幫助，因為List的聲明確實有類似這種替換的方法。 它可能導致誤解，因為泛型聲明絕不會實際的被這樣替換。沒有代碼的多個拷貝，源碼中沒有、二進制代碼中也沒有； 磁盤中沒有，內存中也沒有。如果你是一個C++程序員，你會理解這是和C++模板的很大的區別。

一個泛型類型的聲明只被編譯一次，並且得到一個class文件，就像普通的class或者interface的聲明一樣。類型參數就象在方法或構造函數中普通的參數一樣。就像一個方法有形式參數(formal value parameters)來描述它操作的參數的種類一樣，一個泛型聲明也有形式類型參數(formal type parameters)。當一個方法被調用，實參(actual arguments) 替換形參，方法體被執行。當一個泛型聲明被調用，實際類型參數(actual type arguments)取代形式類型參數。

一個命名的習慣：我們推薦你用簡練的名字作為形式類型參數的名字(如果可能，單個字符)。最好避免小寫字母， 這使它和其他的普通的形式參數很容易被區分開來。許多容器類型使用E作為其中元素的類型，就像上面舉的例子。 在後面的例子中還會有一些其他的命名習慣。

3. 泛型和子類繼承

讓我們測試一下我們對泛型的理解。下面的代碼片斷合法么？

List ls = new ArrayList(); //1

List lo = ls; //2

第1行當然合法，但是這個問題的狡猾之處在於第2行。 這產生一個問題： 一個String的List是一個Object的List么？大多數人的直覺是回答：“當然！”。 好，在看下面的幾行：

lo.add(new Object()); // 3

String s = ls.get(0); // 4: 試圖把Object賦值給String

這裡，我們使用lo指向ls。我們通過lo來訪問ls,一個String的list。我們可以插入任意對象進去。結果是ls中保存的不再是String。當我們試圖從中取出元素的時候，會得到意外的結果。 java編譯器當然會阻止這種情況的發生。第2行會導致一個編譯錯誤。

總之，如果Foo是Bar的一個子類型(子類或者子接口)，而G是某種泛型聲明，那麼G是G的子類型並不成立!!

這可能是你學習泛型中最難理解的部分，因為它和你的直覺相反。這種直覺的問題在於它假定這個集合不改變。我們的直覺認為

這些東西都不可改變。 舉例來說，如果一個交通部(DMV)提供一個駕駛員表給人口普查局，這似乎很合理。我們想，一個List 是一個List，假定Driver是Person的子類型。實際上，我們傳遞的是一個駕駛員註冊的拷貝。然而，

人口普查局可能往駕駛員list中加入其他人，這破壞了交通部的記錄。為了處理這種情況，考慮一些更靈活的泛型類型很有用。

到現在為止我們看到的規則限制比較大。

4.通配符(Wildcards)

考慮寫一個例程來打印一個集合(Collection)中的所有元素。下面是在老的語言中你可能寫的代碼：

void printCollection(Collection c) {

Iterator i = c.iterator();

for (int k = 0; k c.size(); k++) {

System.outi.next());

}

}

下面是一個使用泛型的幼稚的嘗試(使用了新的循環語法):

void printCollection(Collection c) {

for (Object e : c) {

System.out.println(e);

}

}

問題是新版本的用處比老版本小多了。老版本的代碼可以使用任何類型的collection作為參數，而新版本則只能使用 Collection，我們剛才闡述了，它不是所有類型的collections的父類。那麼什麼是各種collections的父類呢？它寫作：

Collection(發音為:”collection of unknown”)

就是，一個集合， 它的元素類型可以匹配任何類型。顯然，它被稱為通配符。我們可以寫：

void printCollection(Collection c) {

for (Object e : c) {

System.out.println(e);

}

}

現在，我們可以使用任何類型的collection來調用它。注意，我們仍然可以讀取c中的元素，其類型是Object。這永遠是安全的，

因為不管collection的真實類型是什麼，它包含的都是objects。但是將任意元素加入到其中不是類型安全的：

Collection c = new ArrayList();

c.add(new Object()); // 編譯時錯誤

因為我們不知道c的元素類型，我們不能向其中添加對象。 add方法有類型參數E作為集合的元素類型。我們傳給add的任何參數都必須是一個未知類型的子類。因為我們不知道那是什麼類型， 所以我們無法傳任何東西進去。唯一的例外是null，它是所有類型的成員。 另一方面，我們可以調用get()方法並使用其返回值。返回值是一個未知的類型，但是我們知道，它總是一個Object，因此把get的返回值賦值給一個Object類型的對象或者放在任何希望是Object類型的地方是安全的。

4.1. 有限制的通配符(Bounded Wildcards)

考慮一個簡單的畫圖程序，它可以用來畫各種形狀，比如矩形和圓形。 為了在程序中表示這些形狀，你可以定義下面的類繼承結構：

public abstract class Shape {

public abstract void draw(Canvas c);

}

public class Circle extends Shape {

private int x, y, radius;

public void draw(Canvas c) { // … }

}

public class Rectangle extends Shape {

private int x, y, width, height;

public void draw(Canvas c) { // … }

}

這些類可以在一個畫布(Canvas)上被畫出來:

publicclass Canvas {

publicvoid draw(Shape s) {

s.draw(this);

}

}

所有的圖形通常都有很多個形狀。假定它們用一個list來表示，Canvas里有一個方法來畫出所有的形狀會比較方便：

public void drawAll(List shapes) {

for (Shape s : shapes) {

s.draw(this);

}

}

現在，類型規則導致drawAll()只能使用Shape的list來調用。它不能，比如說對List來調用。這很不幸， 因為這個方法所作的只是從這個list讀取shape，因此它應該也能對List調用。我們真正要的是這個方法能夠接受一個任意種類的shape: 軟件開發網

public void drawAll(List shapes) { //..}

這裡有一處很小但是很重要的不同:我們把類型 List 替換成了List。現在drawAll()可以接受

任何Shape的子類的List，所以我們可以對List進行調用。

List是有限制通配符的一個例子。這裡？代表一個未知的類型，就像我們前面看到的通配符一樣。

但是，在這裡，我們知道這個未知的類型實際上是Shape的一個子類(它可以是Shape本身或者Shape的子類)。我們說Shape是這個通配符的上限(upper bound)。 像平常一樣，要得到使用通配符的靈活性有些代價。這個代價是，現在向shapes中寫入是非法的。比如下面的代碼是不允許的：

public void addRectangle(List shapes) {

shapes.add(0, new Rectangle()); // compile-time error!

}

你應該能夠指出為什麼上面的代碼是不允許的。因為shapes.add的第二個參數類型是? extends Shape——一個Shape未知的子類。 因此我們不知道這個類型是什麼，我們不知道它是不是Rectangle的父類；它可能是也可能不是一個父類，所以這裡傳遞一個

Rectangle不安全。 有限制的通配符正是我們解決DMV給人口普查局傳送名單的例子所需要的。我們的例子假定數據用一個姓名（String） 到people（用Person或其子類來表示，比如Driver）的映射表示。Map是一個有兩個類型參數的泛型類型的例子，表示map的鍵key和值value。 再一次，注意形式類型參數的命名習慣——K代表keys，V代表vlaues。

public class Census {

public static void addRegistry(Map registry) { …}

}

Map allDrivers = …;

Census.addRegistry(allDrivers);

5. 泛型方法

考慮寫一個方法，它用一個Object的數組和一個collection作為參數，完成把數組中所有object放入collection中的功能。

下面是第一次嘗試：

static void fromArrayToCollection(Object[] a, Collection c) {

for(Object o : a) {

c.add(o); // 編譯期錯誤

}

}

現在，你應該能夠學會避免初學者試圖使用Collection作為集合參數類型的錯誤了。或許你已經意識到使用

Collection也不能工作，你不能把對象放進一個未知類型的集合中去。 解決這個問題的辦法是使用generic methods。就像類型聲明，方法的聲明也可以被泛型化——就是說，帶有一個或者多個類型參數。

static void fromArrayToCollection(T[] a, Collection c){

for (T o : a) {

c.add(o); // correct

}

}

我們可以使用任意集合來調用這個方法，只要其元素的類型是數組的元素類型的父類。

Object[] oa = new Object[100];

Collection co = new ArrayList();

fromArrayToCollection(oa, co);// T 指Object

String[] sa = new String[100];

Collection cs = new ArrayList();

fromArrayToCollection(sa, cs);// T inferred to be String

fromArrayToCollection(sa, co);// T inferred to be Object

Integer[] ia = new Integer[100];

Float[] fa = new Float[100];

Number[] na = new Number[100];

Collection cn = new ArrayList();

fromArrayToCollection(ia, cn);// T inferred to be Number

fromArrayToCollection(fa, cn);// T inferred to be Number

fromArrayToCollection(na, cn);// T inferred to be Number

fromArrayToCollection(na, co);// T inferred to be Object

fromArrayToCollection(na, cs);// compile-time error

注意，我們並沒有傳送真實類型參數(actual type argument)給一個泛型方法。編譯器根據實參為我們推斷類型參數的值。

它通常推斷出能使調用類型正確的最明確的類型參數(原文是：It will generally infer the most specific type argument that will make the call type-correct.)。

現在有一個問題：我們應該什麼時候使用泛型方法，又什麼時候使用通配符類型呢？ 為了理解答案，讓我們先看看Collection庫中的幾個方法。

public interface Collection {

boolean containsAll(Collection c);

boolean addAll(Collection c);

}

我們也可以使用泛型方法來代替：

public interface Collection {

boolean containsAll(Collection c);

boolean addAll(Collection c);

// hey, type variables can have bounds too!

}

但是，在 containsAll 和 addAll中，類型參數T 都只使用一次。返回值的類型既不依賴於類型參數(type parameter)也

不依賴於方法的其他參數（這裡，只有簡單的一個參數）。這告訴我們類型參數(type argument)被用作多態（polymorphism），

它唯一的效果是允許在不同的調用點，可以使用多種實參類型(actual argument)。如果是這種情況，應該使用通配符。 通配符就是被設計用來支持靈活的子類化的，這是我們在這裡要強調的。

泛型函數允許類型參數被用來表示方法的一個或多個參數之間的依賴關係，或者參數與其返回值的依賴關係。如果沒有這樣的依賴 關係，不應該使用泛型方法。

(原文：Generic methods allow type parameters to be used to express dependencies among the types of one

or more arguments to a method and/or its return type. If there isn’t such a dependency, a generic method should not be used.）

一前一後的同時使用泛型方法和通配符也是可能的。下面是方法 Collections.copy():

classCollections {

public static void copy(List dest, List src){…}

}

注意兩個參數的類型的依賴關係。任何被從源list從拷貝出來的對象必須能夠將其指定為目標list(dest) 的元素的類型——T類型。因此源類型的元素類型可以是T的任意子類型，我們不關心具體的類型。 copy方法的簽名使用一個類型參數表示了類型依賴，但是使用了一個通配符作為第二個參數的元素類型。我們也可以用其他方式寫這個函數的簽名而根本不使用通配符：

class Collections {

public static void copy(List dest, List src){…}

}

這也可以，但是第一個類型參數在dst的類型和第二個參數的類型參數S的上限這兩個地方都有使用，而S本身只使用一次，

在src的類型中——沒有其他的依賴於它。這意味着我們可以用通配符來代替S。使用通配符比聲明顯式的類型參數更加清晰

和準確，所以在可能的情況下使用通配符更好。 通配符還有一個優勢式他們可以在方法簽名之外被使用，比如field的類型，局部變量和數組。這就有一個例子。

回到我們的畫圖問題，假定我們想要保持畫圖請求的歷史記錄。我們可以把歷史記錄保存在Shape類的一個靜態成員變量里，

在drawAll() 被調用的時候把傳進來的參數保存進歷史記錄：

static ListList history = new ArrayListList();

public void drawAll(List shapes) {

history.addLast(shapes);

for(Shape s: shapes) {

s.draw(this);

}

}

最終，再說一下類型參數的命名習慣。 我們使用T 代表類型，無論何時都沒有比這更具體的類型來區分它。這經常見於泛型方法。如果有多個類型參數， 我們可能使用字母表中T的臨近的字母，比如S。如果一個泛型函數在一個泛型類裡邊出現，最好避免在方法的類型參數和類的類型參數中使用同樣的名字來避免混淆。對內部類也是同樣。

關於如何學好JAVA的文章

51CTO編者註：這篇文章已經是有數年“網齡”的老文，不過在今天看來仍然經典。如何學習Java？本篇文章可以說也是面對編程初學者的一篇指導文章，其中對於如何學習Java的步驟的介紹，很多也適用於開發領域其他技能的學習。

【在原先《學好Java之我見》的基礎上重新整理而成】

Java – 近10年來計算機軟件發展過程中的傳奇，其在眾多開發者心中的地位就如“屠龍刀”、“倚天劍”。

Java是個平台，我只想說說我對學好Java的一點看法，希望對初學者有所幫助。

1. 思考一下

學習Java之前，先別急，靜下心來好好想想：

1）你對學習Java是否有興趣？

2）你是否能靜下心來堅持不懈地學習？

嗯，這是個容易但又絕對不應該忽略的問題，你確信自己對Java感興趣、而且又有吃苦的準備，那你才可能學好Java！如果具備這兩點條件，就請繼續往下看……

2. 準備一下

請不要把你的學習Java之路和其它計算機技術分開看待，技術的聯繫往往是千絲萬縷的，你應該掌握一些學習Java所涉及的基礎知識，對於 “CLASSPATH要怎麼設置啊”、“跪求JDK下載地址”等等問題，你不該問，因為Internet上太多答案了，甚至換個角度說，你是不是還不適合直接學習編程？

1）買本Java學習用書。

JDK 6正式版剛剛推出，市面上你暫時買不到JDK 6的書籍，但我仍推薦你買一本適合入門的、較新JDK版本的Java書籍，那麼，你現在選擇一本講述JDK 5的入門書籍還是有條件的。我可以推薦一些入門書，但是我不打算這麼做，因為合我口味的，不一定適合你。但無論如何，《Thing In Java》絕對不應該作為你入門Java的第一本書籍！

記住，網絡上學習Java的資源很多，但基本不夠系統，擁有一本Java入門書籍，是你系統學習Java的基礎。

2）準備Java學習環境。

準備你的學習環境，很簡單，安裝JDK 6，然後用類似UltraEdit、EditPlus的文本編輯器配置你的學習環境，Internet上有很多關於如何配置的文章。初學Java，不建議用IDE工具，通過一行行的敲代碼，你會碰到很多問題，只有這樣，你才能學會怎樣解決問題，並加深自己對Java的理解。

準備好後，開始進入激動人心的Java學習里程吧！

3. Java基礎學習之路

學習Java的過程雖然辛苦些，但又是處處有精彩！學習過程中的心態一定要保持專一，網上關於語言間的“PK”到處都是，別被浮躁影響！認準了Java，你就堅持！克服心魔，恆心最終會給你回報的。

Java的體系分為Java SE、Java EE和Java ME（JDK 5.0以前分別叫J2SE、J2EE和J2ME），Java的敲門磚就是Java SE了，也就是你要入門學習的內容，不論你日後是選擇哪個體系領域作為發展方向，你都得從Java SE起步。

學習Java SE，打好Java基礎；如果想學Java EE（對不起，我不了解Java ME，所以我無法涉及Java ME的相關內容），對於AWT、Swing是否要學習呢，我個人是覺得還是要知道其所以然的，特別是其事件處理模式，我強烈建議初學者一定要弄清楚，其他具體的開發就不一定要全面掌握了，畢竟AWT、Swing方面的內容足夠用幾本大部頭的書才能描述詳盡；當然，如果你的工作就是做 AWT、Swing開發，那就另當別論了。

I/O、Thread都是基礎之一。

4. Java EE學習之路

學習了Java SE，還只是完成“萬里長征”的第一步。

接下來選擇學習Java EE或是Java ME（或者你還想不斷深入學習Java SE，只要你喜歡，你可以一直深入下去，就像前面所說的，我不會講到Java ME的學習）；估計選擇Java EE方面的學習者會多一些，Java EE所涉及技術非常多，考慮到初學者的接受程度，我會盡量從最常用的角度來介紹。

學習Java EE，在開發環境上不建議再用文本編輯器，我感覺NetBeans 5.5（目前最高正式版本）很適合初學者，我個人也很喜歡NetBeans，如果你喜歡用別的IDE如Eclipse，都沒問題，看自己喜歡吧。

4.1 學習JSP/Servlet

Java EE最高版本目前是5.0版本。

在Java EE中，首先要學習JSP/Servlet（結合Tomcat、MySQL）技術，建議JSP1.2/2.X的知識都要掌握，畢竟現在很多的在用系統都還是基於JSP1.2，學習JSP，還必須掌握一些外延技術，如：你還得掌握HTML基礎知識，最好再掌握些JavaScript（目前正火的AJAX技術之一）、CSS的技術，而了解XML是必不可少的（至少描述性配置信息是通過XML來描述的）。在學習JSP/Servlet過程中，應該結合學習 JDBC、數據庫開發技術，畢竟絕大多數Java Web項目都是和數據庫緊密結合的。

4.2 學習數據庫開發技術

這裡我想重點說一下數據庫開發技術，數據庫技術是做業務系統必備技能，Java Web開發人員最低程度都應該掌握SQL語句的使用！數據庫技術大體可分為DBA技術和數據庫開發技術，對於開發而言，應側重數據庫開發技術，而數據庫基本操作，也是要掌握的。常用數據庫有DB2、Oracle、SQL Server、MySQL等，你可以結合實際需要，選擇一種數據庫，並花大力氣掌握其開發技術。

記住，學習數據庫開發技術和學習Java EE，是相對獨立的，你可以在學習JSP/Servlet的同時，學習數據庫開發技術（如SQL語句等），或者先學數據庫開發技術，之後再學習JSP/Servlet。

4.3 學習Java EE其它開發技術

再往後，可以學習一些EJB的知識，目前EJB最新版本是3.0，其和前面的2.X版本相比，有較大不同，考慮到目前EJB 2.X還有很大的應用市場，建議結合學習EJB 2.X/3.0。在學習EJB過程中，應同時掌握一種企業級應用服務器的使用（如 WebSphere、Weblogic、Sun Applcation Server或JBOSS等，目前Sun Applcation Server 9.X和JBOSS都可支持EJB 3.0）。

之後的學習中，再逐漸擴展到其他Java EE技術。

5. 之後

等你對Java EE有些感悟的時候，你自然就會想不斷擴展你的知識面，這時候你可以學習Spring、Hibernate，以及各種Web框架（如Struts、JSF、Webwork或是Tapestry等）。

隨着技術、經驗的不斷積累，你會逐步關注分析、設計等更高層次的知識，這時候，你可進一步學習相關的UML、模式等知識（積累了一定經驗，你就可以安排自己學習這些知識了）。

6. 小結

永遠記住：自始至終，實踐是學習Java技術歷程中極其重要的一環。脫離了實踐，是學不好技術的！

Java學習、實踐之路依然沒有銀彈，況且一步步走來，要學的東西很多，勤奮是金！

善於利用Internet上眾多的資源，多吸取些別人的經驗。

目前關於Java的爭論很多，如“Java正走下坡路”、“Ruby必將取代Java”等論點甚囂塵上，但正如我前面所言，這是一種浮躁的表現，Java的前景非常好，特別是Java開源以後！就讓他們去吵去吧，掌握了Java，你就掌握了當前最火的技術。

“梅花香自苦寒來”，當你掌握了紮實的Java開發基礎，你就能把手中的這把“屠龍刀”、“倚天劍”舞得風聲水起！那時，你一定會有一種成就感。

以上，你大概了解應當如何學習Java了么？

Java 中的一些小問題~

如果你了解它們在內存里的關係就會懂了

A里有個對象B

A a = new A()時，裡面的b也new了，這時內存堆里有兩個實例，內存棧里有兩個引用分別指向堆里的兩個實例，

如果你把a的引用指向了null，對於你的問題b是否會等於null，這有兩種情況

一種是：實例a被一個以上的引用指向，a是其中一個，如果a指向了null，但是實例a還有其他引用指向，b不會等於null

第二種是：實例a只有一個引用指向，當你把這個引用指向null後，那麼實例就沒有引用指向它了，那麼java的垃圾回收器就會把實例a這個銷毀，當然裡面的b也會銷毀，但是，如果裡面的實例b在外部還有其他的引用指向的話，那麼b也還是會存在

這個要自己慢慢做實驗來了解比較好

向你上面的程序，你把a指向null，那麼你要怎麼訪問b？調用a.getB()不就出現NullPointerException了嗎

但是你可以這樣

A a = new A();

A a1 = a;

a = null;

a1.getB();你看b是不會為空的