第一篇：學習JAVA程序課程心得

《Java項目實戰》心得

在學習JAVA面像對象語言中這是一門以網絡技術、多平臺操作、UML及其建模工具使用、JSP技術等為一體的，一門比較熱門的編程語言。

我在本課程中不到了不少的新知識，例如數據庫的多表查詢、多表添加、權限等功能。在學習JAVA中我們跟著老師將理論和實踐將有機的結合在一起。循序漸進的掌握JAVA的一些基礎知識和實際應用。

JAVA是以做一個項目的來考核每一位同學，是以團隊開發為主這樣讓同學進入公司時就有團隊的意識。為了完整個項目是這個小組必需以一個文檔為主這樣可以讓項目很好的進行。

JAVA是以JDBC連接數據庫的這是一種新的技術。在JAVA中數據連接可創建一類這樣可以每次連接數據庫是調用這個類方便了程序的開發。

怎么學習Java開始的兩年我學JAVA就是拿書看，練習書上的例子，但是一直沒有好的效果。后來因為項目需要開始正式使用JAVA開發，我發現以前練習的東西都忘光了，所以不得不在拿起書看。也就是基本上做了無用功了?，F在想來因為大部分是抄來的，不怎么動腦子，所以不清楚為什么要這樣。所以我強烈建議你學習的時候給自己設定一個假想的項目目標，做一個東西出來，網頁也好，application也好，這樣你才會快速地學習。

對java有了一定地感覺以后，你在去看他的DOCUMENT，看他的源碼，我建議你從低版本的JAVA源碼看起，因為他類少，看起來容易懂。然后你就會知道自己以前編碼的東西那些是很幼稚的，是可以用一兩句就能搞定的。

如果你已經稍微有了些感覺，如果覺得合適也可以考慮參加一些培訓，畢竟比自學要輕松些，另外還可以學到別人的一些經驗，比如：清軟Java培訓，一些學員反應不錯的，也建議你們多了解一下其它的培訓機構。

如何解決問題,學習的過程中不可避免的遇到問題，這些問題有的只是一個符號錯了，一個括號少了，這類的問題在他的文檔，或者一般的網站上就能夠找到，尤其是初學者的問題，不會是很難的問題，在你之前已經無數人問過了，不要害怕提問，但是這個問題最好是你找不到答案的時候去提。有的時候人們覺得你這個問題到處都有，是你個人太懶不去找的原因而沒有解決，這樣不愿意回答。

總而言之我在JAVA中學習了團隊精神和一些面像對象的語言編程。

05軟件 王國輝

第二篇：JAVA學習中的心得和小程序

最初接觸JAVA實在大一的時候，當時想著去考計算機等級考試，那個時候就對JACA有一點興趣。但幸運的是，我當時的公選課選的是C語言而且專業課程里面也開了C語言這門課程所以當時選擇了C語言。而現在接觸了JACA，才真正的發現，不同語言不同的魅力！

剛一開始學習java時，我就已經學習過C語言，不過C語言學的不是很好，所以開始看到java的時候我很反感，看著源代碼，都不知道失什么意思。看書的時候一看到源代碼就頭疼，因為根本看不懂。那段時間根本就是一無所獲，在圖書館借了一本書，關java的語法特性，與別的語言相比的優點，什么跨平臺，源代碼公開，什么write once run anywhere，能說得頭頭是道，可是一到具體的問題，想寫一些具體的東西，問題就都來了，根本不知道該怎么下手。漸漸的時間過去了，一點進展都沒有，而后又同學經常來宿舍跟我講解，我很感謝他。慢慢的我也理解了一些知識。從他那里，我認識到，JAVA是一門計算機語言，是人類發明的語言，應該比人類語言更容易學習，只要你有一種必勝學習JAVA心態就可以成功。JAVA學習中，首先要做到課前、課后復習及預習，要時時保持一個清醒的頭腦；多和同學溝通；互相學習；取長補短；在學習中做到幫助他人或他人幫助自己。學習java，的確要學習的東西很多，就像同學提到的。Java不像.net一家獨大，Java的繁盛在于開源社區的龐大，這也帶來了分支太多的問題，怎樣選擇一條好的學習路線，對于初學者來說，的確是一件很迷茫的事。其實不管

java東西再多，總有規律可循。對于學習java基礎的經驗就是多做、多思考，基礎知識的學習不能不求甚解，要追本溯源，弄清問題的本質。C的入門學習過程是比較痛苦的，你要學好需要一定的努力，但是他有一個好處，相對JAVA來說比較集中，不會出現JAVA里面這么多差異。java的學習過程開始比較容易入手，更容易學習。當然現在C#也可以。java還有一個優勢就是在移動設備的開發，所有的java應用版本不同，但是語法一致。java的跨平臺特性使得學習他讓我們可以在不同的場合下使用。而恰恰就是它的種種跨平臺性讓我非常感興趣。我們的社會發展現在越來越集中化，智能化，所有的東西手機，電腦都可以解決，而終端設備之間的通訊就是促進發展的橋梁，JACA具有非常優越的跨平臺性，基本的移動終端都可以利用JACA平臺進行開發，學習。

當然學習的過程中不可避免的遇到問題，這些問題有的只是一個符號錯了，一個括號少了，但只要仔細查找就會發現不會是很難的問題，最最重要的是要學會詢問別人，有這樣一個笑話：一個程序員向上帝許愿希望他有生之年可以編寫出一個完美的程序結果——程序員最后長生不老！雖然只是一個笑話但是也可以反映出世上沒有絕對完美的程序，所以學會詢問別人是最最有效的方法。

編寫一個程序，實現1-100的累加。

public class LeiJia { public static void main(String args[]){

int sum=0;

for(int i=1;i<=100;i++){

sum=sum+i;}

System.out.println(“sum=”+sum);} }

這是一個小程序對我學習有很大的啟發，這個程序是利用循環FOR語句實現了從1到100的數字的累加運算，對比C語言不難發現其實很多的語法應用都是差不多的但JACA卻具有更多的表現形式和不同的書寫規則，但就是多種的表現形式才能夠使它具有這種跨平臺的多兼容性。

