第一篇：java實用總結

java是一種解釋型語言，但它的源文件要編譯成java字節(jié)碼即.class文件,然后在java虛擬機里運行.jsp是一種WEB開發(fā)技術，它在特定的WEB容器里運行,WEB容器先把jsp轉化成Servlet文件(即.java文件)，然后編譯成.class文件然后在java虛擬機里運行。javascript是一種瀏覽器腳本語言,它被瀏覽器解釋執(zhí)行.這三種語言都采用java的語法。

java包含三大分支:

1.J2SE--java standard edition--標準版本,這個是下面兩個的基礎!一般是位于客戶端的應用;

2.J2ME--java Micro edition--一般位于嵌入式應用,例如手機游戲

3.J2EE--java Enterprise Editon--一般為服務器端程序的應用:例如JSP站點!

現(xiàn)在就知道J2EE是做什么的了吧

首先java它對開發(fā)基于Web的多層{即是J2EE}應用提供了功能上的支持。它包含13種核心技術規(guī)范：

（1）Java Database Connectivity(JDBC)以一種統(tǒng)一的方式來對各種各樣的數(shù)據(jù)庫進行存取

（2）Java Naming and Directory Interface(JNDI)用于名字和目錄服務，它提供了一致的模型來存取和操作企業(yè)級的資源如DNS和LDAP，本地文件系統(tǒng)等

（3）Enterprise Java Beans(EJB)提供了一個框架來開發(fā)和實施分布式商務邏輯，顯著地簡化了具有可伸縮性和高度復雜的企業(yè)級應用的開發(fā)

（4）JavaServer Pages(JSPs)用以創(chuàng)建動態(tài)網頁（5）Java servlets提供的功能大多與JSP類似，不過實現(xiàn)的方式不同

（6）Remote Method Invocation(RMI)在遠程對象上調用一些方法，使用了連續(xù)序列方式在客戶端和服務器端傳遞數(shù)據(jù)

（7）Interface Description Language(IDL)將Java和CORBA集成在一起

（8）Java Transaction Architecture(JTA)可以存取各種事務

（9）Java Transaction Service(JTS)規(guī)定了事務管理器的實現(xiàn)方式

（10）JavaMail 用于存取郵件服務器的API，它提供了一套郵件服務器的抽象類

（11）JavaBeans Activation Framework(JAF)JavaMmail利用JAF來處理MIME-編碼的郵件附件,MIME的字節(jié)流可以被轉換成JAVA對象，或者轉換自JAVA對象

（12）Java Messaging Service(JMS)是用于和面向消息的中間件相互通信的應用程序接口(API)（13）Extensible Markup Language(XML)XML是一種可以用來定義其它標記語言的語言

所以你說的JSP是Java在web上面[一般來說java的web應用成為J2EE]的應用的一個分支而已!

現(xiàn)在你也就知道JSP了哈!

很多初學習者對JavaScript、Java、Jsp、J2ee之間的關系與區(qū)別總是感到很困惑，為了幫助大家快速理解幾者之間的關系，我們進行了如下解釋說明：

1.JavaScript用于編寫嵌入在網頁文檔中的程序,它由瀏覽器負責解釋和執(zhí)行，可以在網頁上產生動態(tài)的顯示效果和實現(xiàn)與用戶交互的功能，譬如，讓一串文字跟著鼠標移動，讓一個圖標在網頁漂浮移動，驗證用戶輸入的信用卡號的格式正確與否，等等特效網頁功能。2.Java則是一種基礎性的語言，學習jsp,j2ee都要有java的基礎。無論你是想成為詩人，還是小說家，還是散文家，甚至就是當記者，你都要學習語文吧，Java就相當于語文、Jsp、J2ee則相當于小說、散文等。

學好了語文，你能否就會有一份好的職業(yè)呢？不見得吧，但至少機會要多多了，語文學得越好，就更容易成為小說家，或是記者等等了。要想成為記者、散文家等等，沒有語文是怎么都不行的。

3.jsp用于讓www服務器產生出內容可以變化的網頁文檔和對用戶提交的表單數(shù)據(jù)進行處理，例如，顯示留言內容，留言內容總是在增加的，所以，傳遞給用戶瀏覽器的網頁文件內容是需要改變的，這就是jsp來實現(xiàn)的。將用戶留言插入到數(shù)據(jù)庫中，也是jsp來實現(xiàn)的。

