第一篇：Java課程教學小結(jié)

2010年~2011年度第一學期《Java程序設(shè)計》課程總結(jié)及教

學效果分析教學改進報告

本學期本人擔任了軟件日語091班的《Java程序設(shè)計》課程的教學工作，通過一學期的教學，本人的總結(jié)如下：

情況分析：《Java程序設(shè)計》課程講述的內(nèi)容是Java程序設(shè)計。課程以Java為藍本進行教學，注重操作和程序設(shè)計，是一門實用性很強的課程，我比較喜歡，因此從起初就下定決心要教好這門課程了。針對這這個學期的教學工作現(xiàn)在總結(jié)如下。

１、采用多媒體教學。用生動形象的教學課件幫助學生理解。一些學生比較難理解的章節(jié)內(nèi)容，我都作成動態(tài)的畫面，將每一步操作都動態(tài)的表示出來，學生有興趣看，也有興趣學習。使學生能理解難點內(nèi)容，掌握重點內(nèi)容，鞏固學習效果。

２、案例教學法和任務(wù)驅(qū)動法的實施和應(yīng)用。在教學活動中我采用訂單管理系統(tǒng)為教學案例，開展教學。從基本概念到最后的類以及最終項目的完成，都采用這一案例進行。所有實例都可以運行，可以查找結(jié)果。在機房，學生可以邊操作邊運行實例，上課是由于任務(wù)驅(qū)動，學生操作的積極性很高。

３、在課堂上開展競賽，學生參與，誰首先完成任務(wù)，誰先檢查，并且每次檢查都有分數(shù)記錄，因此學生的積極性大大提高，教學效果好，聽課認真。

４、項目引領(lǐng)課程，要求學生完成在線考試系統(tǒng)，這是一個由數(shù)據(jù)庫SQL做后臺，Java做前臺的系統(tǒng)。雖然和真正的軟件還是有差距的，但是通過本課程學生可以理解使用Java調(diào)用SQL的過程和編寫大的數(shù)據(jù)庫軟件的方法。在這個案例中，我全程輔導，指導學生完成數(shù)據(jù)庫、表、每個界面和各個代碼的編寫、講解、錄入。由于這個環(huán)節(jié)被學校抽到聽課和資料檢查學生格外認真，我也感到了學生對我的教學工作的支持，我非常滿意。盡管他們是大二的學生，但是他們的熱情和認真不遜色與其他班級。因此，通過一個學期一門課程和一個實訓環(huán)節(jié)的相處我和這個班級的學生的感情很深。

５、認真作好教案和備課筆記，這是自己最為重要的教學資源，是經(jīng)驗和知識的積累。

在今后的教學過程中，我還要不斷總結(jié)，多采用多媒體課件的方式為學生進行演示，以加強學生的感性認識，培養(yǎng)學生真正掌握學習計算機科學技術(shù)的思想和方法，為學生課后的進一步學習提供指導和幫助，爭取達到更好的教學效果。

第二篇：java小結(jié)

//1.累加 public class 累加 {

}

//2.階乘

public class 30的階乘 {

} public static void main(String[] args){

} int product=1;for(int i=1;i<=30;i++){ product=*i;} public static void main(String[] args){

} int i=1;for(int counter=1;counter<=100;counter++){ } System.out.println(i);i+=counter;

//3.倒序輸出

法1 用char數(shù)組思想 import java.util.Scanner;public class 逆序輸出 {

public static void main(String[] args){

Scanner scan=new Scanner(System.in);// String input[]=new String[4];input=scan.nextLine();// huiche

// String result=“";char[] Array=input[4].toCharArray();for(int i=Array.length-1;i>=0;i--){

} result+=Array[i];} System.out.println(result);} //倒序輸出 法2 用reverse（）方法 import javax.swing.JOptionPane;public static void main(String[] args){

}

String a = null;StringBuffer b;//輸入

a=JOptionPane.showInputDialog(a);StringBuffer c1=new StringBuffer(a);b=c1.reverse();System.out.println(b);