在我所學的語言當中，我自認為JAVA是一門比較強大的面向對象的編程語言，不僅僅因為它的跨平臺性，更多的是因為它的靈活多變和實用性較強，可以說比較的經典和強悍。所以學好java語言有很大的用處，在不斷地接觸JAVA中我們更多學到的是不懂就問和自己應該盡自己的全力去嘗試，哪怕失敗，只要自己盡自己的全力，和身邊同學一起探討而不是抄襲，團結合作，發揮團隊意識，最后在自己的努力下，終于運行成功，這種成就感美不可言，心情愉悅至極。

第三篇：學習JAVA心得

學習JAVA心得(2007-07-10 17:44:52)

經?？吹接腥藛栐趺磳WJAVA，無數的問題其實都已經是討論很多編了，我學習JAVA5年，真正覺得有感覺是2003的時候，這么長時間以來有一些想法，寫出來大家共同探討：

1.為什么要學JAVA?

首要的原因當然是為了生活，找份好工作，現在放眼望去，知名公司只會要求兩種語言－c/c++，當然包括后來的NET，和JAVA。其他一些公司可能會要其他的語言，但最終的結果是你會回到這兩類上。前者的入門學習過程是比較痛苦的，你要學好需要一定的努力，但是他有一個好處，相對JAVA來說比較集中，不會出現JAVA里面這么多差異。java的學習過程開始比較容易入手，更容易學習。當然現在C#也可以。java還有一個優勢就是在移動設備的開發，所有的java應用版本不同，但是語法一致。java的跨平臺特性使得學習他讓我們可以在不同的場合下使用。

2.怎么學習java

開始的兩年我學JAVA就是拿書看，練習書上的例子，但是一直沒有好的效果。后來因為項目需要開始正式使用JAVA開發，我發現以前練習的東西都忘光了，所以不得不在拿起書看。也就是基本上做了無用功了?，F在想來因為大部分是抄來的，不怎么動腦子，所以不清楚為什么要這樣。所以我強烈建議你學習的時候給自己設定一個假想的項目目標，做一個東西出來，網頁也好，application也好，這樣你才會快速地學習。

對java有了一定地感覺以后，你在去看他的DOCUMENT，看他的源碼，我建議你從低版本的JAVA源碼看起，因為他類少，看起來容易懂。然后你就會知道自己以前編碼的東西那些是很幼稚的，是可以用一兩句就能搞定的。

3.如何解決問題

學習的過程中不可避免的遇到問題，這些問題有的只是一個符號錯了，一個括號少了，這類的問題在他的文檔，或者一般的網站上就能夠找到，尤其是初學者的問題，不會是很難的問題，在你之前已經無數人問過了，不要害怕提問，但是這個問題最好是你找不到答案的時候去提。有的時候人們覺得你這個問題到處都有，是你個人太懶不去找的原因而沒有解決，這樣不愿意回答。

等你走出了這個階段，這個時候在有問題可能就是比較難一些的，這個時候在一般的網站上應該是難以找到結果的，我建議你英文夠好的話直接上國外的網站，包括JAVA自己的網站。如果一般呢，可以到IBM的中文網站上去，這些地方有很多一系列問題的解決方法，那上面提供的例子不管是書寫格式還是正確性都是比較好的，為你養成良好的習慣有很大的幫助。

4.其他UML等的學習

數據結構要不要學，UML要不要學，這些問題我覺得應人而異，你滿足于做一般的程序員，完全可以不學，現在商業軟件用到的都是成熟的技術，所有你遇到的問題，除非bug，無法解決的，在網上都能找到現成的代碼，完全可以支持你完成工作。

但是如果你把編程當作一種樂趣的話，還是要學習的，用UML語言之后，你會發現編碼的速度會更快，因為在這個過程中你理清了思路，通過使用工具，你可以要編碼的模塊分到最細，完成這部分工作以后，沒一個模塊的代碼寫起來會順手很多，因為邏輯明確。數據結構對你寫一些小的算法有幫助。而且通過比較高層次來觀察整個系統，你對程序的把握會越

來越有信心。

編程是一種樂趣，只有你覺得他有樂趣的時候你才會用更多的熱情去學習，現在java的書很多，我覺得國內一般人寫的不要看，還是原版的或者原版翻譯的比較好

第四篇：Java心得

JAVA心得

1.Only public & abstract are permitted for interface.2.Only public, abstract & final are permitted for class.3.main方法作為程序的入口,其modifier必須是 public static void

且必須有一個類型為String的數組參數, 否則不能運行.4.非static內部類中不能有static的域和方法.static的域和方法只能存在于頂級類中或者是static嵌套類中.5.interface 中定義的變量都是public static final的, 且必須賦值.6.如果試圖在方法中更改final變量的值, 則編譯不能通過;

7.兩個int類型的數相除其結果也是int型且不會四舍五入而是直接截取整數部分.一個浮點型數字與整數相除其結果是浮點型.8.try{}塊后面必須有catch(Exception){}或者finally{}

try{return a;}

finally{

}

執行順序是return語句返回結果之前 先執行finally{}再返回結果.9.子類override父類方法是可見修飾符級別不能降低,例如父類是protected

子類可以是protected和public 但不可以是default和private.如果子類有個方法與父類同名且參數類型也相同,則必須返回值類型也相同 否則不能編譯.Java允許方法名與類名相同, IDE會給出警告但可以編譯和運行.

第五篇：JAVA課程總結

DAY01

JavaSE第一天課程安排

##### 目標：開發第一個JAVA小程序，了解掌握相關概念

#####

內容：

1、了解計算機相關概念

2、下載安裝Java開發環境

3、開發第一個Java程序

4、開發環境設置優化

5、掌握Java程序的開發運行流程

6、掌握Java相關概念

7、練習

#####----------------計算機相關概念----------------

1、計算機

1、機器

2、軟件

3、數據輸入----> 數據處理----> 數據輸出-----（重要不緊急）

2、軟件----