4.j2ee用于開發(fā)大型的商業(yè)系統(tǒng)，例如，你在各個銀行之間的取款，存款，銀行之間要互通有無，執(zhí)行存取款的記錄操作，還要進行安全性檢查，不能誰都可以來查帳，還要考慮網絡斷線等問題。

使用j2ee，你就不用編寫這些底層的細節(jié)程序代碼了，而將精力集中到應用的業(yè)務流程設計上。

第二篇：java總結

將數(shù)據(jù)成員聲明為靜態(tài)的，那么每次調用的時候，靜態(tài)成員的值并不會因之而改變。

如果想在主函數(shù)調用函數(shù)（不是有對象進行調用），比如while（test（）），那么test（）必須聲明為靜態(tài)的。

構造器，在c++中叫構造函數(shù)，也可以叫做構造方法，每當創(chuàng)建一個對象的時候，就會調用構造器。

構造器可以分為默認構造器和帶參數(shù)的構造器，默認構造器就是無參的構造器，構造器的作用是使類中的成員初始化。

。構造器的互相調用可以使用this，主要就是在構造器內使用this（參數(shù)），里面的參數(shù)個數(shù)和類型決定調用什么構造器。

java中初始化的順序，首先是創(chuàng)建一個對象，如果是創(chuàng)建的靜態(tài)的對象和非靜態(tài)的對象，先調用靜態(tài)的對象，然后系統(tǒng)就會在堆中給他分配內存空間，如果在靜態(tài)對象的類中有靜態(tài)的成員類和非靜態(tài)的成員類，先初始化靜態(tài)的成員類，然后在調用非靜態(tài)的成員類，最后調用自己的構造函數(shù)，如果在主函數(shù)創(chuàng)建的是非靜態(tài)的對象，如果創(chuàng)建的類中有靜態(tài)成員類，不進行初始化，只進行非成員類的初始化，最后執(zhí)行自己的構造函數(shù)。

引進類庫的時候要注意如果引進的是同名的類或者方法，在不使用的情況下，系統(tǒng)不會報錯，但是，一不小心就會有錯誤。，但是，如果類中的私有方法不能被繼承，在向上轉型的時候就會出錯，所以多態(tài)并不適合私有方法。而final不能被覆蓋，所以在運行的時候也會出錯。如果使用static，父類的靜態(tài)方法會被子類的靜態(tài)方法隱藏，而父類是靜態(tài)，子類不是靜態(tài)的，則會編譯出錯。

空白final增加了程序的靈活性，但必須在構造器中給他賦值（可以是有參的構造器，也可以是無參的構造器），你可以定義一個final類，里面的屬性是可以引用改變它。

抽象類，如果父類是抽象類，則需要把父類的方法在子類中全部實現(xiàn)，如果父類不是抽象類，而父類的父類是抽象類，不需要將方法實現(xiàn)。如果方法是抽象的，那么就需要把類也定義成抽象的。

如果抽象類有final，static定義的方法，則子類中的方法不需要實現(xiàn)的。私有的更沒法實現(xiàn)了。因此，當我們實現(xiàn)一個接口的時候，就需要將接口的方法實現(xiàn)，是因為接口就是抽象的，在接口中所有的方法都沒有實例化。

在java中存在著內部類，就是在類中定義類，這跟內部成員類是有區(qū)別，內部類可以將方法和屬性在這個類中實現(xiàn)初始化形如A.a a=t.new a()的形式。當然也有匿名內部類等。下面說下容器也叫集合。

容器有set list queue和map

你可以聲明一個容器來保存一個對象或多個對象，通常我們add方法和get方法將某個對象加入容器和得到加入容器的對象，如果父類添加到

容器的對象，那么子類也可以加入到容器中，但是，如果是子類的子類，那么你就需要提示當前的是什么類型的，否則的話，編輯器將會報錯，下面來討論下加入容器中的順序與重復值的問題，list必須按照順序添加元素，而set不能有重復元素。

剛剛我們討論add方法每次加一個元素到容器中，那么是否可以天健一組元素到容器中那，那么，使用我們可以（容器對象）。addall方法

運行速度相對較快，我們還可以使用Collections.addall（），把一些值賦給某個對象，而這種方法似乎方便的多。