//4.輸出100 121 144...361 public class平方輸入數(shù)組 {

}

//5.求最大公約數(shù)

private static int gys(int m,int n)

{

if(n==0)

return m;else public static void main(String[] args){

} int[] array=new int[10];for(int i=0;i<10;i++){ } array[i]=Math.pow((i+10),2.0);

for(int k=0;k

return gcd(n,m%n);

}

//6.求最小公倍數(shù)

public static int gbs(int n1,int n2){

int a =(n1>n2)? n1 : n2;

for(int j=a;j<=n1*n2;j++)

{

if(j%n1==0 && j%n2==0)

{

return j;

}

}

return 0;}

//7.1）十進制整數(shù)轉(zhuǎn)化為二進制整數(shù)采用“除2取余，逆序排列” import java.util.Scanner;public class Main {

public static void main(String[] args){ //第一行輸入要幾組測試數(shù)據(jù)

int N=0,a;//N為輸入幾組數(shù)據(jù)，a為輸入的十進制數(shù)字

} String b = null;Scanner scan=new Scanner(System.in);N=scan.nextInt();Main num=new Main();for(int i=1;i<=N;i++){

} a=scan.nextInt();b=num.deimalBinary(a);int d=num.Calcute(b);if(d%2==0)System.out.println(”Even“);else

System.out.println(”O(jiān)dd“);

/*一個方法得到二進制數(shù)，用遞歸

*用2去除十進制整數(shù)，可以得到一個商和余數(shù)；

*再用2去除商，又會得到一個商和余數(shù)，} *如此進行，直到商為零時為止，*然后把先得到的余數(shù)作為二進制數(shù)的低位有效位，*后得到的余數(shù)作為二進制數(shù)的高位有效位，依次排列起來

*/ public String deimalBinary(int a){

} public int Calcute(String b){

} char[] Array=b.toCharArray();for(int i=0;i

} if(Array[i]=='1'){ } counter+=1;return counter;

//7.2）十進制小數(shù)轉(zhuǎn)換為二進制小數(shù)采用“乘2取整，順序排列”

/*用2乘十進制小數(shù)，可以得到積，*將積的整數(shù)部分取出，再用2乘余下的小數(shù)部分，//8.矩陣運算（加減乘）//矩陣運算 *又得到一個積，再將積的整數(shù)部分取出，*如此進行，直到積中的小數(shù)部分為零，*或者達到所要求的精度為止。

*然后把取出的整數(shù)部分按順序排列起來，*先取的整數(shù)作為二進制小數(shù)的高位有效位，后取的整數(shù)作為低位有效位。*/ import java.util.Scanner;public class Main { public static void main(String[] args){

int N1,M1,N2,M2,K;Scanner scan=new Scanner(System.in);N1=scan.nextInt();M1=scan.nextInt();int[][] a=new int[N1][M1];for(int i=0;i

for(int j=0;j

N2=scan.nextInt();M2=scan.nextInt();int[][] b=new int[N2][M2];for(int i=0;i

{ } b[i][j]=scan.nextInt();} K=scan.nextInt();if(K==1)//加法 {

int[][] c=new int[N1][M1];for(int i=0;i

} {

for(int j=0;j

}

System.out.println();} } if(K==2)//減法 {

int[][] c=new int[N1][M1];for(int i=0;i

} for(int j=0;j

for(int j:i){ System.out.print(j+” “);} System.out.println();} } if(K==3)//乘法 {

int[][] c=new int[N1][M2];for(int i=0;i

} {

for(int j=0;j

} for(int p=0;p

c[i][j]+=a[i][p]*b[p][j];for(int[] i:c)for(int j:i){ System.out.print(j+” “);} System.out.println();}

} } } 9.//保留確定位數(shù)輸出

import java.text.DecimalFormat;//非四舍五入

DecimalFormat myformat=new DecimalFormat(”#0.00");

myformat.format(double num);//四舍五入,例為保留2位

double f=3.1415926;

BigDecimal a=new BigDecimal(f);

double af=a.setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue();

第三篇：JAVA課程總結(jié)

DAY01

JavaSE第一天課程安排

##### 目標：開發(fā)第一個JAVA小程序，了解掌握相關(guān)概念

#####

內(nèi)容：

1、了解計算機相關(guān)概念

2、下載安裝Java開發(fā)環(huán)境

3、開發(fā)第一個Java程序

4、開發(fā)環(huán)境設(shè)置優(yōu)化

5、掌握Java程序的開發(fā)運行流程

6、掌握Java相關(guān)概念

7、練習

#####----------------計算機相關(guān)概念----------------

1、計算機

1、機器

2、軟件

3、數(shù)據(jù)輸入----> 數(shù)據(jù)處理----> 數(shù)據(jù)輸出-----（重要不緊急）

2、軟件----

A、系統(tǒng)軟件-----操作系統(tǒng)---windows linux B、應(yīng)用軟件-----QQ、CF、計算器（數(shù)據(jù)）軟件的功能： 數(shù)據(jù)輸入----> 數(shù)據(jù)處理----> 數(shù)據(jù)輸出 數(shù)據(jù)-----123、文件、文件夾----泛稱

3、計算機操作

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

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

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

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

B、DOS命令----CUI和GUI有對應(yīng)關(guān)系

按規(guī)律記憶

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

cd 路徑名（進入多級）

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

1、文件

增

-----notepad/write/edit 查

-----type 文件名---查看內(nèi)容 改

-----notepad/write/edit

刪

-----del 文件名稱

2、文件夾---dir

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

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

1、簡單調(diào)用----記住一個 help

2、調(diào)用 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、軟件開發(fā)

使用計算機語言開發(fā)程序 學習計算機語言：語法

總結(jié)：了解-----

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

----------------下載安裝Java開發(fā)環(huán)境----------

1、Java簡介

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

Open Net Environment----開放的網(wǎng)絡(luò)環(huán)境

JavaSE-----桌面應(yīng)用程序開發(fā)----核心----就業(yè)機會不多 JavaEE-----企業(yè)的分布式系統(tǒng)開發(fā)1）----（N從右向左數(shù)的位數(shù)）

4、負數(shù)的轉(zhuǎn)換----（不不）

-10 0000 0000 概念：原反補

正數(shù)：源碼反碼補碼都一樣

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

反碼----計數(shù)位取反，1變0,0變1

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

++--（重點）DAY03 一.算數(shù)運算符：

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.=：執(zhí)行順序，從右至左，并且最后返回變量； 2.+=： 3.-=： 4.*=： 5./=： 6.%=：

特點：帶隱式強制轉(zhuǎn)換；

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

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

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

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

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

四.邏輯運算符：

&&、||和&、|的區(qū)別：

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

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

1.位運算符：

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

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

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

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

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();三.選擇結(jié)構(gòu)：

1.if語句：

1)格式1：

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

2)格式2：

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

}else{ } //為false，執(zhí)行這里