A、系統軟件-----操作系統---windows linux B、應用軟件-----QQ、CF、計算器（數據）軟件的功能： 數據輸入----> 數據處理----> 數據輸出 數據-----123、文件、文件夾----泛稱

3、計算機操作

物理操作 軟件操作 GUI/CUI GUI-----圖形用戶接口-----Graphics User Interface(常用)CUI-----命令行用戶接口---Command User Interface(了解)A、如何啟動CUI

1、開始----> 附件-----> 命令提示符

2、開始----> 搜索CMD

3、win7----> shift 右擊----> 打開命令行

B、DOS命令----CUI和GUI有對應關系

按規律記憶

電腦上數據分兩類： 切換盤符：盤符號: 進入文件夾： cd 文件夾名

cd 路徑名（進入多級）

返回上一級:cd..返回根目錄:cd

1、文件

增

-----notepad/write/edit 查

-----type 文件名---查看內容 改

-----notepad/write/edit

刪

-----del 文件名稱

2、文件夾---dir

增----md XXX 查----dir--查看文件夾下所有文件

改----修改名稱 ren 刪----rd 要求：

1、簡單調用----記住一個 help

2、調用 time date 等命令

3、命令如何使用--命令 /? DOS啟動程序

1、DOS下進入程序所在路徑

2、敲入程序名稱

3、回車

需求：任意目錄下啟動程序，notepad可以，QQ不可以 edit cd cd..cd help 命令 /?----------不重要緊急

4、鍵盤使用------------重要不緊急

快捷鍵: 全選： ctrl + A

撤銷： ctrl + Z 復制： ctrl + C 粘貼： ctrl + V 保存： ctrl + S------剪切： ctrl + X eclipse: ctrl + D----刪除一整行

5、計算機語言

6、軟件開發

使用計算機語言開發程序 學習計算機語言：語法

總結：了解-----

緊急-----常見的DOS命令

----------------下載安裝Java開發環境----------

1、Java簡介

A、詹姆斯 格斯林 B、開源----開放源代碼 C、ONE體系

Open Net Environment----開放的網絡環境

JavaSE-----桌面應用程序開發----核心----就業機會不多 JavaEE-----企業的分布式系統開發1）----（N從右向左數的位數）

4、負數的轉換----（不不）

-10 0000 0000 概念：原反補

正數：源碼反碼補碼都一樣

負數：原碼----標志位是1，計數位和正數一樣

反碼----計數位取反，1變0,0變1

補碼----反碼基礎之上 +1 101 0111 1111 1111 1111 1111 1111 1111 1111----2^311 = 127 short-----2個字節16bit----最小值：-2^15=-32768 最大值：2^15* / %

++--（重點）DAY03 一.算數運算符：

1.+ 2.-

3.* 4./

/ 3 : 3 10 / 0 : 運行時異常；

10.0 / 0 :Infinity(無窮)不是異常

5.%

% 3 : 1 10 % 0 : 運行時異常

10.0 % 0 : NaN(Not A Number)不是異常-10 %-3 :-1 10 % 3 :1-10 % 3:-1 10 %-3:1 6.++: 7.--: 如果表達式中，只做++或--一件事情，那么前++/--和后++/--效果一樣的； 但如果表達式中做多件事情：

前++/--:先自增/自減，然后再參與表達式的其它運算； 后++/--:先參與表達式的運算，然后在自增/自減；

二.賦值運算符

1.=：執行順序，從右至左，并且最后返回變量； 2.+=： 3.-=： 4.*=： 5./=： 6.%=：

特點：帶隱式強制轉換；

byte b1 = 10;b1 = b1 + 20;//編譯錯誤

b1 += 20;//OK的-->b1 =(byte)(b1 + 20);三.關系運算符：

1.==：判斷是否相等 2.!=：判斷是否不等；

3.<:左操作數是否小于右操作數； 4.>:左操作數是否大于右操作數；

5.<=:左操作數是否小于或者等于右操作數； 6.>=:左操作數是否大于或者等于右操作數；

四.邏輯運算符：

&&、||和&、|的區別：

1.邏輯&&和||具有短路行為，一旦確定整個表達式的結果，那么將不再執行剩余表達式； 1.&&(語意：并且):兩邊都為true，結果為：true； 2.||(語意：或者)：有一邊為true，結果為true;3.!(語意：不是)：!true：false；!false:true 位運算符：

4.&(并且):結果同&& 5.|(或者):結果同|| DAY04 一.運算符：

1.位運算符：

1).<<(左移)： 2).>>(有符號右移):

3).>>>(無符號右移)4).&(按位與):兩位都是1，結果為1； 5).|(按位或):有1位為1，結果為1；

6).^(按位異或):兩位相同結果為0，否則為1； 7).~(取反):1變0，0變1 2.位運算符的考點：

1).高效的計算某數 * 2 : << 2).高效的計算某數 / 2 : >> 3).&、|同&&、||的區別： 邏輯與&&、||：具有短路行為；

4).將兩個變量的值交換：三次異或；

3.三目運算符： 條件表達式 ？ 表達式1 ： 表達式2；

二.鍵盤錄入：

步驟：

1.import java.util.Scanner;2.Scanner sc = new Scanner(System.in);3.int : int num = sc.nextInt();

double : double d = sc.nextDouble();

String : String s = sc.next();三.選擇結構：

1.if語句：

1)格式1：

if(條件表達式){ } 注意：如果if體內只有一條語句，可以省略大括號，但不建議；

2)格式2：

if(條件表達式){ //為true，執行這里

}else{ } //為false，執行這里

3)格式3：

if(條件表達式){ }else if(條件表達式2){ }else if(條件表達式3){ }else{ } 2.switch語句：

1).格式：