還有許多排序方法，當然，你可以再實踐中檢驗當前的排序問題。

下面有 continous，indexof remove等一些方法，還是需要在實踐中檢驗。

迭代器是個好東西，他可以使容器的類型發(fā)生多用，要首先見對象轉換成iterator類型，那么就需要調用iterator()方法，下面就需要檢驗它是否

有下一個值，如果有的話，就把它的下一個值傳給當前容器的對象，本質上傳的應該是引用，下面就可以輸出當前的引用，但是你可以賦給toString方法

使他可以傳進一個對象進來。對象的getfirst()和element（）方法傳的是當前對象的頭對象，如果為空，則拋出異常，peek（）方法，如果列表為空，則

返回null。remove和removefirst（）如果列表為空，則返回異常，否則，返回移除當前的對象，poll（）方法當列表為空時，返回null，addfirst和add和addlast

一樣都是把對象加到列表的尾部。

棧是先進后出或后進先出的容器就像子彈夾一樣。模擬下?? 就是addfirst（）不斷的將元素加到列表的末尾，然后，removefirst將的第一個元素去掉。

set元素的鍵 值相對，鍵使用的是keyset方法，值是value是方法。要想鍵值相對，只需要使用兩個for循環(huán)。

queue是先進先出的容器??? 使用offer方法將對象依次向后排，然后使用removefirst就可以發(fā)現(xiàn)隊列的性質。

java異常

異常通常來捕捉錯誤，這些錯誤，分為Error錯誤，這些錯誤如 內部內部錯誤和資源耗盡錯誤，通常是不可預知的，我們似乎通知用戶，無能為力，第二種是運行錯誤，在運行錯誤中，如果是文件操作，你不捕捉異常，系統(tǒng)將會報錯，而令一個錯誤就是語法，這種錯誤你可以盡可能的避免，但是有些錯誤，在編程的時候還需要提醒用戶，而且盡可能的捕捉。

在異常處理的過程中如果在try{}中加入return語句，那么finally中的語句也會被執(zhí)行，拋出異常后，try{}下面的語句將不會被執(zhí)行，finally中的語句一定被執(zhí)行，但是如果finally語句

放在try{}和catch{}之間，那就悲劇了，可能會發(fā)生異常丟失，在構造器中盡量不要捕捉異常。通常情況下，你知道怎樣捕捉異常才會去捕捉異常。

java

IO系統(tǒng)

javaIO系統(tǒng)通常進行的文件的操作和網絡的操作和內存的操作。有輸入流和輸出流，輸入流就是把文件或者網絡中的東西寫到內存，輸出流就是把東西輸入到文件等。

輸入流通常使用的是write（）方法將數(shù)據(jù)寫到文件。輸出流通常是通過read（）方法將數(shù)據(jù)讀出來。在文件的外面可以加上緩沖流? 或者dateoutputstream來對整數(shù)，double等進行

操作。加入緩沖流可以提高速度，可以1行1行的讀。對文件進行處理通常是字節(jié)和字符，有時候我們可以講字節(jié)轉化成字節(jié)。還有對壓縮文件的讀取等等。

java 線程

所謂線程? 就是一個程序有多個任務在執(zhí)行，每個任務都需要使他啟動，通常情況下需要將線程與集合聯(lián)系在一起，但在集合中有安全的和不安全的。那么線程將同步運行。但是有時候我們通過start（）方法來運行線程是相當消耗系統(tǒng)資源的，因此，java se5提供了一中

新的方法來啟動線程，我們可以通過限制線程的數(shù)目來減小資源的浪費，如果我們想每次只啟動一個線程，而且把這個線程結束，那么

就可以限制線程的數(shù)目為一。

當然如果我們想加入一個線程，通常情況下，我們可以通過加入join（）的方法，他會在某個線程結束之后，啟動join（）加入的線程，這個線程是可選的，如果這個線程被打斷了，通常這個線程會拋出異常，然后，join（）方法加入的線程會立刻被執(zhí)行。

下面的就是圖形界面了。

可以添加按鈕，文本框，密碼框，和各種布局管理器。以及如何實現(xiàn)監(jiān)聽等等。感覺太沒意思了