3)格式3：

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

1).格式：

switch(表達式）{

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

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

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

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

或者到達switch語句結(jié)束。4.多個case之間，沒有順序關(guān)系；

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

DAY05 一.while循環(huán)：

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

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

for(定義循環(huán)變量表達式

;

條件表達式

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

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

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

6).進入循環(huán) 7).增量表達式......四.三種循環(huán)的區(qū)別：

1.只有do_while循環(huán)是先無條件的進入循環(huán)體執(zhí)行一次，然后再判斷；

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

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

對于循環(huán)體中的內(nèi)容，如果需要先執(zhí)行一次，再判斷，那么可以使用do_while DAY06 一.方法：

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

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

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

方法名：自定義標識符；

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

如果有，每個形參是由：數(shù)據(jù)類型 形參名

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

3.方法內(nèi)，可以寫什么？

1).定義變量；

2).if語句，switch語句； 3).各種循環(huán)語句；

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

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

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

二.數(shù)組：

1.一維數(shù)組：

1).定義的格式：

1.動態(tài)初始化：數(shù)據(jù)類型[] 數(shù)組名 = new 數(shù)據(jù)類型[數(shù)組長度];2.靜態(tài)初始化：

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

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

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

默認值：

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

1.定義的格式：

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

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

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

2.當一個方法接收的是一個“引用數(shù)據(jù)類型”是，調(diào)用方法傳遞實參時，是將“引用”復制到方法內(nèi)；

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