switch(表達式）{

} case 值1: //代碼 break;case 值2：

//代碼 break;default: //代碼 break;2).注意事項：

1.“表達式”可以產生的值：byte,short,int,char,枚舉(JDK5以后),String(JDK7以后)2.case語句后跟“常量表達式”，不能是“變量”；而且不能出現相同的常量值；

3.break;語句“不是必須的”。如果不寫，如果一旦case相應的值成功，但內部沒有break語句，那么將會無條件(不再進行case匹配)的繼續向下執行其它case中的語句，直到遇到break;語句

或者到達switch語句結束。4.多個case之間，沒有順序關系；

5.default語句“不是必須的”?？梢圆粚?，它就相當于多重if語句中最后的else。6.default語句和case語句“沒有順序關系”。

DAY05 一.while循環：

while(條件表達式){ } 二.do_while循環：

do{ }while(條件表達式);三.for循環：

for(定義循環變量表達式

;

條件表達式

;增量表達式){ } 說明：

1.三個表達式都不是必須的；但分號必須要寫； 2.執行順序：

1).定義循環變量表達式； 2).條件表達式;3).進入循環； 4).增量表達式； 5).條件表達式；

6).進入循環 7).增量表達式......四.三種循環的區別：

1.只有do_while循環是先無條件的進入循環體執行一次，然后再判斷；

while和for循環都先判斷，后進入循環體； 2.一般對于有明顯的遍歷范圍的，建議首選for循環。

對于沒有明顯遍歷范圍的，一般使用while。

對于循環體中的內容，如果需要先執行一次，再判斷，那么可以使用do_while DAY06 一.方法：

1.方法的作用：代碼復用； 2.方法定義的格式：

修飾符 返回值類型 方法名([形參列表]){ } 修飾符：目前只需要寫：public static 返回值類型：可以是任何的Java類型(基本數據類型、引用數據類型)。

如果沒有返回值，這里要寫void

方法名：自定義標識符；

形參列表：可以沒有，但是一定寫一對小括號。

如果有，每個形參是由：數據類型 形參名

多個形參，中間用逗號隔開；

3.方法內，可以寫什么？

1).定義變量；

2).if語句，switch語句； 3).各種循環語句；

總之：除了不能定義方法，其它都可以； 4.方法的注意事項：

1).方法不調用不執行;2).方法與方法是平級關系，不能嵌套定義;3).方法定義的時候參數之間用逗號隔開;4).方法調用的時候不用在傳遞數據類型;5).如果方法有明確的返回值，一定要有return帶回一個值;5.方法的重載：

1).在一個類中，可以定義多個同名的方法，但形參列表不能完全相同； 2).方法重載，跟返回值類型無關；跟形參名無關；

二.數組：

1.一維數組：

1).定義的格式：

1.動態初始化：數據類型[] 數組名 = new 數據類型[數組長度];2.靜態初始化：

數據類型[] 數組名 = new 數據類型[]{值1，值2，值3，.....，值n};

數據類型[] 數組名 = {值1，值2，值3.....值n};2).數組是“引用數據類型”，變量存儲的是“引用(地址)”；

3).當new(實例化)一個數組對象時，其“值”的空間是在堆中分配的，對于各種數據類型，都會分配一個

默認值：

整數：0 小數：0.0 字符：'u0000' 布爾：false String：null 其它引用類型：null 4).數組的訪問方式：使用：數組名[索引] DAY07 一.二維數組：

1.定義的格式：

數據類型[][] 數組名 = new 數據類型[第一維的長度][第二維的長度];左邊也可以寫成：

數據類型 數組名[][] 數據類型[] 數組名[] 數據類型[][] 數組名 = new 數據類型[][]{{值1，值2},{值3，值4},{值5，值6，值7}};數據類型[][] 數組名 = {{值1，值2},{值3，值4},{值5，值6，值7}};二.方法的值傳遞和引用傳遞： 1.當一個方法接收的是一個“基本數據類型”時，調用方法傳遞實參時，是將“值”復制到方法內；

在方法內，如修改其值，修改的只是“副本”，原值不會被改變；

2.當一個方法接收的是一個“引用數據類型”是，調用方法傳遞實參時，是將“引用”復制到方法內；

在方法內，是可以通過這個引用修改“堆”空間的內容，即使方法結束，修改會影響到原堆中的值；

DAY08

一.類：是一組相關的“屬性”和“行為”的集合；

對象：是該類事物的具體體現； 二.類和對象的關系：

1.現實：

類 對象 貓 波斯貓

折耳貓 加菲貓

---------

狗 金毛

藏獒 沙皮

2.代碼：

類 對象

Cat c1 = new Cat();c1.name = “波斯貓”;class Cat{

}

String name;int age;c1.age = 2;

----Cat c2 = new Cat();c2.name = “折耳貓”;c2.age = 3;----------------------------class Dog{

}

Dog d1 = new Dog();d1.name = “金毛”;String name;int age;d1.age = 2;

----Dog d2 = new Dog();d2.name = “藏獒”;d2.age = 3;

三.類的定義：

1.使用關鍵字：class(注意小寫)2.一個java源文件中：

1).如果定義多個類，但只有一個是public的；而且源文件名必須與這個public的類名一致； 2).如果定義多個類，可以沒有public類；源文件名沒有一致性要求；

3).main()方法不是必須放在public類中；

3.類中可以定義什么：

1).成員變量：

A.可以是基本數據類型，也可以是任何引用數據類型； B.可以顯示初始化；

class Student{

} String name = “張三”;int age = 20;C.可以隱式初始化；

整型：0 浮點：0.0 字符：'u0000' 布爾：false 引用類型：null 2).成員方法： A.可以有參數，可以沒參數；

可以有返回值，可以沒有返回值；

B.方法的“形參”可以是任何Java類型(基本數據類型、引用數據類型)C.方法的“返回值”可以是任何Java類型(基本數據類型、引用數據類型)D.一個類中可以定義多個同名的方法，但形參列表不完全相同，叫：方法的重載；

3).內部類(后面講)；

4.成員變量和局部變量的區別：

1).成員變量： A.定義在“類體”中；可以是任何數據類型；

B.會被自動初始化；

class Student{

} String name;void show(){ } System.out.println(“我叫：” + num);

//打?。何医校簄ull C.當實例化對象后，被存儲在“堆”中；

D.當“對象”不被使用(沒有任何引用)，并被垃圾回收器回收時被清理；