下面就說下坦克大戰(zhàn)如何實現(xiàn)的。也就是多線程，圖形界面，各種類，監(jiān)聽，集合等構成的像放電影一樣的由你操作的游戲。當我們從鍵盤中進行前進或者退后的操作時，那么面板中必須不斷重新畫出這個坦克，才能使我們感覺坦克在移動，那么以前的坦克哪里去了，那他肯定是垃圾了，所以一定會被回收，當然畫出子彈的狀況也是如此。

而敵人的坦克也是這樣畫的，只不過是個死循環(huán)。

第三篇：Java學習總結

8月份學習總結

目錄一、二、1)

2)

3)

4)

5)

6)

7)

三、前言..........................1 主要知識點概括....................2 初識Java.........................2 變量、數(shù)據(jù)類型和運算符.........................2 運算符和基本選擇結構......................3 復雜選擇結構........................3 循環(huán)結構

（一）....................4 循環(huán)結構

（二）....................4 數(shù)組..........................5 學習體會.........................5一、前言

在青鳥將近2個月的學習生活當中，從計算機基礎學到了Java程序基礎，個人感到在青鳥的學習十分的充實。不僅掌握了必須的理論基礎，也通過實踐鞏固了各種程序基礎。同時，在這段學習期間，我也逐步融入了171班這個大家庭。使用Java理解程序邏輯這門課程將近上了一半，主要學習了以下7個內容：

? 初識Java

? 變量、數(shù)據(jù)類型和運算符

? 運算符和基本選擇結構

? 復雜選擇結構

? 循環(huán)結構

（一）? 循環(huán)結構

（二）? 數(shù)組

二、主要知識點概括

1)初識Java

? 主要知識點

① Java應用程序開發(fā)基本步驟。

② Java程序的結構、編寫規(guī)范以及注釋。

? 重點關注

① 源程序.java文件編譯后變成.class文件，通過控制臺使用命令“javac 空格 文件名.java”對源程序進行編譯。再通過“java 空格 文件名”命令運行編譯后的class文件。

② public修飾的類的名稱必須與Java文件同名。

③ main（）方法中的void不可少。

④ Java對大小寫敏感。

⑤ 每個完整的語句都要以“;”結束。

⑥ println語句中用于輸出字符串的引號必須是英文的引號。

2)變量、數(shù)據(jù)類型和運算符

? 主要知識點

① 常用數(shù)據(jù)類型。

② 變量的聲明與賦值。

③ 賦值運算符與算術運算符。

④ 數(shù)據(jù)類型轉換。

⑤ 調用Scanner類實現(xiàn)從控制臺獲取鍵盤輸入信息。

? 重點關注

① 自動類型轉換的條件：(1)兩種類型需兼容；(2)目標類型大于源類型。

② 輸入公式需注意數(shù)據(jù)類型，如雙精度變量degreeCel 和degreeFah。不管degreeFah為何數(shù)，經過degreeCel = 5/9*(degreeFah-32)運算后，degreeCel 始終為0.0，沒有

得到想要的結果。是由于5/9的結果為整形，運算結果為0，乘以(degreeFah-32)后始終為0，需把9改為9.0。

③ 聲明變量后養(yǎng)成變量賦初值習慣。

④ 使用Scanner input語句需記得在程序開頭調用Scanner類。

3)運算符和基本選擇結構

? 主要知識點

① boolean類型變量。

② 使用關系運算符比較返回boolean類型結果。

③ if選擇結構與if else選擇結構

? 重點關注

① 優(yōu)先級：++、--、!>算術運算符>比較運算符>&&>||。

② 邏輯&&和邏輯||具有判斷短路特點。

③ if語句后面的條件判斷可以放置boolean類型變量或返回boolean類型結果的表達式。④ if語句執(zhí)行的代碼塊需用大括號括起來。

⑤ char類型變量與字符比較可以用‘== ’，String類型變量與字符比較用.equals(“ ”)。

4)復雜選擇結構

? 主要知識點

① 多重if選擇結構、嵌套if選擇結構。

② switch選擇結構。

③ 用戶輸入信息判斷。

? 重點關注

① 先確定將要實現(xiàn)功能的邏輯結構，從而選擇合適的if結構實現(xiàn)代碼。

② switch結構只能處理等值條件判斷，且條件必須是整形變量或字符型變量，而多重

if結構沒有此限制。

③ 通過input.hasNext()==true語句進行用戶輸入信息類型判斷。獲取用戶輸入信息的語句需處于input.hasNext()==true的判斷結構內。