DAY08

一.類：是一組相關(guān)的“屬性”和“行為”的集合；

對象：是該類事物的具體體現(xiàn)； 二.類和對象的關(guān)系：

1.現(xiàn)實：

類 對象 貓 波斯貓

折耳貓 加菲貓

---------

狗 金毛

藏獒 沙皮

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.使用關(guān)鍵字：class(注意小寫)2.一個java源文件中：

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

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

3.類中可以定義什么：

1).成員變量：

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

class Student{

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

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

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

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

3).內(nèi)部類(后面講)；

4.成員變量和局部變量的區(qū)別：

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

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.當方法或其它代碼塊被執(zhí)行時，基本數(shù)據(jù)類型的“值”和引用數(shù)據(jù)類型的“引用”都是存儲在“棧”中； D.當方法或代碼塊執(zhí)行完畢時，會被立即清理；

四.對象的使用：

1.創(chuàng)建對象使用new關(guān)鍵字；會在堆中分配內(nèi)存空間； 格式：

類名

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

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

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

五.方法的形參：

1.可以是“基本數(shù)據(jù)類型”：

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

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

2.可以是“引用數(shù)據(jù)類型”：

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

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

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

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).對象調(diào)用方法僅僅一次的時候:new Student().show();2).作為實際參數(shù)傳遞:printStudent(new Student());七.封裝：

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

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

3.封裝的原則：

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

八.private關(guān)鍵字：

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

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

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

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

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

所以每個對象內(nèi)的this變量的值是不同的；

3.this關(guān)鍵字可以調(diào)用本對象的“成員屬性”、“成員方法”、“構(gòu)造方法”； 4.以下情況必須顯示的使用this：

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

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

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

DAY09

一.構(gòu)造方法：

1.當實例化一個類的對象時，JVM會自動調(diào)用本類的一個方法：構(gòu)造方法；

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

1).構(gòu)造方法名必須與類名一致；

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

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

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

class Student(){

} public void Student(){ }

//普通成員方法，不是構(gòu)造方法；

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

class Student(){ public student(){ }

//構(gòu)造方法必須同類名一致，包括大小寫；

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

構(gòu)造方法也可以調(diào)用其它構(gòu)造方法；

二.static關(guān)鍵字：

1.static關(guān)鍵字：靜態(tài)的，全局的。

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

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

3.特點：

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

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

4).可以通過類名調(diào)用，也可以通過對象名調(diào)用； 4.static關(guān)鍵字注意事項：

1).在靜態(tài)方法中是沒有this關(guān)鍵字的

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

三.靜態(tài)變量和成員變量的區(qū)別：

1.所屬不同

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

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

1).靜態(tài)變量存儲于方法區(qū)的靜態(tài)區(qū) 2).成員變量存儲于堆內(nèi)存

3.內(nèi)存出現(xiàn)時間不同 1).靜態(tài)變量隨著類的加載而加載，隨著類的消失而消失

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

4.調(diào)用不同

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

DAY10 一.代碼塊(理解)：

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

1.初始化成員變量。執(zhí)行流程：

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

二.繼承(必須掌握)：

1.使用關(guān)鍵字:extends 2.作用：代碼重用。為多態(tài)提供了前提； 3.this和super的區(qū)別：

1).this:

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

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

2).super:

1).在子類中使用；

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

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

4.類的初始化過程：

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

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

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

6.繼承的好處和弊端：