2).局部變量：

A.定義在某個方法、或其它代碼塊中； B.必須顯示初始化，否則不能訪問其值；

class Student{

void show(){ String name;System.out.println(“我叫：” + name);

//編譯錯誤。局部變量必須顯示初始化才能訪問其值；

} } name = “張三”;//OK?？梢员毁x值。

C.當方法或其它代碼塊被執行時，基本數據類型的“值”和引用數據類型的“引用”都是存儲在“棧”中； D.當方法或代碼塊執行完畢時，會被立即清理；

四.對象的使用：

1.創建對象使用new關鍵字；會在堆中分配內存空間； 格式：

類名

變量名 = new 類名();2.一個類可以創建多個對象；

3.每個“對象”的“成員變量”在“堆”中都有一份獨立的空間；

每個“對象”的“成員方法”被存儲在“方法區”中，多個對象只有一個“方法空間”； 4.對象的“引用(地址)”被存儲在“?！敝?；

五.方法的形參：

1.可以是“基本數據類型”：

1).調用時，必須傳遞此類型的“值”； 2).調用時，是將值復制一份到方法內部； 3).在方法內，使用形參接收此值的副本； 4).在方法內，如果更改此值，對原值沒有影響；

int a = 10;show(a);System.out.println(a);//10---public void show(int n){//n = 10 } n = 20;//對原來的a的值是沒有影響的；

2.可以是“引用數據類型”：

1).調用時，必須傳遞此類型的“引用”；

2).調用時，是將“引用(地址)”復制一份到方法內部； 3).在方法內，使用形參接收此“引用”的副本；

4).在方法內，如果通過此引用更改堆中的值，對原堆中的值將會產生影響；

int[] arr = {14,324,435};//arr = 0x2233 show(arr);//show(0x2233)System.out.println(arr[0]);//1000

----public void show(int[] array){//array = 0x2233 } array[0] = 1000;六.匿名對象：

1.匿名對象：沒有名字的對象：new Student();2.匿名對象的兩種使用情況：

1).對象調用方法僅僅一次的時候:new Student().show();2).作為實際參數傳遞:printStudent(new Student());七.封裝：

1.直接對外部暴露成員變量是很不安全的，這時可以將成員變量“私有化”，對外提供公有的 get和set方法； 2.封裝的好處：

1)隱藏實現細節，提供公共的訪問方式 2)提高了代碼的復用性 3)提高安全性。

3.封裝的原則：

1)將不需要對外提供的內容都隱藏起來。2)把屬性隱藏，提供公共方法對其訪問。

八.private關鍵字：

1.是一種“訪問修飾符”(將在day10講到)；

Java中一共有四種訪問修飾符：從寬到窄：public，protected，(默認)，private 2.用于修飾“成員變量”和“成員方法”；

3.被private修飾的成員，只能在類的內部被其它成員訪問。在類外部無法訪問；

九.this關鍵字： 1.每個類都有一個“隱式”的變量：this；

2.它是在實例化對象時，由虛擬機自動賦值的，會被自動賦值為當前對象的“引用”。

所以每個對象內的this變量的值是不同的；

3.this關鍵字可以調用本對象的“成員屬性”、“成員方法”、“構造方法”； 4.以下情況必須顯示的使用this：

1).“局部變量”覆蓋“成員變量”時，可以使用this顯示的訪問被覆蓋的“成員變量”；

否則訪問的是“局部變量”；

2).在一個構造方法中調用本類的其它構造方法；this()或this(實參)；

DAY09

一.構造方法：

1.當實例化一個類的對象時，JVM會自動調用本類的一個方法：構造方法；

2.定義類時，可以不定義構造方法，編譯器會自動添加一個無參，什么都不做的構造方法； 3.如果類中定義了構造方法，編譯器就不會添加任何構造方法了； 4.構造方法的格式要求：

1).構造方法名必須與類名一致；

2).構造方法不能定義“返回值類型”，甚至是void；

3).構造方法不能返回一個具體的值，但內部可以使用return;語句； 注意：

1).以下代碼可以編譯通過：

class Student(){

} public void Student(){ }

//普通成員方法，不是構造方法；

2).以下代碼不能通過編譯：

class Student(){ public student(){ }

//構造方法必須同類名一致，包括大小寫；

} 5.一個類中可以定義多個“構造方法”，但每個構造方法的形參列表不能完全相同，叫：構造方法的重載； 6.在一個構造方法中可以調用另一個構造方法，使用this關鍵字； 7.構造方法可以調用“成員方法”，但“成員方法”不能調用構造方法；

構造方法也可以調用其它構造方法；

二.static關鍵字：

1.static關鍵字：靜態的，全局的。

2.可以修飾“成員變量”和“成員方法”。被static修飾的成員變量存儲在方法區的“靜態存儲區”，只有

一份拷貝，被多個對象共享；

3.特點：

1).隨著類的加載而加載

2).優先于對象存在3).被類的所有對象共享

4).可以通過類名調用，也可以通過對象名調用； 4.static關鍵字注意事項：

1).在靜態方法中是沒有this關鍵字的

2).靜態方法只能訪問靜態的成員變量和靜態的成員方法

三.靜態變量和成員變量的區別：

1.所屬不同

1).靜態變量屬于類，所以也稱為為類變量

2).成員變量屬于對象，所以也稱為實例變量(對象變量)2.內存中位置不同

1).靜態變量存儲于方法區的靜態區 2).成員變量存儲于堆內存

3.內存出現時間不同 1).靜態變量隨著類的加載而加載，隨著類的消失而消失

2).成員變量隨著對象的創建而存在，隨著對象的消失而消失

4.調用不同

1).靜態變量可以通過類名調用，也可以通過對象調用 2).成員變量只能通過對象名調用

DAY10 一.代碼塊(理解)：

1.普通代碼塊(類體中)：包含：局部代碼塊(方法或其它代碼塊內)2.靜態代碼塊：(類體中)作用：

1.初始化成員變量。執行流程：