④ 多個分支的輸出內容含有大部分相同字眼時，可把不同的字眼放入字符串變量內。

然后在選擇結構內判斷輸出的字符串，選擇結構外統(tǒng)一輸出所有內容，實現(xiàn)程序優(yōu)化。

5)循環(huán)結構

（一）? 主要知識點

① while循環(huán)語句的使用。

② do while 循環(huán)語句的使用。

③ 程序調試。

? 重點關注

① 編寫循環(huán)結構代碼時需注意循環(huán)變量的初值，循環(huán)操作中對循環(huán)變量值的改變和循

環(huán)條件三者間的關系需合乎邏輯，確保循環(huán)次數(shù)正確以及不出現(xiàn)死循環(huán)。

② while循環(huán)的特點是先判斷，后執(zhí)行；do-while循環(huán)的特點是先執(zhí)行后判斷。根據(jù)要

實現(xiàn)的功能判斷使用何種循環(huán)語句。

③ 當循環(huán)體內存在循環(huán)監(jiān)控控制臺輸入信息體系時，可通過設置標志flag去控制輸出

不同的輸入提示。

④ My eclipse中調試程序設置斷點后按F5單步跳入，F(xiàn)6單步跳過，F(xiàn)7用于單步跳入后的返回。

6)循環(huán)結構

（二）? 主要知識點

① for循環(huán)語句的使用。

② break與continue語句的使用。

? 重點關注

① for語句的語法格式：for(參數(shù)初始化；條件判斷；參數(shù)值改變){循環(huán)體}。

② 循環(huán)次數(shù)確定時選用for循環(huán)結構。

③ break語句實現(xiàn)直接跳出循環(huán)體，去執(zhí)行循環(huán)塊下一條語句。

④ continue語句實現(xiàn)終止執(zhí)行當前循環(huán)continue語句后的語句，且進入下一次循環(huán)。⑤ break語句和continue語句除了可用于for循環(huán)體外，也適用于while與do while循

環(huán)中。

7)數(shù)組

? 主要知識點

① 數(shù)組的定義。

② 數(shù)組元素的訪問。

③ 數(shù)組的輸入與輸出。

④ 數(shù)組元素升序排列。

⑤ 基本數(shù)據(jù)類型與引用數(shù)據(jù)類型。

? 重點關注

① 數(shù)組的下標是從0開始的。

② 數(shù)組元素的錄入可以通過嵌入循環(huán)體內進行動態(tài)初始化，數(shù)組的輸出可以使用一個

循環(huán)動態(tài)輸出數(shù)組元素。

③ 利用Arrays類提供的sort()方法對數(shù)組元素進行升序排序。

④ int、double、char、boolean類型是基本數(shù)據(jù)類型，String和數(shù)組是引用數(shù)據(jù)類型。

基本數(shù)據(jù)類型變量聲明后會賦予一個默認值。

⑤ 數(shù)組引用賦值需注意引用數(shù)組的賦值將會同步改變被引用數(shù)組的原值。

三、學習體會

首先，想成為一個專業(yè)的程序員，英文詞匯量首先要足夠的龐大。就拿變量聲明來講，變量命名應該做到顧名思議，若詞匯量的匱乏，變量的命名很難達到要求。因此，需要更多的時間去積累英文知識。

另外，通過這一個月以來的學習發(fā)現(xiàn)編程思想十分重要。每個程序實現(xiàn)之前

都需要構建明確的編程思路。編程思路主要體現(xiàn)在：（1）算法確定。實現(xiàn)最終的算法，可以有多個路徑選擇。不同的編程思路會影響程序的大小以及運行效率；

（2）語句選擇。比如實現(xiàn)特定功能，卻只有一種語句是最適合；（3）程序結構。對于要實現(xiàn)一個較為龐大的體系，需要明確每個功能實現(xiàn)的先后，每個功能實現(xiàn)的先決條件。不然后續(xù)工作將變得十分混亂，代碼冗余。

第四篇：java總結

調用父類構造方法

? 在子類的構造方法中可使用super(argument_list)語句調用父類的構造方法

? 如果子類的構造方法中沒有顯示地調用父類構造方法，也沒有使用this關鍵字調用重載的其它構造方法，則系統(tǒng)默認調用父類無參數(shù)的構造方法