好處： 1).代碼復用

2).為多態(tài)提供了前提； 弊端：

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

三.方法重寫:

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

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

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

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

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

四.final關(guān)鍵字：

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

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

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

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

DAY11

一.多態(tài)：

1.父類的引用指向子類的對象； 2.多態(tài)前提和體現(xiàn)

1).有繼承關(guān)系 2).有方法重寫

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

3.多態(tài)的轉(zhuǎn)型：

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

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

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

5.多態(tài)的弊端： 1).不能訪問子類特有功能(可以向下轉(zhuǎn)型)6.多態(tài)時的訪問規(guī)則：

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

例如：

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();//多態(tài)

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()”);

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

二.抽象類：

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

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

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

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

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

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

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

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

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

例如：

abstract class A{ } class B extends A{ }

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

5.abstract關(guān)鍵字不能和哪些關(guān)鍵字共存：

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

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

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

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

三.接口：

1.使用interface關(guān)鍵字定義：只能修飾“類”：

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

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

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

例如： interface IA{

} public int num1 = 10;

//OK

上述三個關(guān)鍵字中任何一個都可以不寫，系統(tǒng)會自動添加；

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

//OK

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

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

例如： interface IA{

} void show1();

//OK

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

3.子類實現(xiàn)接口使用關(guān)鍵字：implements 4.一個子類可以同時實現(xiàn)多個接口；

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

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

例如：

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

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

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

四.多態(tài)的形式：

1.父類的多態(tài)； 2.抽象類多態(tài)； 3.接口多態(tài)；

五.類與類，類與接口，接口與接口的關(guān)系：

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

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

3.接口與接口：繼承關(guān)系，關(guān)鍵字：extends，可以單繼承，也可以多繼承

例如：

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

六.抽象類和接口的區(qū)別：

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

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

2.關(guān)系區(qū)別

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

2).類與接口 實現(xiàn)，單實現(xiàn)，多實現(xiàn) 3).接口與接口 繼承，單繼承，多繼承

3.設(shè)計理念區(qū)別

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

一.類名作為形參：

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).使用此類類型；(多態(tài))2).不能使用某個子類類型接收；

六.接口作為返回值：

1.可以返回的類型：

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

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

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

DAY12

一.包：

1.定義包使用關(guān)鍵字：package；

1).注意事項：

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

2.導入包使用關(guān)鍵字：import；

1).注意事項：

A.導入到最終的類；

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

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

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

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

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

只能被子類訪問；

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

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

1).類：

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

2).成員變量：

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

3).構(gòu)造方法：

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

4).成員方法：

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

三.內(nèi)部類：

1.成員內(nèi)部類：

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

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

2.局部內(nèi)部類：

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

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

3.匿名內(nèi)部類：

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

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

DAY14 一.Object類：

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

public class Object{ public Object(){

內(nèi)存的操作；

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

//默認實現(xiàn)：將此對象的地址轉(zhuǎn)換為int值返回；

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

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

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

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

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

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

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

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

} protected Object clone(){

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

--

二.java.lang.String類：

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

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

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

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

2.堆：new String())

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

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.構(gòu)造方法：

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

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

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

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

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

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

boolean startsWith(String str):判斷字符串是否以參數(shù)字符串開頭； boolean endsWith(String str):判斷字符串是否以參數(shù)字符串結(jié)尾； 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()：獲取此字符串內(nèi)部的字符數(shù)量。(區(qū)分數(shù)組的length屬性)char charAt(int index)：獲取此字符串中index位置的字符char;int indexOf(int ch)：從左向右查找，獲取字符ch在字符串中第一次出現(xiàn)的位置。如果不包含，則返回：false

int indexOf(String str)：獲取字符串str在此字符串中第一次出現(xiàn)的位置。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).轉(zhuǎn)換功能：

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

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

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

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編碼表的順序與參數(shù)字符串比較；

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):不區(qū)分大小寫的比較；

DAY15 一.StringBuffer類：