1.普通構造代碼塊：每次實例化此類對象時，會被執行。它會先于“構造方法”被執行； 2.靜態代碼塊：第一次實例化此類對象時； 3.靜態代碼塊-->普通構造代碼塊-->構造方法：

二.繼承(必須掌握)：

1.使用關鍵字:extends 2.作用：代碼重用。為多態提供了前提； 3.this和super的區別：

1).this:

1).在任何類中使用； 2).存儲的是本類對象的引用；

3).可以訪問本對象的成員變量、成員方法、構造方法；

2).super:

1).在子類中使用；

2).存儲的是父類對象的引用；

3).可以訪問父類對象的成員變量、成員方法、構造方法；

4.類的初始化過程：

加載class文件 堆中開辟空間 變量的默認初始化 變量的顯示初始化 構造代碼塊初始化 構造方法初始化

成員變量-->構造代碼塊-->構造方法 5.Java中繼承的特點：

1).Java中只能單繼承； 2).Java中可以多級繼承；

6.繼承的好處和弊端：

好處： 1).代碼復用

2).為多態提供了前提； 弊端：

1).由于繼承，子類對父類產生了依賴；

三.方法重寫:

1.在子類中，定義跟父類一模一樣的方法，這叫：方法重寫； 2.重寫的規則：

1).返回值類型、方法名、形參列表：要完全一致； 2).子類的訪問修飾符可以跟父類的相同，或更寬；

3.重寫的意義： 1).子類保留了父類的方法，具有了自己特有的行為；

4.重寫和重載的區別： 1).重寫：在子類中定義跟父類一模一樣的方法；

2).重載：在一個類中，定義：方法名相同，參數列表不完全相同的方法，叫：重載。跟返回值類型無關；

四.final關鍵字：

1.可以修飾： 成員變量：表示其變量擁有最終的值，不能被更改，成為“常量”。修飾基本數據類型：表示其值不能被修改。修飾引用數據類型，表示地址不能被修改；

成員方法：表示最終的方法。不能被重寫； 類：

表示最終類。不能被繼承；

局部變量：表示其值不能改變；區分：基本類型和引用類型； 方法形參：表示其值不能改變；區分：基本類型和引用類型；

DAY11

一.多態：

1.父類的引用指向子類的對象； 2.多態前提和體現

1).有繼承關系 2).有方法重寫

3).有父類引用指向子類對象

3.多態的轉型：

1).自動轉型：子類的引用轉為父類的引用；Person p = new Student();2).強制轉型：父類的引用轉為它所指向的子類對象的引用；Student stu =(Student)p;3).在進行強制轉型前，為保證安全，可以使用instanceof關鍵字進行判斷：

if(p instanceof Student){ } Student stu =(Student)p;4.多態的好處：

1).提高了程序的維護性(由繼承保證)2).提高了程序的擴展性(由多態保證)

5.多態的弊端： 1).不能訪問子類特有功能(可以向下轉型)6.多態時的訪問規則：

1).總體規則：訪問的任何成員父類中必須要有，否則編譯錯誤；

例如：

class A{ } class B extends A{ } main(){

} A a = new B();System.out.println(a.n);//編譯錯誤，父類中沒有n int n = 20;int num = 10;2).成員變量：如果子、父類中都有，訪問的是“父類”的；

class A{ } class B extends A { } main(){

} A a = new B();//多態

System.out.println(a.num);//打印10；

int num = 20;int num = 10;

普通方法：如果子、父類中都有(重寫)，訪問的是“子類”的；

class A{

} class B extends A{

} main(){

} A a = new B();a.show();

//打?。築-->show()(訪問的是子類的show());void show(){ } System.out.println(“B-->show()”);void show(){ } System.out.println(“A-->show()”);

靜態方法：如果子、父類中都有(重寫)，訪問的是“父類”的；

二.抽象類：

1.使用abstract關鍵字修飾；可以修飾“類”，可以修飾“成員方法”；

abstract class A{ } abstract void show();2.“抽象類”的特點：

1).不能被實例化，只能用于被繼承；

2).可以包含：成員變量、構造方法、成員方法、抽象方法； 3).可以不包含抽象方法；

3.“抽象方法”的特點：

1).沒有方法體；abstract void show();2).必須被子類重寫。除非子類也是個抽象類；

3.子類繼承抽象類使用關鍵字：extends，仍然是單繼承；

4.一個子類繼承 了一個抽象類，必須實現抽象類中所有的抽象方法；

否則子類也必須是抽象的。

例如：

abstract class A{ } class B extends A{ }

//編譯錯誤。類B不是抽象的，繼承類抽象類必須重寫抽象類中的所有abstract void show();抽象方法。abstract class B extends A{ } //編譯通過。類B沒有重寫父類中的抽象方法，但類B是抽象的。

5.abstract關鍵字不能和哪些關鍵字共存：

1.private:抽象方法就是用來被子類重寫的，而私有方法不能被子類重寫；

2.final：抽象類和抽象方法就是用來被子類繼承和重寫的，而fianl類和final方法不能

被繼承和重寫； 3.static：static修飾的方法在沒有任何對象的情況下就會被分配內存空間；而抽象方法

沒有方法體，無法分配空間；

三.接口：

1.使用interface關鍵字定義：只能修飾“類”：

interface IA{ } 2.“接口”的特點：

1).不能被實例化，沒有構造方法，只能用于子類“實現”； 2).可以包含：

A.成員變量(常量)：隱式的定義為：public static final。

例如： interface IA{

} public int num1 = 10;

//OK

上述三個關鍵字中任何一個都可以不寫，系統會自動添加；

static final int num2 = 20;//OK final int num3 = 30;

//OK

//OK public final num4 = 40;int num5 = 50;

//OK B.抽象方法：隱式的定義為：public abstract?？梢允÷?，系統會自動添加

例如： interface IA{

} void show1();

//OK

//OK;public void show2();abstract void show3();//OK;3).接口的功能是：擴展功能；

3.子類實現接口使用關鍵字：implements 4.一個子類可以同時實現多個接口；

