第一篇：java實用總結

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

java包含三大分支:

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

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

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

現在就知道J2EE是做什么的了吧

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

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

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

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

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

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

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

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

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

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

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

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

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

現在你也就知道JSP了哈!

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

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

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

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

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

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

第二篇：java總結

將數據成員聲明為靜態的，那么每次調用的時候，靜態成員的值并不會因之而改變。

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

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

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

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

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

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

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

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

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

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

容器有set list queue和map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

java異常

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

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

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

java

IO系統

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

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

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

java 線程

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

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

就可以限制線程的數目為一。

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

下面的就是圖形界面了。

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

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

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

第三篇：Java學習總結

8月份學習總結

目錄一、二、1)

2)

3)

4)

5)

6)

7)

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

（一）....................4 循環結構

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

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

? 初識Java

? 變量、數據類型和運算符

? 運算符和基本選擇結構

? 復雜選擇結構

? 循環結構

（一）? 循環結構

（二）? 數組

二、主要知識點概括

1)初識Java

? 主要知識點

① Java應用程序開發基本步驟。

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

? 重點關注

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

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

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

④ Java對大小寫敏感。

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

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

2)變量、數據類型和運算符

? 主要知識點

① 常用數據類型。

② 變量的聲明與賦值。

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

④ 數據類型轉換。

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

? 重點關注

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

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

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

③ 聲明變量后養成變量賦初值習慣。

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

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

? 主要知識點

① boolean類型變量。

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

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

? 重點關注

① 優先級：++、--、!>算術運算符>比較運算符>&&>||。

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

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

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

4)復雜選擇結構

? 主要知識點

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

② switch選擇結構。

③ 用戶輸入信息判斷。

? 重點關注

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

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

if結構沒有此限制。

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

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

然后在選擇結構內判斷輸出的字符串，選擇結構外統一輸出所有內容，實現程序優化。

5)循環結構

（一）? 主要知識點

① while循環語句的使用。

② do while 循環語句的使用。

③ 程序調試。

? 重點關注

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

環條件三者間的關系需合乎邏輯，確保循環次數正確以及不出現死循環。

② while循環的特點是先判斷，后執行；do-while循環的特點是先執行后判斷。根據要

實現的功能判斷使用何種循環語句。

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

不同的輸入提示。

④ My eclipse中調試程序設置斷點后按F5單步跳入，F6單步跳過，F7用于單步跳入后的返回。

6)循環結構

（二）? 主要知識點

① for循環語句的使用。

② break與continue語句的使用。

? 重點關注

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

② 循環次數確定時選用for循環結構。

③ break語句實現直接跳出循環體，去執行循環塊下一條語句。

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

環中。

7)數組

? 主要知識點

① 數組的定義。

② 數組元素的訪問。

③ 數組的輸入與輸出。

④ 數組元素升序排列。

⑤ 基本數據類型與引用數據類型。

? 重點關注

① 數組的下標是從0開始的。

② 數組元素的錄入可以通過嵌入循環體內進行動態初始化，數組的輸出可以使用一個

循環動態輸出數組元素。

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

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

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

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

三、學習體會

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

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

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

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

第四篇：java總結

調用父類構造方法

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

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

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

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}

對象構造和初始化細節

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

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

1.綁定構造方法參數

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

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

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

5.執行當前構造方法的方法體

==操作符與equals方法

==操作符與equals方法的區別：

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

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

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

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

由裝箱引發的——Integer比較的來龍去脈

前置知識： 眾所周之，java是保留了int，char等基本數據類型的，也就是說int類型的并不是對象，然而有些方法卻需要object 類型的變量，所以java使用了裝箱機制，我們可一自豪的這樣聲明一個整型變量：Integer a = new Integer(10);那么整型的a也就是對象了，那這句是什么意思呢：Integer a= 10;java中可以這樣聲明一個對象嗎？當然不是，從jdk1.5后，java實現了自動裝箱，也就是自動將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的兩個數為啥走向了“反目成仇”的地步呢？憑啥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循環對數組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關鍵字大咧咧的杵在哪呢，對靜態的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數據，那么當我們Integer b = 127的時候，并沒有new出一個新對象

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

然后我們在看Integer c = 128;Integer d = 128;這兩句。現在不用我說就應該能明白了吧，當數據不再-128到127之間時，是不執行return

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

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

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

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關鍵字大咧咧的杵在哪呢，對靜態的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數據，那么當我們Integer b = 127的時候，并沒有new出一個新對象來，而是共享了a這個對象的引用，記住，他們共享了同一個引用?。?/p>

呵呵，博主我被你這句話小小的誤導了一下，其實你這里說的原理沒錯，但是把位置說錯了，這段代碼只是初始化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.驗證數組Arrays類和Collection類

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

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

前三章重點

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

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

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

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

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

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

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

第四五章重點

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

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

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

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

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

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

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

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

9.抽象類：

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

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

10.接口：

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

（2）用關鍵字interface來聲明接口，用關鍵字imlpements來實現接口。

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

（4）實現接口的非抽象類必須實現接口的所有方法。

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

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

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

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

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

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

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

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

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

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

1.流--字節流和字符流；

流--節點流和處理流。

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

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