1.String的緩沖池類。

2.String和StringBuffer的區(qū)別：

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

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

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

3.添加功能：

public StringBuffer append(String str)：及各種重載的方法。將任何類型的參數(shù)添加到末尾； 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.反轉(zhuǎn)功能： public StringBuffer reverse()：反轉(zhuǎn)內(nèi)部字符串；

7.截取功能：

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

二.StringBuffer類和StringBuilder類的區(qū)別：

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

三.Arrays類：

1.對數(shù)組操作的類，沒有構(gòu)造方法，內(nèi)部包含了大量靜態(tài)的工具方法； 2.常用方法：

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

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

四.包裝類：

基本數(shù)據(jù)類型 byte short int long char float 包裝類型

Byte Short Integer

Long Character Float Double Boolean double boolean

第四篇：java知識點小結(jié)

java重要知識點總結(jié)如下：

1，抽象，封裝，繼承，多態(tài)是面向?qū)ο蟪绦蛟O(shè)計中得四個特點.2，面向?qū)ο蟮密浖_發(fā)大體分為：面向?qū)ο蟮姆治?，面向?qū)ο蟮脑O(shè)計，面向?qū)ο蟮膶崿F(xiàn).可概括為如下過程：分析用戶需求，從問題中抽取對象模型;細化模型，設(shè)計類，包括類的屬性和類間的

相互關(guān)系，同時觀察是否有可以直接引用的已有類或部件;選定一種面向?qū)ο蟮木幊陶Z言，具體編碼實現(xiàn)

上一階段類的設(shè)計，并在開發(fā)過程中引入測試，完善整個解決方案.3，面向?qū)ο蟪绦蛟O(shè)計方法的優(yōu)點是：可重用性，可擴展性，可管理性.4，類的定義：class前的修飾符分為訪問控制符和非訪問控制符兩大類.訪問控制符包括public和private.非訪問控制符包括abstract(抽象)，final(最終).5，final類是最終類，是不能有子類的類.abstract和final不能同時修飾一個類，因為抽象類本身沒有具體對象，需要派生出子類后在創(chuàng)建子類的對象.而最終類不可能有子類.6，創(chuàng)建對象的格式為： 類名 對象名=new 構(gòu)造方法(參數(shù));注意前面是類名后面是構(gòu)造方法.注意構(gòu)造方法沒有返回類型，也不能寫void，主要用于完成類對象的初始化工作，一般不能直接由編程

直接調(diào)用，而是用new運算符來調(diào)用.7，如果class前面由public修飾符，則默認構(gòu)造方法的前面也應(yīng)該有public修飾符.8，類中有static修飾的域或方法，可用類名或?qū)ο竺L問，否則只能用對象名訪問.9，修飾域的訪問控制符可以是：public，private，protected，private protected.非訪問控制符可以是：

static，final，volatile(易失域)

10，類變量的最本質(zhì)的特點是：他們是類的域，不屬于任何一個類的具體對象實例.不是保存在某個對象實例的內(nèi)存空間中，而是保存在類的內(nèi)存區(qū)域的公共存儲單元中.11，局部變量是在方法體內(nèi)聲明的，只有當方法被調(diào)用時他們才存在，因而只能在本方法內(nèi)使用，不存在訪問控制符，也不能聲明為靜態(tài)變量(static)，但可以聲明為final變量.局部變量必須初始化.12，修飾方法的訪問控制符可以是：public，private，protected，private protected，修飾方法的非訪問控制符可以是：static，final，abstract，native(本地方法)，synchronized(同步方法)。

13，用static修飾的變量或方法都為類成員，類成員可以用類名或?qū)嵗L問，實例成員只能用實例名來訪問。

14，如果一個類中含有抽象方法，則此類必須為抽象類，如果抽象類的子類不為抽象類，則子類必須實現(xiàn)父類的所有抽象方法。抽象方法不能用靜態(tài)方法和最終方法。抽想方法只有函數(shù)頭的聲明，而用分號來替代方法體，沒有大括號。如abstract void abstractmethod();