interface IA{} interface IB{} class C implements IA,IB{ //OK的。} 5.子類實現接口時，必須重寫接口中所有的抽象方法，而且必須是public的--因為

接口中抽象方法的定義隱式的是public的。

例如：

interface IA{ } class B implements IA{ void show(){ }

//編譯錯誤。父接口的show()隱式的為public的，子類重寫時void show();必須是public的；

} 5.接口編譯后一樣會生成.class文件。

四.多態的形式：

1.父類的多態； 2.抽象類多態； 3.接口多態；

五.類與類，類與接口，接口與接口的關系：

1.類與類：繼承關系，關鍵字：extends，只能單繼承，但是可以多層繼承

2.類與接口：實現關系，關鍵字：implements，可以單實現，也可以多實現。還可以在繼承一個類的同時實現多個接口

3.接口與接口：繼承關系，關鍵字：extends，可以單繼承，也可以多繼承

例如：

interface IA{} interface IB{} interface IC extends IA,IB{} //OK的

六.抽象類和接口的區別：

1.成員區別 1).抽象類 變量,常量;有抽象方法;抽象方法,非抽象方法

七.2).接口 常量;抽象方法

2.關系區別

1).類與類 繼承，單繼承

2).類與接口 實現，單實現，多實現 3).接口與接口 繼承，單繼承，多繼承

3.設計理念區別

1).抽象類 被繼承體現的是：”is a”的關系。共性功能 2).接口 被實現體現的是：”like a”的關系。擴展功能

一.類名作為形參：

1.實參可以是：

1).此類對象的引用;2).null;3).此類子類對象的引用；

二.抽象類作為形參：

1.實參可以是：

1).此類子類對象的引用； 2).null;

三.接口作為形參：

1.實參可以是：

1).此接口子類對象的引用； 2).null;

四.類名作為返回值：

1.可以返回的類型：

1).此類對象的引用； 2).null;

3).此類子類對象的引用；

2.可以用什么類型接收：

1).使用此類類型；

2).不能使用某個子類類型接收；

五.抽象類作為返回值：

1.可以返回的類型：

1).null;2).此類子類對象的引用；

2.可以用什么類型接收：

1).使用此類類型；(多態)2).不能使用某個子類類型接收；

六.接口作為返回值：

1.可以返回的類型：

1).null;2).此接口子類對象的引用；

2.可以用什么類型接收：

1).使用此接口類型；(多態)2).不能使用某個子類類型接收；

DAY12

一.包：

1.定義包使用關鍵字：package；

1).注意事項：

A.package語句必須是程序的第一條可執行的代碼 B.package語句在一個java文件中只能有一個 C.如果沒有package，默認表示無包名

2.導入包使用關鍵字：import；

1).注意事項：

A.導入到最終的類；

B.可以使用通配符：*，只統配包下的類，不包括子包下的其它類； C.在一個類文件中，可以有多條import語句；

D.import語句必須在package語句之后，在定義類之前；

3.package,import,class有沒有順序關系？ 有：package-->import-->class 二.訪問修飾符：

1.用于限定“類”和“成員”被其它包下的其它類訪問的； 2.四種訪問修飾符：

1).public(公有)：可以修飾類、成員?？梢员蝗魏伟碌钠渌愒L問； 2).protected(保護)：可以修飾成員?？梢员煌碌钠渌愒L問。如果在包外

只能被子類訪問；

3).(默認)：可以修飾類、成員。只能被包內的其它類訪問； 4).private(私有)：可以修飾成員。只能被類中的其它方法訪問；

3.類及成員可用的修飾符：

1).類：

默認，public，final，abstract 我們自己定義：public居多

2).成員變量：

四種權限修飾符均可,final,static 我們自己定義：private居多

3).構造方法：

四種權限修飾符均可,其他不可 我們自己定義：public 居多

4).成員方法：

四種權限修飾符均可，fianl,static,abstract 我們自己定義：public居多

三.內部類：

1.成員內部類：

1).定義在類體中，作為類的成員；

2).可以使用同類“成員方法”相同的修飾符；

2.局部內部類：

1).定義在某個方法或代碼塊內部；

2).不能使用“訪問修飾符”，不能使用static修飾符；可以使用final和abstract 3).注意：局部內部類訪問“局部變量”，要求局部變量必須是final的(常量)；（重點）

3.匿名內部類：

1).就是內部類的簡化寫法。2).前提：存在一個類或者接口 這里的類可以是具體類也可以是抽象類。

3).格式： new 類名或者接口名(){重寫方法;} 4).本質： 是一個繼承了類或者實現了接口的子類匿名對象

DAY14 一.Object類：

1.所有引用數據類型(包括類庫中的類，自定義類，數組)的超類； 2.定義在java.lang包，使用時不需要導包； 3.常用方法：