? 如果子類構造方法中既未顯式調用父類構造方法，而父類中又沒有無參的構造方法，則編譯出錯

1public class Person {

3private String name;

4private int age;private Date birthDate;

7public Person(String name, int age, Date d){ 8this.name = name;

9this.age = age;

10this.birthDate = d;

11}

12public Person(String name, int age){ 13this(name, age, null);

14}

15public Person(String name, Date d){ 16this(name, 30, d);

17}

18public Person(String name){

19this(name, 30);}

21// ……

22}

1public class Student extends Person {

2private String school;

4public Student(String name, int age, String s){ 5super(name, age);

6school = s;

7}

8public Student(String name, String s){

9super(name);

10school = s;

11}

12public Student(String s){ // 編譯出錯: no super()13school = s;

14}

15}

對象構造和初始化細節(jié)

? 分配存儲空間并進行默認的初始化

? 按下述步驟初始化實例變量

1.綁定構造方法參數(shù)

2.如有this()調用，則調用相應的重載構造方法，然后跳轉到步驟5

3.顯式或隱式追溯調用父類的構造方法(Object類除外)

4.進行實例變量的顯式初始化操作

5.執(zhí)行當前構造方法的方法體

==操作符與equals方法

==操作符與equals方法的區(qū)別：

? 引用類型比較引用；基本類型比較值；

? equals()方法只能比較引用類型，“==”可以比較引用類型及基本類型；

? 特例：當用equals()方法進行比較時，對類File、String、Date及封裝類（Wrapper Class）來說，是比較類型及內容而不考慮引用的是否是同一個實例；

? 用“==”進行比較時，符號兩邊的數(shù)據(jù)類型必須一致(可自動轉換的基本數(shù)據(jù)類型除外)，否則編譯出錯；

由裝箱引發(fā)的——Integer比較的來龍去脈

前置知識： 眾所周之，java是保留了int，char等基本數(shù)據(jù)類型的，也就是說int類型的并不是對象，然而有些方法卻需要object 類型的變量，所以java使用了裝箱機制，我們可一自豪的這樣聲明一個整型變量：Integer a = new Integer(10);那么整型的a也就是對象了，那這句是什么意思呢：Integer a= 10;java中可以這樣聲明一個對象嗎？當然不是，從jdk1.5后，java實現(xiàn)了自動裝箱，也就是自動將Integer a =10 中的int類型的10轉化為了 Integer類型。好，有了前面的只是我們且先看一個題目：

Integer a = 127;

Integer b = 127;

Integer c = 128;

Integer d = 128;

System.out.println(a==b);

System.out.println(c==d);

答案是什么呢？ 如果您回答true，false，那么很遺憾的告訴你，哈哈，其實你答對了??！

那我們暈了就相差1的兩個數(shù)為啥走向了“反目成仇”的地步呢？憑啥127等于127，我128就不等于128呢？且聽我慢慢道來，Integer a =127,Integer a=128。

127，128應該不會造成什么差異吧，難道是自動裝箱的過程有貓膩？找下源碼看看：