15，this變量用在一個方法的內(nèi)部，指向當前對象，當前對象指的是調(diào)用當前正在執(zhí)行的方法的那個對象。super變量是直接指向父類的構(gòu)造方法，用來引用父類種的變量和方法。(由于他們指的是對象，所以不能通過它來引用類變量和類方法)

16，如果要引用一個包中的多個類，可以用星號來代替。使用星號只能表示本層次的所有類，而不包括子層次下的類。所以經(jīng)常需要用兩條語句來引入兩個層次的類：import java.awt.*;import java.awt.event.*;

17，訪問修飾符：

--類中限定為public的成員可以被所有的類訪問。

--類中先定位private的成員只能被這個類本身訪問。同一個類的不同對象可以訪問對方的private域變量或調(diào)用對方的域方法，這是因為訪問保護控制在類的級別上，而不是對象的級別上。

--類中限定為protected的成員可以被這個類本身，它的子類(包括同一個包中和不同包中的子類)，以及同一個包中的其他類訪問。

--用private protected修飾的成員可以被該類本身訪問，也可以被該類的所有子類訪問。

--默認訪問控制符規(guī)定只能被同一個包中的類訪問和引用，而不能被其他包的類訪問。即他的訪問權(quán)限是friendly。

18，注意：

----abstract和private，static，final，native不能并列修飾同一個方法。

----abstract類中不能有private修飾的域和方法

----static方法不能處理非static的域。

19，重載方法的參數(shù)必須不同，或者是參數(shù)個數(shù)不同，或者是參數(shù)類型不同。重載的多個方法必須返回相同的數(shù)據(jù)類型。

20，在java中，一個類獲取某一接口定義的功能并不是通過直接繼承這個接口的屬性和方法來實現(xiàn)的。因為接口中的屬性都是常量，接口的方法都是沒有方法體的抽象方法，沒有具體定義操作。

第五篇：java個人小結(jié)（范文模版）

原文[2007年03月25日 星期日 上午 03:04]

Java發(fā)展到現(xiàn)在，按應(yīng)用來分主要分為三大塊：J2SE,J2ME和J2EE。這三塊相互補充，應(yīng)用范圍不同。

J2SE就是Java2的標準版，主要用于桌面應(yīng)用軟件的編程；

J2ME主要應(yīng)用于嵌入是系統(tǒng)開發(fā)，如手機和PDA的編程；

J2EE是Java2的企業(yè)版，主要用于分布式的網(wǎng)絡(luò)程序的開發(fā)，如電子商務(wù)網(wǎng)站和ERP系統(tǒng)。先學習j2se

要學習j2ee就要先學習j2se，剛開始學習j2se先建議不要使用IDE，然后漸漸的過渡到使用IDE開發(fā)，畢竟用它方便嘛。學習j2se推薦兩本書，《java2核心技術(shù)一二卷》，《java編程思想》，《java模式》。其中《java編程思想》要研讀，精讀。這一段時間是基本功學習，時間會很長，也可能很短，這要看學習者自身水平而定。

不要被IDE糾纏

在學習java和j2ee過程中，你會遇到五花八門的IDE，不要被他們迷惑，學JAVA的時候，要學語言本身的東西，不要太在意IDE的附加功能，JAVA編程在不同IDE之間的轉(zhuǎn)換是很容易的，過于的在意IDE的功能反而容易耽誤對語言本身的理解。目前流行的IDE有jbuilder，eclipse和eclipse的加強版WSAD。用好其中一個就可以了，推薦從eclipse入手j2ee。因為Jbuilder更適合于寫j2se程序。

選擇和學習服務(wù)器使用配置