public class Object{ public Object(){

內存的操作；

} public int hashCode(){ //功能：用于哈希表結構的鍵值

//默認實現：將此對象的地址轉換為int值返回；

//此方法建議子類重寫；

} public final Class getClass(){ //功能：獲取此對象的Class對象，在day27講解

//此方法不能被子類重寫 } public String toString(){ //功能：返回此對象的字符串表現形式；

//默認實現：全名限定的類名 + @ + hashCode(無意義)//此方法建議子類重寫；

} public boolean equals(Object obj){ //功能：將當前對象與參數對象進行比較

//默認實現：比較地址(跟==的結果是一樣的)//此方法建議子類重寫；

} protected void finalize(){ //功能：當前對象在被垃圾回收器回收前，由垃圾回收器自動調用的方法。一般用于做些釋放 //默認實現：無

//此方法根據需要由子類重寫(一般我們不用)}

} protected Object clone(){

} //功能：復制此對象的副本； //默認實現：本地方法 //一般子類無需重寫；

--

二.java.lang.String類：

1.一個“字符串”對象； 2.一個“引用數據類型”； 3.使用方式：

String s1 = “abc”;(常用、存儲的是常量池中的地址)或：

String s1 = new String(“abc”);(存儲的是堆中的地址)(在內存中創建了兩個對象：1.常量池：“abc”；

class Student(extends Object){ } //默認就擁有了Object類中可以繼承的方法；

2.堆：new String())

4.特點：其“值”的內容不能改變(地址可以改變)；

String str = “你好”;str = “Java”;//原值被丟棄，存儲了新的地址；

5.常見面試題： String s1 = “abc”;

String s2 = “abc”;System.out.println(s1 == s2);//true--------

String s1 = “Hello”;String s2 = “World”;String s3 = “HelloWorld”;String s4 = “Hello” + “World”;String s5 = s1 + s2;String s6 = “Hello” + s2;String s7 = s1 + “World”;String s8 = new String(“Hello”);System.out.println(s3 == s4);//true System.out.println(s3 == s5);//false System.out.println(s3 == s6);//false System.out.println(s3 == s7);//false System.out.println(s1 == s8);//false;6.構造方法：

public String()：構造一個空字符串。效果同String str = “";public String(byte[] bytes):使用一個byte[]數組構造一個字符串；

public String(byte[] bytes,int offset,int length)：使用byte[]數組的一部分構造一個字符串； public String(char[] value)：使用一個字符數組構造一個字符串；

public String(char[] value,int offset,int count)：使用字符數組的一部分構造一個字符串； public String(String original)：使用一個字符串構造一個字符串；

7.常用方法：----注意：以下方法返回String的，都是生成一個新字符串，原字符串不變； 1).判斷功能：

boolean equals(Object obj):重寫父類的方法。與參數字符串比較，如果包含一樣的字符序列則返回true，否則返回false;

boolean equalsIgnoreCase(String str):作用與equals()相同；但此方法不區分大小寫； boolean contains(String str):判斷是否包含參數字符串；

boolean startsWith(String str):判斷字符串是否以參數字符串開頭； boolean endsWith(String str):判斷字符串是否以參數字符串結尾； boolean isEmpty():判斷字符串是否是”空字符串“；

----

String s1 = ”“;String s2 = new String();String s3 = new String(”“);String s4 = null;String s5 = ”“;String s6;System.out.println(s1.isEmpty());System.out.println(s2.isEmpty());System.out.println(s3.isEmpty());// System.out.println(s4.isEmpty());

System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s3.equals(s1));System.out.println(s1 == s2);System.out.println(s2 == s3);System.out.println(s1 == s3);System.out.println(s1 == s5);

System.out.println(s4 == s6);-----2).獲取功能：

int length()：獲取此字符串內部的字符數量。(區分數組的length屬性)char charAt(int index)：獲取此字符串中index位置的字符char;int indexOf(int ch)：從左向右查找，獲取字符ch在字符串中第一次出現的位置。如果不包含，則返回：false

int indexOf(String str)：獲取字符串str在此字符串中第一次出現的位置。int indexOf(int ch,int fromIndex)：從fromIndex位置開始，查找字符ch。int indexOf(String str,int fromIndex)：從fromIndex位置開始，查找str。

String substring(int start)：從start(包含)開始，截取到此字符串的末尾；返回一個新字符串，原字符串不變； String substring(int start,int end)：從start(包含)到end(不包含)截取字符串；返回一個新字符串，原字符串不變；

3).轉換功能：

byte[] getBytes()：將字符串轉換為一個byte[]數組。char[] toCharArray()：將字符串轉換為一個char[]數組；

static String valueOf(char[] chs)：靜態方法，將一個char[]數組轉換為一個String static String valueOf(int i)：靜態方法，將一個int轉換為一個String String toLowerCase()：轉換為小寫； String toUpperCase()：轉換為大寫；

String concat(String str)：將參數字符串添加到本字符串的末尾。

4).替換功能：

String replace(char old,char new)：使用new字符替換本字符串中的所有old字符； String replace(String old,String new)：使用new字符串替換本字符串中的所有old字符串；

5).其它功能：

String trim():去掉字符串兩邊的空格；不包括中間的。

int compareTo(String str)：重寫Comparable接口的方法。按Unicode編碼表的順序與參數字符串比較；

System.out.println(”a“.compareTo(”b“));//-1 System.out.println(”a“.compareTo(”a“));//0 System.out.println(”b“.compareTo(”a“));//1 int compareToIgnoreCase(String str):不區分大小寫的比較；

DAY15 一.StringBuffer類：

1.String的緩沖池類。

2.String和StringBuffer的區別：

1).String:其”值“不可變； 2).StringBuffer:其”值"可變；

當我們多次進行字符串的拼接等操作時，使用String會產生大量的垃圾空間。建議使用此類； 2.構造方法：

public StringBuffer()：初始容量16 public StringBuffer(int capacity)：初始容量capacity public StringBuffer(String str):使用String構造一個StringBuffer。

3.添加功能：

public StringBuffer append(String str)：及各種重載的方法。將任何類型的參數添加到末尾； public StringBuffer insert(int offset,String str)：將一個String插入到offset位置。原位置上的字符依次后移；

4.刪除功能：

public StringBuffer deleteCharAt(int index)：刪除index位置上的字符

public StringBuffer delete(int start,int end)：刪除start到end-1處的所有字符；

5.替換功能： public StringBuffer replace(int start,int end,String str)：將start到end處的所有字符替換為str;6.反轉功能： public StringBuffer reverse()：反轉內部字符串；

7.截取功能：

public String substring(int start)：截取從start到結尾，返回一個新字符串； public String substring(int start,int end)：截取從start到end-1處的所有字符；

二.StringBuffer類和StringBuilder類的區別：

1.StringBuffer是線程安全的； 2.StringBuilder是線程不安全的；

三.Arrays類：

1.對數組操作的類，沒有構造方法，內部包含了大量靜態的工具方法； 2.常用方法：

1).public static String toString(int[] a)：將int[]數組轉換為String的表示形式； 2).public static void sort(int[] a)：升序排序int[]數組；

3).public static int binarySearch(int[] a,int key)：二分查找int[]數組中的key值；

四.包裝類：

基本數據類型 byte short int long char float 包裝類型

Byte Short Integer

Long Character Float Double Boolean double boolean