private static class IntegerCache {

private IntegerCache(){}

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {

for(int i = 0;i < cache.length;i++)

cache[i] = new Integer(i128);

}

這是用一個for循環(huán)對數(shù)組cache賦值，cache[255] = new Integer(255-128),也就是newl一個Integer(127),并把引用賦值給cache[255],好了，然后是Integer b= 127,流程基本一樣，最后又到了cache[255] = new Integer(255-128),這一句，那我們迷糊了，這不是又new了一個對象127嗎，然后把引用賦值給cache[255]，我們比較這兩個引用（前面聲明a的時候也有一個）,由于是不同的地址，所以肯定不會相等，應該返回false??！呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關鍵字大咧咧的杵在哪呢，對靜態(tài)的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數(shù)據(jù)，那么當我們Integer b = 127的時候，并沒有new出一個新對象

來，而是共享了a這個對象的引用，記住，他們共享了同一個引用??！，那么我們進行比較a==b時，由于是同一個對象的引用（她們在堆中的地址相同），那當然返回true了！！

然后我們在看Integer c = 128;Integer d = 128;這兩句?，F(xiàn)在不用我說就應該能明白了吧，當數(shù)據(jù)不再-128到127之間時，是不執(zhí)行return

IntegerCache.cache[i + offset];這句的，也就是不會返回一個static的引用，而是執(zhí)行了return new Integer(i);于是當 Integer d = 128 時，又會重新返回一個引用，兩個不同的引用

在做c==d 的比較時當然返回false了！

下面附上本程序的字節(jié)碼以供喜歡底層的讀者參考：

Compiled from “CompareInteger.java”

public class CompareInteger extends java.lang.Object{

public CompareInteger();

Code:

0:aload_0

1:invokespecial#1;//Method java/lang/Object.“”:()V4:return

public static void main(java.lang.String[]);

Code:

0:bipush 127

2:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

5:astore_1

6:bipush 127

8:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

11: astore_2

12: sipush 128

15: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

18: astore_3

19: sipush 128

22: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

25: astore 4

27: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

30: aload_1

31: aload_2

32: if_acmpne39

35: iconst_1

36: goto40

39: iconst_0

40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

46: aload_3

47: aload4

49: if_acmpne56

52: iconst_1

53: goto57

56: iconst_0

57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return

}

評論：呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關鍵字大咧咧的杵在哪呢，對靜態(tài)的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數(shù)據(jù)，那么當我們Integer b = 127的時候，并沒有new出一個新對象來，而是共享了a這個對象的引用，記住，他們共享了同一個引用??！

呵呵，博主我被你這句話小小的誤導了一下，其實你這里說的原理沒錯，但是把位置說錯了，這段代碼只是初始化cache：

static {

for(int i = 0;i < cache.length;i++)

cache[i] = new Integer(i-128);

}

但真正讓cache[i]為static變量的是這句代碼：

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];

第五篇：Java總結

Java實驗

1.調試HelloWorld程序

2.this,super,get ,set,把課本90頁程序4.7中的name改成私有變量

3.繼承，重寫，父類引用指向子類對象

4.驗證數(shù)組Arrays類和Collection類

5.編寫一個自己的異常類并捕獲之。

6.編寫一個類，將該類的幾個對象裝入TreeSet容器中，并將該容器的內容通過輸出流寫入文件中。

前三章重點

0.java的數(shù)據(jù)類型：四類八種-（1）布爾類型Boolean;(2)字符類型char;(3)整數(shù)byte,short,int,long;(4)浮點類型：float,double;1.面向對象的3個基本特征：封裝，繼承，多態(tài)。

2.構造方法和普通方法的區(qū)別：對構造方法而言，它有以下特性---（1）方法名必須與要創(chuàng)建對象的類名相同。（2）不允許聲明返回類型，即使聲明為void也不被允許。

3.this關鍵字:是一個引用，this引用指向的是其本身所在方法的當前對象。this的使用方法:(1)調用成員變量；（2）可以用this()調用其他構造函數(shù)。

4.java中只對類成員變量進行自動初始化，而方法內部的局部變量在使用前必須手動初始化。

5.static 關鍵字：可用來修飾類的成員變量和成員方法，需要注意兩點--（1）靜態(tài)方法不能調用類的非靜態(tài)方法，不能訪問類的非靜態(tài)變量。（2）靜態(tài)方法和靜態(tài)變量（非私有的）可以有兩種調用方式，一是實例對象調用，二是類名直接調用。

6.類成員訪問控制修飾符public、private、default(可不寫，即缺省狀態(tài))、protected的使用：public-公用的；private-私有的，只在定義它的類內部使用；default-可以被同一包中的類訪問；protected-既可以被同一包中的類訪問，也可以被不在同一包中的子類訪問。

7.方法的重載：指方法名相同，而方法的參數(shù)列表不相同。參數(shù)列表不同有三層意思：（1）參數(shù)類型不同。（2）參數(shù)順序不同。（3）參數(shù)個數(shù)不同。另外需注意，在同一個類中，當方法名和參數(shù)列表都相同時，訪問控制修飾符或方法返回類型不相同并不是方法的重載，而且這種情況在java中是不被允許的。

第四五章重點

1.繼承：需使用關鍵字extends.在使用繼承時需注意--（1）每個子類只能定義一個超類（父類），即extends后面應且僅應跟一個類名作為該類的父類。（2）父類中的私有屬性和私有方法不能被繼承。