當你有了j2se和IDE的經(jīng)驗時，可以開始j2ee的學習了，web服務(wù)器：tomcat，勿庸置疑，tomcat為學習web服務(wù)首選。而應(yīng)用服務(wù)器目前主要有三個：jboss、weblogic、websphere。有很多項目開始采用jboss，并且有大量的公司開始做websphere或weblogic向jboss應(yīng)用服務(wù)器的移植（節(jié)省成本），這里要說的是，學習tomcat和jboss我認為是首選，也是最容易上手的。學習服務(wù)器使用配置最好去詢問有經(jīng)驗的人（有條件的話），因為他們或許一句話就能解決問題，你自己上網(wǎng)摸索可能要一兩天（我就干過這種傻事），我們應(yīng)該把主要時間放在學習原理和理論上，一項特定技術(shù)的使用永遠代替不了一個人的知識和學問。

學習web知識

如果你是在做電子商務(wù)網(wǎng)站等時，你可能要充當幾個角色，這是你還要學習：

html，可能要用到dreamwave等IDE。

Javascript，學會簡單的數(shù)據(jù)校驗，數(shù)據(jù)聯(lián)動顯示等等

J2eeAPI學習

學習j2eeAPI和學習服務(wù)器應(yīng)該是一個迭代的過程。

先學習jsp和servlet編程，這方面的書很多，我建立看oreilly公司的兩本《jsp設(shè)計》和《java servlet編程》，oreilly出的書總是那本優(yōu)秀，不得不佩服。

學習jdbc數(shù)據(jù)庫編程，j2ee項目大多都是MIS系統(tǒng)，訪問數(shù)據(jù)庫是核心。這本應(yīng)屬于j2se學習中，這里拿出來強調(diào)一下。

學習jndi api，它和學習ejb可以結(jié)合起來。

學習ejb api，推薦書《精通ejb》

經(jīng)過上面的這些的學習，大概可以對付一般的應(yīng)用了。

有人說跟著sun公司的《j2ee tutorial》一路學下來，當然也可以。

學習ejb設(shè)計模式和看代碼（最重要）

設(shè)計模式是練內(nèi)功，其重要性可以這么說吧，如果你不會用設(shè)計模式的話，你將寫出一堆使用了ejb的垃圾，有慢又是一堆bug，其結(jié)果不如不用ejb實現(xiàn)（ejb不等于j2ee）

無論學習什么語言，都應(yīng)該看大量代碼，你看的代碼量不到一定數(shù)量，是學不好j2ee的目前有很多開源的工程可以作為教材：

jive論壇

petstore sun公司

dune sun公司

等等，研讀一個，并把它用到自己的工程中來。

J2ee其他學習

當你漸漸對j2ee了解到一定深度時，你要開始關(guān)注當前領(lǐng)域中的一些技術(shù)變化，J2ee是一塊百家爭鳴的領(lǐng)域，大家都在這里提出自己的解決方案，例如structs，hiberate，ofbiz等等，學習這些東西要你的項目和目標而定，預(yù)先補充一下未嘗不可，但不用涉及太深，畢竟學習原理和理論是最最重要的事。

目前常見j2eeAPI

JavaServer Pages(JSP)技術(shù)1.2

Java Servlet技術(shù)2.3

JDBC API 2.0

Java XML處理API(JAXP)1.1

Enterprise JavaBeans技術(shù)2.0

Java消息服務(wù)(JMS)1.0

Java命名目錄接口(JNDI)1.2

Java事務(wù)API(JTA)1.0

JavaMail API 1.2

JavaBeans激活架構(gòu)(JAF)1.0

J2EE連接器體系結(jié)構(gòu)(JCA)1.0

Java認證和授權(quán)服務(wù)(JAAS)1.0

學習上面的某些API要以你的項目而定，了解所有他們總之是有好處的上面印證了大家說的一句話，java語言本身不難學，但是技術(shù)太多，所以學java很費勁?；叵胍幌拢旧厦總€初學者，在剛學習java的時候可能都會問別人這么一句話，你怎么知道的哪個方法(api)在哪個包里的？呵呵，無他，唯手熟爾。

2008年10月29日 星期三 下午 9:29