2.方法的重寫：即子類對超類中的方法保持方法名、返回類型和參數(shù)列表不變，重寫了方法體，使子類和超類完成不同的工作。重寫需注意下面幾個關鍵點：（1）超類中的私有方法不能被重寫。（2）訪問限制符強度由低到高依次是：public、protected、default、private,在重寫過程中，如果子類和父類中方法的返回值、方法名及方法的參數(shù)列表都相同，這時，要求子類中該方法的訪問限制符強度不能超過父類的。即如果父類中為public時，子類也只能為public,而不能是余下的三種。

3.重載（overload）和覆蓋（override）的區(qū)別：(1)重載—發(fā)生在一個類的內部或子類與父類之間，要求方法名相同而參數(shù)列表不一樣。（2）覆蓋—只能發(fā)生在繼承過程中，要求子類方法的返回類型，方法名和參數(shù)列表同父類的都相同，而方法體不一樣。

4.構造器的調用順序：先祖先，再客人，最后自己。

5.多態(tài)：指在類繼承中子類和父類中可以有同名但意義或實現(xiàn)方式不同的屬性和方法。分為：覆蓋和重載。多態(tài)的優(yōu)點：因為多態(tài)，可以在程序中對類進行擴展，而不需改變那些操作基類接口的方法。

6.動態(tài)綁定：指在代碼執(zhí)行期間，判斷所引用對象的實際類型，根據(jù)其實際類型調用相應方法。動態(tài)綁定存在的三個必要條件--（1）要有繼承；（2）要有重寫（覆蓋）；（3）父類引用指向子類對象（向上轉型）。

7.Object中常用的方法總結：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，盡可能記幾個，以防老師讓咱們列舉）注：java中Object類是所有類的父類，即java中所有的類都有上述9種方法。

8.對象的比較：注意關鍵字instanceof的使用。

9.抽象類：

抽象方法—用關鍵字abstract修飾的方法，該方法只需方法的聲明，而不需方法的實現(xiàn)（即無方法體）。

抽象類——至少包含一個抽象方法的類，也用abstract關鍵字聲明。（注：（1）抽象類中可以有一些具體方法。（2）抽象類不能實例化。（3）子類繼承抽象類必須實現(xiàn)其抽象方法。）

10.接口：

（1）可以看成是高度抽象的抽象類，但是接口不是類。

（2）用關鍵字interface來聲明接口，用關鍵字imlpements來實現(xiàn)接口。

（3）接口不能有具體方法，不能有實例數(shù)據(jù)，但可以定義常量。

（4）實現(xiàn)接口的非抽象類必須實現(xiàn)接口的所有方法。

（5）每個類可以實現(xiàn)多個接口，這些接口用逗號隔開，同時，一個接口可以被多個類實現(xiàn)。

第六章：重點看一下實驗四

1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必須保持元素的特定順序，常見的實現(xiàn)類有ArrayList和LinkedList；Set不能有重復元素,常見的實現(xiàn)類有HashSet和TreeSet。

Map——一組成對的“鍵值對”對象，即其元素是成對的對象，常見的實現(xiàn)類有HashMap和TreeMap。

第七章 1.異常類的根類是Throwable類，它的兩個直接子類是Error類和Exception類。

2.異常中常用的5個關鍵字為：try,catch,finally,throw,throws.其中，try和catch:用于捕獲異常；finally:無論try塊中的異常是否拋出，finally中的代碼塊總能被執(zhí)行；throw:拋出異常；throws：聲明異常。

3.“未被檢查的異常（Unchecked Exceptions）”和“受檢查的異常(Checked Exceptions)”——

Unchecked Exceptions :編譯器不檢查方法是否處理或拋出的異常，即不做處理，編譯時不報錯。

Checked Exceptions：受編譯器檢查的異常，即不做處理編譯時通不過。

4.常見的幾種Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(盡可能的記幾個吧，以防不測)第八章

1.流--字節(jié)流和字符流；

流--節(jié)點流和處理流。

2.所有的輸入流都是從抽象類InputStream和Reader繼承而來。所有輸出流都是從抽象類OutputStream和Writer繼承而來。3．字節(jié)流：InputStream和OutputStream;字符流：Reader和Writer；

4.節(jié)點流：直接與文件等底層打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.處理流：相當于包裝流，套在節(jié)點流上，方便數(shù)據(jù)處理。相關一些用法，具體參考最后一次實驗。