java
1.4.1 第一個(gè)java application
//這是我們的第一個(gè)java application，該程序保存在文件Property.java中
import java.util.*; /*下面我們用到了Date和Properties這兩個(gè)類(lèi)，是
屬于java.util這個(gè)包的；*/
/*而System和Runtime這兩個(gè)類(lèi)，是屬于
java.lang這個(gè)包的。*/
public class Property { //程序員給這個(gè)類(lèi)取名為Property
public static void main(String args[]){ //main是類(lèi)的主方法
System.out.println(new Date( )); //在命令行下面打印出日期
Properties p=System.getProperties( ); //獲得系統的Properties對象p
p.list(System.out); //在命令行下打印出p中的各個(gè)系統變量的值
System.out.println("--- Memory Usage:"); /*打印一行字符串---Memory Usage*/
Runtime rt=Runtime.getRuntime( ); //獲得系統的Runtime對象rt
System.out.println("Total Memory= "
+ rt.totalMemory( ) //打印總內存大小
+" Free Memory = "
+rt.freeMemory( )); //打印空閑內存大小
}
}
--觀(guān)看動(dòng)畫(huà)--在java中，程序都是以類(lèi)的方式組織的，java源文件都保存在以java為后綴的.java文件當中。每個(gè)可運行的程序都是一個(gè)類(lèi)文件，或者稱(chēng)之為字節碼文件，保存在.class文件中。而作為一個(gè)java application，類(lèi)中必須包含主方法，程序的執行是從main方法開(kāi)始的，方法頭的格式是確定不變的：
public static void main(String args[])
其中關(guān)鍵字public意味著(zhù)方法可以由外部世界調用。main方法的參數是一個(gè)字符串數組args，雖然在本程序中沒(méi)有用到，但是必須列出來(lái)。
程序的第一行非常有意思：
System.out.println(new Date());
打印語(yǔ)句的參數是一個(gè)日期對象Date，而創(chuàng )建Date對象的目的就是把它的值發(fā)給println()語(yǔ)句。一旦這個(gè)語(yǔ)句執行完畢，Date對象就沒(méi)用了，而后"無(wú)用內存回收器"會(huì )將其收回。
第二行中調用了System.getProperties( )。從幫助文檔中可知，getProperties( )是System類(lèi)的一個(gè)靜態(tài)方法（static 方法），由于它是"靜態(tài)"的，所以不必創(chuàng )建任何對象就可以調用該方法。在第三行，Properties對象有一個(gè)名為list( )的方法，它將自己的全部?jì)热荻及l(fā)給一個(gè)PrintStream對象，該對象就是list()方法的參數。
第四行和第六行是典型的打印語(yǔ)句，其中第六行通過(guò)運算符"＋"的重載來(lái)連接多個(gè)字符串對象，在java中只有當"＋"運算符作用于字符串時(shí)在能夠進(jìn)行重載。但是讓我們仔細觀(guān)察下述語(yǔ)句：
System.out.println("Total Memory= "
+ rt.totalMemory( ) //打印總內存大小
+" Free Memory = "
+rt.freeMemory( )); //打印空閑內存大小
其中，totalMemory( )和freeMemory( )返回的是數值，并非String對象。如果將一個(gè)字符串與一個(gè)數值相加，結果會(huì )如何？在這種情況下，編譯器會(huì )自動(dòng)調用一個(gè)toString()方法，將該數值（int型或者float型）轉換成字符串。經(jīng)過(guò)這樣處理以后，就可以用"＋"進(jìn)行字符串連接了。
main()的第五行通過(guò)調用Runtime的getRuntime()方法創(chuàng )建了一個(gè)Runtime對象，該對象中包含了內存等信息。
//這是我們的第一個(gè)java applet，該程序保存在文件HelloEducation.java中
import java.awt.Graphics; //在進(jìn)行顯示輸出時(shí)，需要用到類(lèi)Graphics的對象；
import java.applet.Applet; //Applet類(lèi)是所有的java applet的父類(lèi)；
public class HelloEducation extends Applet {
//程序員給這個(gè)類(lèi)取名為HelloEducation
//所有的applet程序都是Applet類(lèi)的子類(lèi)
public String s;
public void init() { //
s=new String("Welcome to Tongfang Education");
//生成一個(gè)字符串對象
}
public void paint(Graphics g){
g.drawString(s,25,25);
//在瀏覽器中坐標為（25，25）的位置顯示字符串s
}
}
--觀(guān)看動(dòng)畫(huà)--applet程序是從方法init( )開(kāi)始執行的，在該方法中完成了對字符串s的初始化工作，而顯示功能是在方法paint( )中執行的。paint( )方法是類(lèi)Applet的一個(gè)成員方法，其參數是圖形對象Graphics g，通過(guò)調用對象g的drawString( )方法就可以顯示輸出。
一個(gè)完整的java源程序應該包括下列部分：
package語(yǔ)句； //該部分至多只有一句，必須放在源程序的第一句
import語(yǔ)句； /*該部分可以有若干import語(yǔ)句或者沒(méi)有，必須放在所有的
類(lèi)定義之前*/
public classDefinition； //公共類(lèi)定義部分，至多只有一個(gè)公共類(lèi)的定義
//java語(yǔ)言規定該java源程序的文件名必須與該公共類(lèi)名完全一致
classDefinition; //類(lèi)定義部分，可以有0個(gè)或者多個(gè)類(lèi)定義
interfaceDefinition; //接口定義部分，可以有0個(gè)或者多個(gè)接口定義
例如一個(gè)java源程序可以是如下結構，該源程序命名為HelloWorldApp.java：
package javawork.helloworld; /*把編譯生成的所有.class文件放到包
javawork.helloworld中*/
import java.awt.*; //告訴編譯器本程序中用到系統的AWT包
import javawork.newcentury; /*告訴編譯器本程序中用到用戶(hù)自定義
的包javawork.newcentury*/
public class HelloWorldApp{......} /*公共類(lèi)HelloWorldApp的定義，
名字與文件名相同*/
class TheFirstClass{......} //第一個(gè)普通類(lèi)TheFirstClass的定義
class TheSecondClass{......} //第二個(gè)普通類(lèi)TheSecondClass的定義
...... //其它普通類(lèi)的定義
interface TheFirstInterface{......} /*第一個(gè)接口
TheFirstInterface的定義*/
...... //其它接口定義
package語(yǔ)句：由于java編譯器為每個(gè)類(lèi)生成一個(gè)字節碼文件，且文件名與類(lèi)名相同，因此同名的類(lèi)有可能發(fā)生沖突。為了解決這一問(wèn)題，java提供包來(lái)管理類(lèi)名空間，包實(shí)際提供了一種命名機制和可見(jiàn)性限制機制。而在java的系統類(lèi)庫中，把功能相似的類(lèi)放到一個(gè)包（package）中，例如所有的圖形界面的類(lèi)都放在java.awt這個(gè)包中，與網(wǎng)絡(luò )功能有關(guān)的類(lèi)都放到j(luò )ava.net這個(gè)包中。用戶(hù)自己編寫(xiě)的類(lèi)（指.class文件）也應該按照功能放在由程序員自己命名的相應的包中，例如上例中的javawork.helloworld就是一個(gè)包。包在實(shí)際的實(shí)現過(guò)程中是與文件系統相對應的，例如javawork.helloworld所對應的目錄是path\javawork\helloworld，而path是在編譯該源程序時(shí)指定的。比如在命令行中編譯上述HelloWorldApp.java文件時(shí)，可以在命令行中敲入"javac -d f:\javaproject HelloWorldApp.java"，則編譯生成的HelloWorldApp.class文件將放在目錄f:\javaproject\javawork\helloworld\目錄下面，此時(shí)f:\javaprojcet相當于path。但是如果在編譯時(shí)不指定path，則生成的.class文件將放在編譯時(shí)命令行所在的當前目錄下面。比如在命令行目錄f:\javaproject下敲入編譯命令"javac HelloWorldApp.java"，則生成的HelloWorldApp.class文件將放在目錄f:\javaproject下面，此時(shí)的package語(yǔ)句相當于沒(méi)起作用。
但是，如果程序中包含了package語(yǔ)句，則在運行時(shí)就必須包含包名。例如，HelloWorldApp.java程序的第一行語(yǔ)句是：package p1.p2；編譯的時(shí)候在命令行下輸入"javac -d path HelloWorldApp.java"，則HelloWorldApp.class將放在目錄path\p1\p2的下面，這時(shí)候運行該程序時(shí)有兩種方式：
第一種：在命令行下的path目錄下輸入字符"java p1.p2.HelloWorldApp"。
第二種：在環(huán)境變量classpath中加入目錄path，則運行時(shí)在任何目錄下輸入"java p1.p2.HelloWorldApp"即可。
import語(yǔ)句：如果在源程序中用到了除java.lang這個(gè)包以外的類(lèi)，無(wú)論是系統的類(lèi)還是自己定義的包中的類(lèi)，都必須用import語(yǔ)句標識，以通知編譯器在編譯時(shí)找到相應的類(lèi)文件。例如上例中的java.awt是系統的包，而javawork.newcentury是用戶(hù)自定義的包。比如程序中用到了類(lèi)Button，而B(niǎo)utton是屬于包java.awt的，在編譯時(shí)編譯器將從目錄classpath\java\awt中去尋找類(lèi)Button，classpath是事先設定的環(huán)境變量，比如可以設為：classpath=.；d:\jdk1.3\lib\。 classpath也可以稱(chēng)為類(lèi)路徑，需要提醒大家注意的是，在classpath中往往包含多個(gè)路徑，用分號隔開(kāi)。例如classpath=.；d:\jdk1.3\lib\中的第一個(gè)分號之前的路徑是一個(gè)點(diǎn)，表示當前目錄，分號后面的路徑是d:\jdk1.3\lib\，表示系統的標準類(lèi)庫目錄。在編譯過(guò)程中尋找類(lèi)時(shí)，先從環(huán)境變量classpath的第一個(gè)目錄開(kāi)始往下找，比如先從當前目錄往下找java.awt中的類(lèi)Button時(shí),編譯器找不著(zhù)，然后從環(huán)境變量classpath的第二個(gè)目錄開(kāi)始往下找，就是從系統的標準類(lèi)庫目錄d:\jdk1.3\lib開(kāi)始往下找java.awt的Button這個(gè)類(lèi)，最后就找到了。如果要從一個(gè)包中引入多個(gè)類(lèi)則在包名后加上".*"表示。
如果程序中用到了用戶(hù)自己定義的包中的類(lèi)，假如在上面程序中要用到j(luò )avawork.newcentury包中的類(lèi)HelloWorldApp，而包javawork.newcentury所對應的目錄是f:\javaproject\javawork\newcentury，classpath仍舊是classpath=.；d:\jdk1.3\lib\，則編譯器在編譯時(shí)將首先從當前目錄尋找包javawork.newcentury，結果是沒(méi)有找到；然后又從環(huán)境變量classpath的第二個(gè)目錄d:\jdk1.3\lib\開(kāi)始往下找，但是仍然沒(méi)有找到。原因在于包javawork.newcentury是放在目錄f:\javaproject下面。因此，需要重新設定環(huán)境變量classpath，設為classpath=.；d:\jdk1.3\lib\；f:\javaproject\ 。所以編譯器從f:\javaproject開(kāi)始找包javawork.newcentury就可以找到。
源文件的命名規則：如果在源程序中包含有公共類(lèi)的定義，則該源文件名必須與該公共類(lèi)的名字完全一致，字母的大小寫(xiě)都必須一樣。這是java語(yǔ)言的一個(gè)嚴格的規定，如果不遵守，在編譯時(shí)就會(huì )出錯。因此，在一個(gè)java源程序中至多只能有一個(gè)公共類(lèi)的定義。如果源程序中不包含公共類(lèi)的定義，則該文件名可以任意取名。如果在一個(gè)源程序中有多個(gè)類(lèi)定義，則在編譯時(shí)將為每個(gè)類(lèi)生成一個(gè).class文件。
單行注釋?zhuān)簭?http://"開(kāi)始到本行結束的內容都是注釋?zhuān)纾?div style="height:15px;">
//這是一行單行注釋
//則是另一行單行注釋
多行注釋?zhuān)涸?/*"和"*/"之間的所有內容都是注釋?zhuān)纾?div style="height:15px;">
/*這是一段注釋分布在多行之中*/
文檔注釋?zhuān)涸谧⑨尫矫鎗ava提供一種C/C++所不具有的文檔注釋方式。其核心思想是當程序員編完程序以后，可以通過(guò)JDK提供的javadoc命令，生成所編程序的API文檔，而該文檔中的內容主要就是從文檔注釋中提取的。該API文檔以HTML文件的形式出現，與java幫助文檔的風(fēng)格與形式完全一致。凡是在"/**"和"*/"之間的內容都是文檔注釋。例如下面的DocTest.java文件：
/** 這是一個(gè)文檔注釋的例子，主要介紹下面這個(gè)類(lèi) */
public class DocTest{
/** 變量注釋?zhuān)旅孢@個(gè)變量主要是充當整數計數 */
public int i;
/** 方法注釋?zhuān)旅孢@個(gè)方法的主要功能是計數 */
public void count( ) {}
}
1． java中的數據類(lèi)型劃分
java語(yǔ)言的數據類(lèi)型有簡(jiǎn)單類(lèi)型和復合類(lèi)型：
簡(jiǎn)單數據類(lèi)型包括：
整數類(lèi)型（Integer）：byte， short， int， long
浮點(diǎn)類(lèi)型（Floating）：float，double
字符類(lèi)型（Textual）：char
布爾類(lèi)型（Logical）：boolean
復合數據類(lèi)型包括：
class
interface
數組
2．常量和變量
常量：用保留字final來(lái)實(shí)現
final typeSpecifier varName=value[,varName[=value]…];
如：final int NUM=100;
變量：是java 程序中的基本存儲單元，它的定義包括變量名、變量類(lèi)型和作用域幾個(gè)部分。其定義格式如下：
typeSpecifier varName[=value[,varName[=value]…];
如：int count; char c='a';
變量的作用域指明可訪(fǎng)問(wèn)該變量的一段代碼，聲明一個(gè)變量的同時(shí)也就指明了變量的作用域。按作用域來(lái)分，變量可以有下面幾種：局部變量、類(lèi)變量、方法參數和例外處理參數。在一個(gè)確定的域中，變量名應該是唯一的。局部變量在方法或方法的一個(gè)塊代碼中聲明，它的作用域為它所在的代碼塊（整個(gè)方法或方法中的某塊代碼）。類(lèi)變量在類(lèi)中聲明，而不是在類(lèi)的某個(gè)方法中聲明，它的作用域是整個(gè)類(lèi)。方法參數傳遞給方法，它的作用域就是這個(gè)方法。例外處理參數傳遞給例外處理代碼，它的作用域就是例外處理部分。
1．布爾類(lèi)型--boolean
布爾型數據只有兩個(gè)值true和false，且它們不對應于任何整數值。布爾型變量的定義如：
boolean b=true;
2．字符類(lèi)型--char
字符常量：
字符常量是用單引號括起來(lái)的一個(gè)字符，如'a'，'A';
字符型變量：
類(lèi)型為char，它在機器中占16位，其范圍為0～65535。字符型變量的定義如：
char c='a'; /*指定變量c為char型，且賦初值為'a'*/
3．整型數據
整型常量：
◇ 十進(jìn)制整數
如123，－456，0
◇ 八進(jìn)制整數
以0開(kāi)頭，如0123表示十進(jìn)制數83，－011表示十進(jìn)制數－9。
◇ 十六進(jìn)制整數
以0x或0X開(kāi)頭，如0x123表示十進(jìn)制數291，－0X12表示十進(jìn)制數－18。
整型變量：
數據類(lèi)型
所占位數
數的范圍
byte
8
-27～27-1
bhort
16
-215～215-1
int
32
-231～231-1
long
64
-263～263-1
4．浮點(diǎn)型（實(shí)型）數據
實(shí)型常量：
◇ 十進(jìn)制數形式
由數字和小數點(diǎn)組成，且必須有小數點(diǎn)，如0.123, 1.23, 123.0
◇ 科學(xué)計數法形式
如：123e3或123E3，其中e或E之前必須有數字，且e或E后面的指數必須為整數。
◇ float型的值,必須在數字后加f或F,如1.23f。
實(shí)型變量：
數據類(lèi)型
所占位數
數的范圍
float
32
3.4e-038 ～3.4e+038
double
64
1.7e-038 ～1.7e+038
5．簡(jiǎn)單數據類(lèi)型的例子：
【例2．1】
public class Assign {
public static void main (String args [ ] ) {
int x , y ; //定義x，y兩個(gè)整型變量
float z = 1.234f ; //指定變量z為float型，且賦初值為1.234
double w = 1.234 ; //指定變量w為double型，且賦初值為1.234
boolean flag = true ; //指定變量flag為boolean型，且賦初值為true
char c ; //定義字符型變量c
String str ; //定義字符串變量str
String str1 = " Hi " ; //指定變量str1為String型，且賦初值為Hi
c = ' A ' ; //給字符型變量c賦值'A'
str = " bye " ; //給字符串變量str賦值"bye"
x = 12 ; //給整型變量x賦值為12
y = 300; //給整型變量y賦值為300
}
}
對各種類(lèi)型的數據進(jìn)行加工的過(guò)程成為運算，表示各種不同運算的符號稱(chēng)為運算符，參與運算的數據稱(chēng)為操作數，按操作數的數目來(lái)分，可有：
◇ 一元運算符：＋＋，－－，＋，－
◇ 二元運算符：＋，－，>
◇ 三元運算符：？：
基本的運算符按功能劃分，有下面幾類(lèi)：
1 算術(shù)運算符： +，―，*，/，%，++，――。
例如：
3+2;
a-b;
i++;
--i;
2 關(guān)系運算符： >，<，>=，<=，==，!=。
例如：
count>3;
I==0;
n!=-1;
3 布爾邏輯運算符： !，&&，|| 。
例如：
flag=true;
!(flag);
flag&&false;
4 位運算符： >>，<<，>>>，&，|，^，~。
例如：
a=10011101; b=00111001；則有如下結果：
a<<3 =11101000;
a>>3 =11110011 a>>>3=00010011;
a&b=00011001; a|b=10111101;
~a=01100010; a^b=10100100;
5 賦值運算符 =，及其擴展賦值運算符如+=，―=，*=，/=等。
例如：
i=3;
i+=3; //等效于i=i+3;
6 條件運算符 ? ：
例如：result=(sum= =0 ? 1 : num/sum);
7 其它：
包括分量運算符· ，下標運算符 []，實(shí)例運算符instanceof，內存分配運算符new，強制類(lèi)型轉換運算符 (類(lèi)型)，方法調用運算符 () 等。例如：
System.out.println("hello world");
int array1[]=new int[4];
分支語(yǔ)句提供了一種控制機制，使得程序的執行可以跳過(guò)某些語(yǔ)句不執行，而轉去執行特定的語(yǔ)句。
1．條件語(yǔ)句 if-else
if(boolean-expression)
statement1;
[else statement2;]
2．多分支語(yǔ)句 switch
switch (expression){
case value1 : statement1;
break;
case value2 : statement2;
break;
…………
case valueN : statemendN;
break;
[default : defaultStatement; ]
}
◇ 表達式expression的返回值類(lèi)型必須是這幾種類(lèi)型之一：int,byte,char,short。
◇ case子句中的值valueN必須是常量，而且所有case子句中的值應是不同的。
◇ default子句是可選的。
◇break語(yǔ)句用來(lái)在執行完一個(gè)case分支后，使程序跳出switch語(yǔ)句，即終止switch語(yǔ)句的執行（在一些特殊情況下，多個(gè)不同的case值要執行一組相同的操作，這時(shí)可以不用break）。
1．while語(yǔ)句
[initialization]
while (termination){
body;
[iteration;]
}
2．do-while語(yǔ)句
[initialization]
do {
body;
[iteration;]
} while (termination);
3．for語(yǔ)句
for (initialization; termination; iteration){
body;
}
◇ for語(yǔ)句執行時(shí)，首先執行初始化操作，然后判斷終止條件是否滿(mǎn)足，如果滿(mǎn)足，則執行循環(huán)體中的語(yǔ)句，最后執行迭代部分。完成一次循環(huán)后，重新判斷終止條件。
◇ 初始化、終止以及迭代部分都可以為空語(yǔ)句(但分號不能省)，三者均為空的時(shí)候，相當于一個(gè)無(wú)限循環(huán)。
◇ 在初始化部分和迭代部分可以使用逗號語(yǔ)句，來(lái)進(jìn)行多個(gè)操作。逗號語(yǔ)句是用逗號分隔的語(yǔ)句序列。
for( i=0, j=10; i<j; i++, j--){
……
}
1．break語(yǔ)句
◇ 在switch語(yǔ)中，break語(yǔ)句用來(lái)終止switch語(yǔ)句的執行。使程序從switch語(yǔ)句后的第一個(gè)語(yǔ)句開(kāi)始執行。
◇ 在Java中，可以為每個(gè)代碼塊加一個(gè)括號，一個(gè)代碼塊通常是用大括號{}括起來(lái)的一段代碼。加標號的格式如下：
BlockLabel: { codeBlock }
break語(yǔ)句的第二種使用情況就是跳出它所指定的塊，并從緊跟該塊的第一條語(yǔ)句處執行。例如：
break BlockLabel；
break語(yǔ)句
a:{…… //標記代碼塊a
b:{…… //標記代碼塊b
c:{…… //標記代碼塊c
break b;
…… //此處的語(yǔ)句塊不被執行
}
…… /此處的語(yǔ)句塊不被執行
}
…… //從此處開(kāi)始執行
}
2．continue語(yǔ)句
continue語(yǔ)句用來(lái)結束本次循環(huán)，跳過(guò)循環(huán)體中下面尚未執行的語(yǔ)句，接著(zhù)進(jìn)行終止條件的判斷，以決定是否繼續循環(huán)。對于for語(yǔ)句，在進(jìn)行終止條件的判斷前，還要先執行迭代語(yǔ)句。它的格式為：
continue；
也可以用continue跳轉到括號指明的外層循環(huán)中，這時(shí)的格式為
continue outerLable;
例如：
outer: for( int i=0; i<10; i++ ){ //外層循環(huán)
inner: for( int j=0; j<10; j++ ){ //內層循環(huán)
if( i<j ){
……
continue outer;
}
……
}
……
}
3．返回語(yǔ)句return
return語(yǔ)句從當前方法中退出，返回到調用該方法的語(yǔ)句處，并從緊跟該語(yǔ)句的下一條語(yǔ)句繼續程序的執行。返回語(yǔ)句有兩種格式：
return expression ;
return;
return語(yǔ)句通常用在一個(gè)方法體的最后,否則會(huì )產(chǎn)生編譯錯誤,除非用在if-else語(yǔ)句中
1． 一維數組的定義
type arrayName[ ]；
類(lèi)型(type)可以為Java中任意的數據類(lèi)型，包括簡(jiǎn)單類(lèi)型和復合類(lèi)型。
例如：
int intArray[ ]；
Date dateArray[];
2．一維數組的初始化
◇ 靜態(tài)初始化
int intArray[]={1,2,3,4};
String stringArray[]={"abc", "How", "you"};
◇ 動(dòng)態(tài)初始化
1）簡(jiǎn)單類(lèi)型的數組
int intArray[];
intArray = new int[5];
2）復合類(lèi)型的數組
String stringArray[ ];
String stringArray = new String[3];/*為數組中每個(gè)元素開(kāi)辟引用
空間(32位) */
stringArray[0]= new String("How");//為第一個(gè)數組元素開(kāi)辟空間
stringArray[1]= new String("are");//為第二個(gè)數組元素開(kāi)辟空間
stringArray[2]= new String("you");// 為第三個(gè)數組元素開(kāi)辟空間
3．一維數組元素的引用
數組元素的引用方式為：
arrayName[index]
index為數組下標，它可以為整型常數或表達式，下標從0開(kāi)始。每個(gè)數組都有一個(gè)屬性length指明它的長(cháng)度，例如：intArray.length指明數組intArray的長(cháng)度。
1．二維數組的定義
type arrayName[ ][ ]；
type [ ][ ]arrayName;
2．二維數組的初始化
◇ 靜態(tài)初始化
int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};
Java語(yǔ)言中，由于把二維數組看作是數組的數組，數組空間不是連續分配的，所以不要求二維數組每一維的大小相同。
◇ 動(dòng)態(tài)初始化
1) 直接為每一維分配空間，格式如下：
arrayName = new type[arrayLength1][arrayLength2];
int a[ ][ ] = new int[2][3]；
2) 從最高維開(kāi)始，分別為每一維分配空間：
arrayName = new type[arrayLength1][ ];
arrayName[0] = new type[arrayLength20];
arrayName[1] = new type[arrayLength21];
…
arrayName[arrayLength1-1] = new type[arrayLength2n];
3) 例：
二維簡(jiǎn)單數據類(lèi)型數組的動(dòng)態(tài)初始化如下,
int a[ ][ ] = new int[2][ ]；
a[0] = new int[3];
a[1] = new int[5];
對二維復合數據類(lèi)型的數組，必須首先為最高維分配引用空間，然后再順次為低維分配空間。
而且，必須為每個(gè)數組元素單獨分配空間。
例如：
String s[ ][ ] = new String[2][ ];
s[0]= new String[2];//為最高維分配引用空間
s[1]= new String[2]; //為最高維分配引用空間
s[0][0]= new String("Good");// 為每個(gè)數組元素單獨分配空間
s[0][1]= new String("Luck");// 為每個(gè)數組元素單獨分配空間
s[1][0]= new String("to");// 為每個(gè)數組元素單獨分配空間
s[1][1]= new String("You");// 為每個(gè)數組元素單獨分配空間
3．二維數組元素的引用
對二維數組中的每個(gè)元素，引用方式為：arrayName[index1][index2]
例如： num[1][0];
4．二維數組舉例：
【例2．2】?jì)蓚€(gè)矩陣相乘
public class MatrixMultiply{
public static void main(String args[]){
int i,j,k;
int a[][]=new int [2][3]; //動(dòng)態(tài)初始化一個(gè)二維數組
int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//靜態(tài)初始化
一個(gè)二維數組
int c[][]=new int[2][4]; //動(dòng)態(tài)初始化一個(gè)二維數組
for (i=0;i<2;i++)
for (j=0; j<3 ;j++)
a[i][j]=(i+1)*(j+2);
for (i=0;i<2;i++){
for (j=0;j<4;j++){
c[i][j]=0;
for(k=0;k<3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("*******Matrix C********");//打印Matrix C標記
for(i=0;i<2;i++){
for (j=0;j<4;j++)
System.out.println(c[i][j]+" ");
System.out.println();
}
}
}
1．字符串常量
字符串常量是用雙引號括住的一串字符。
"Hello World!"
2．String表示字符串常量
用String表示字符串：
String( char chars[ ] );
String( char chars[ ], int startIndex, int numChars );
String( byte ascii[ ], int hiByte );
String( byte ascii[ ], int hiByte, int startIndex, int numChars );
String使用示例：
String s=new String() ; 生成一個(gè)空串
下面用不同方法生成字符串"abc"：
char chars1[]={'a','b','c'};
char chars2[]={'a','b','c','d','e'};
String s1=new String(chars1);
String s2=new String(chars2,0,3);
byte ascii1[]={97,98,99};
byte ascii2[]={97,98,99,100,101};
String s3=new String(ascii1,0);
String s4=new String(ascii2,0,0,3);
3．用StringBuffer表示字符串
StringBuffer( ); /*分配16個(gè)字符的緩沖區*/
StringBuffer( int len ); /*分配len個(gè)字符的緩沖區*/
StringBuffer( String s ); /*除了按照s的大小分配空間外,再分配16個(gè)
字符的緩沖區*/
1．類(lèi)String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。
◇ public int length() 此方法返回字符串的字符個(gè)數
◇ public char charAt(int index) 此方法返回字符串中index位置上的字符，其中index 值的 范圍是0~length-1
◇ public int indexOf(int ch)
public lastIndexOf(in ch)
返回字符ch在字符串中出現的第一個(gè)和最后一個(gè)的位置
◇ public int indexOf(String str)
public int lastIndexOf(String str)
返回子串str中第一個(gè)字符在字符串中出現的第一個(gè)和最后一個(gè)的位置
◇ public int indexOf(int ch,int fromIndex)
public lastIndexOf(in ch ,int fromIndex)
返回字符ch在字符串中位置fromIndex以后出現的第一個(gè)和最后一個(gè)的位置
◇ public int indexOf(String str,int fromIndex)
public int lastIndexOf(String str,int fromIndex)
返回子串str中的第一個(gè)字符在字符串中位置fromIndex后出現的第一個(gè)和最后一個(gè)的位置。
◇ public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
srcbegin 為要提取的第一個(gè)字符在源串中的位置， end為要提取的最后一個(gè)字符在源串中的位置，字符數組buf[]存放目的字符串， dstbegin 為提取的字符串在目的串中的起始位置。
◇public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
參數及用法同上，只是串中的字符均用8位表示。
2．類(lèi)StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。
方法capacity()用來(lái)得到字符串緩沖區的容量，它與方法length()所返回的值通常是不同的。
1．String類(lèi)提供的方法：
concat( )
replace( )
substring( )
toLowerCase( )
toUpperCase( )
◇ public String contat(String str);
用來(lái)將當前字符串對象與給定字符串str連接起來(lái)。
◇ public String replace(char oldChar,char newChar);
用來(lái)把串中出現的所有特定字符替換成指定字符以生成新串。
◇ public String substring(int beginIndex)；
public String substring(int beginIndex,int endIndex);
用來(lái)得到字符串中指定范圍內的子串。
◇ public String toLowerCase();
把串中所有的字符變成小寫(xiě)。
◇ public String toUpperCase();
把串中所有的字符變成大寫(xiě)。
2．StringBuffer類(lèi)提供的方法：
append( )
insert( )
setCharAt( )
如果操作后的字符超出已分配的緩沖區,則系統會(huì )自動(dòng)為它分配額外的空間。
◇ public synchronized StringBuffer append(String str);
用來(lái)在已有字符串末尾添加一個(gè)字符串str。
◇ public synchronized StringBuffer insert(int offset, String str);
用來(lái)在字符串的索引offset位置處插入字符串str。
◇ public synchronized void setCharAt(int index,char ch);
用來(lái)設置指定索引index位置的字符值。
注意：String中對字符串的操作不是對源操作串對象本身進(jìn)行的，而是對新生成的一個(gè)源操作串對象的拷貝進(jìn)行的，其操作的結果不影響源串。
相反，StringBuffer中對字符串的連接操作是對源串本身進(jìn)行的，操作之后源串的值發(fā)生了變化，變成連接后的串。
1．字符串的比較
String中提供的方法：
equals( )和equalsIgnoreCase( )
它們與運算符'= ='實(shí)現的比較是不同的。運算符'= ='比較兩個(gè)對象是否引用同一個(gè)實(shí)例，而equals( )和equalsIgnoreCase( )則比較 兩個(gè)字符串中對應的每個(gè)字符值是否相同。
2．字符串的轉化
java.lang.Object中提供了方法toString( )把對象轉化為字符串。
3．字符串"+"操作
運算符'+'可用來(lái)實(shí)現字符串的連接：
String s = "He is "+age+" years old.";
其他類(lèi)型的數據與字符串進(jìn)行"+"運算時(shí)，將自動(dòng)轉換成字符串。具體過(guò)程如下：
String s=new StringBuffer("he is").append(age).append("years old").toString();
注意：除了對運算符"+"進(jìn)行了重載外，java不支持其它運算符的重載。
1．類(lèi)聲明：
[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]
{……}
其中，修飾符public,abstract,final 說(shuō)明了類(lèi)的屬性，className為類(lèi)名，superclassName為類(lèi)的父類(lèi)的名字，interfaceNameList為類(lèi)所實(shí)現的接口列表。
2．類(lèi)體
類(lèi)體定義如下：
class className
{[public | protected | private ] [static]
[final] [transient] [volatile] type
variableName; //成員變量
[public | protected | private ] [static]
[final | abstract] [native] [synchronized]
returnType methodName([paramList]) [throws exceptionList]
{statements} //成員方法
}
3．成員變量
成員變量的聲明方式如下：
[public | protected | private ] [static]
[final] [transient] [volatile] type
variableName; //成員變量
其中，
static: 靜態(tài)變量（類(lèi)變量）；相對于實(shí)例變量
final: 常量
transient: 暫時(shí)性變量，用于對象存檔
volatile: 貢獻變量，用于并發(fā)線(xiàn)程的共享
4．成員方法
方法的實(shí)現包括兩部分內容：方法聲明和方法體。
[public | protected | private ] [static]
[final | abstract] [native] [synchronized]
returnType methodName([paramList])
[throws exceptionList] //方法聲明
{statements} //方法體
方法聲明中的限定詞的含義：
static: 類(lèi)方法，可通過(guò)類(lèi)名直接調用
abstract: 抽象方法，沒(méi)有方法體
final: 方法不能被重寫(xiě)
native: 集成其它語(yǔ)言的代碼
synchronized: 控制多個(gè)并發(fā)線(xiàn)程的訪(fǎng)問(wèn)
◇ 方法聲明
方法聲明包括方法名、返回類(lèi)型和外部參數。其中參數的類(lèi)型可以是簡(jiǎn)單數據類(lèi)型，也可以是復合數據類(lèi)型（又稱(chēng)引用數據類(lèi)型）。
對于簡(jiǎn)單數據類(lèi)型來(lái)說(shuō)，java實(shí)現的是值傳遞，方法接收參數的值，但不能改變這些參數的值。如果要改變參數的值，則用引用數據類(lèi)型，因為引用數據類(lèi)型傳遞給方法的是數據在內存中的地址，方法中對數據的操作可以改變數據的值。
例3-1說(shuō)明了簡(jiǎn)單數據類(lèi)型與引用數據的區別。
【例3-1】
import java.io.*;
public class PassTest{
float ptValue;
public static void main(String args[]) {
int val;
PassTest pt=new PassTest();
val=11;
System.out.println("Original Int Value is:"+val);
pt.changeInt(val); //值參數
System.out.println("Int Value after Change is:" +val); /*值參數
值的修改，沒(méi)有影響值參數的值*/
pt.ptValue=101f;
System.out.println("Original ptValue is:"+pt.ptValue);
pt.changeObjValue(pt); //引用類(lèi)型的參數
System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用參數值的修改，改變了引用參數的值*/
}
public void changeInt(int value){
value=55; //在方法內部對值參數進(jìn)行了修改
}
public void changeObjValue(PassTest ref){
ref.ptValue=99f; //在方法內部對引用參數進(jìn)行了修改
}
}
查看運行結果◇ 方法體
方法體是對方法的實(shí)現，它包括局部變量的聲明以及所有合法的Java指令。方法體中聲明的局部變量的作用域在該方法內部。若局部變量與類(lèi)的成員變量同名，則類(lèi)的成員變量被隱藏。
例3-2 說(shuō)明了局部變量z和類(lèi)成員變量z的作用域是不同的。
【例3-2】
import java.io.*;
class Variable{
int x=0,y=0,z=0; //類(lèi)的成員變量
void init(int x,int y) {
this.x=x; this.y=y;
int z=5; //局部變量
System.out.println("** in init**");
System.out.println("x="+x+" y="+y+" z="+z);
}
}
public class VariableTest{
public static void main(String args[]){
Variable v=new Variable();
System.out.println("**before init**");
System.out.println("x="+v.x+" y="+ v.y+" z="+v.z);
v.init(20,30);
System.out.println("**after init**");
System.out.println("x="+v.x+ " y="+ v.y+" z="+v.z);
}
}
查看運行結果上例中我們用到了this，這是因為init()方法的參數名與類(lèi)的成員變量x,y的名字相同，而參數名會(huì )隱藏成員變量，所以在方法中，為了區別參數和類(lèi)的成員變量，我們必須使用this。this-----用在一個(gè)方法中引用當前對象，它的值是調用該方法的對象。返回值須與返回類(lèi)型一致，或者完全相同，或是其子類(lèi)。當返回類(lèi)型是接口時(shí)，返回值必須實(shí)現該接口。
5．方法重載
方法重載是指多個(gè)方法享有相同的名字，但是這些方法的參數必須不同，或者是參數的個(gè)數不同，或者是參數類(lèi)型不同。返回類(lèi)型不能用來(lái)區分重載的方法。
參數類(lèi)型的區分度一定要足夠，例如不能是同一簡(jiǎn)單類(lèi)型的參數，如int與long。
【例3-3】
import java.io.*;
class MethodOverloading{
void receive(int i) {
System.out.println("Receive one int data");
System.out.println("i="+i);
}
void receive(int x, int y) {
System.out.println("Receive two int datas");
System.out.println("x="+x+" y="+y);
}
}
public class MethodOverloadingTest{
public static void main(String args[]) {
MethodOverloading mo=new MethodOverloading();
mo.receive(1);
mo.receive(2,3);
}
}
查看運行結果(編譯器會(huì )根據參數的個(gè)數和類(lèi)型來(lái)決定當前所使用的方法)
6． 構造方法
◇ 構造方法是一個(gè)特殊的方法。Java 中的每個(gè)類(lèi)都有構造方法，用來(lái)初始化該類(lèi)的一個(gè)對象。
◇ 構造方法具有和類(lèi)名相同的名稱(chēng)，而且不返回任何數據類(lèi)型。
◇ 重載經(jīng)常用于構造方法。
◇ 構造方法只能由new運算符調用
【例3-4】
class Point{
int x,y;
Point(){
x=0; y=0;
}
Point(int x, int y){
this.x=x;
this.y=y;
}
}
1. 對象的生成
對象的生成包括聲明、實(shí)例化和初始化。
格式為：
type objectName=new type([paramlist]);
◇ 聲明：type objectName
聲明并不為對象分配內存空間，而只是分配一個(gè)引用空間；對象的引用類(lèi)似于指針，是32位的地址空間，它的值指向一個(gè)中間的數據結構，它存儲有關(guān)數據類(lèi)型的信息以及當前對象所在的堆的地址，而對于對象所在的實(shí)際的內存地址是不可操作的，這就保證了安全性。
◇ 實(shí)例化：運算符new為對象分配內存空間，它調用對象的構造方法，返回引用；一個(gè)類(lèi)的不同對象分別占據不同的內存空間。
◇ 生成：執行構造方法，進(jìn)行初始化；根據參數不同調用相應的構造方法。
2. 對象的使用
通過(guò)運算符"."可以實(shí)現對變量的訪(fǎng)問(wèn)和方法的調用。變量和方法可以通過(guò)設定訪(fǎng)問(wèn)權限來(lái)限制其它對象對它的訪(fǎng)問(wèn)。
◇調用對象的變量
格式：objectReference.variable
objectReference是一個(gè)已生成的對象，也可以是能生成對象的表達式
例： p.x= 10;
tx=new Point( ).x;
◇調用對象的方法
格式：objectReference.methodName([paramlist]);
例如：p.move(30,20);
new Point( ).move(30,20);
3. 對象的清除
當不存在對一個(gè)對象的引用時(shí)，該對象成為一個(gè)無(wú)用對象。Java的垃圾收集器自動(dòng)掃描對象的動(dòng)態(tài)內存區，把沒(méi)有引用的對象作為垃圾收集起來(lái)并釋放。
System.gc( );
當系統內存用盡或調用System.gc( )要求垃圾回收時(shí)，垃圾回收線(xiàn)程與系統同步運行。
1． 封裝性
java語(yǔ)言中，對象就是對一組變量和相關(guān)方法的封裝，其中變量表明了對象的狀態(tài)，方法表明了對象具有的行為。通過(guò)對象的封裝，實(shí)現了模塊化和信息隱藏。通過(guò)對類(lèi)的成員施以一定的訪(fǎng)問(wèn)權限，實(shí)現了類(lèi)中成員的信息隱藏。
◇ 類(lèi)體定義的一般格式：
class className
{ [public | protected | private ] [static]
[final] [transient] [volatile] type
variableName; //成員變量
[public | protected | private ] [static]
[final | abstract] [native] [synchronized]
returnType methodName([paramList])
[throws exceptionList]
{statements} //成員方法
}
◇ java類(lèi)中的限定詞
java語(yǔ)言中有四種不同的限定詞，提供了四種不同的訪(fǎng)問(wèn)權限。
1） private
類(lèi)中限定為private的成員，只能被這個(gè)類(lèi)本身訪(fǎng)問(wèn)。
如果一個(gè)類(lèi)的構造方法聲明為private,則其它類(lèi)不能生成該類(lèi)的一個(gè)實(shí)例。
2） default
類(lèi)中不加任何訪(fǎng)問(wèn)權限限定的成員屬于缺省的（default）訪(fǎng)問(wèn)狀態(tài)，可以被這個(gè)類(lèi)本身和同一個(gè)包中的類(lèi)所訪(fǎng)問(wèn)。
3） protected
類(lèi)中限定為protected的成員，可以被這個(gè)類(lèi)本身、它的子類(lèi)（包括同一個(gè)包中以及不同包中的子類(lèi)）和同一個(gè)包中的所有其他的類(lèi)訪(fǎng)問(wèn)。
4） public
類(lèi)中限定為public的成員，可以被所有的類(lèi)訪(fǎng)問(wèn)。
表3-1列出了這些限定詞的作用范圍。
【表3-1】 java中類(lèi)的限定詞的作用范圍比較
同一個(gè)類(lèi)
同一個(gè)包
不同包的子類(lèi)
不同包非子類(lèi)
private
*
default
*
*
protected
*
*
*
public
*
*
*
*
2． 繼承性
通過(guò)繼承實(shí)現代碼復用。Java中所有的類(lèi)都是通過(guò)直接或間接地繼承java.lang.Object類(lèi)得到的。繼承而得到的類(lèi)稱(chēng)為子類(lèi)，被繼承的類(lèi)稱(chēng)為父類(lèi)。子類(lèi)不能繼承父類(lèi)中訪(fǎng)問(wèn)權限為private的成員變量和方法。子類(lèi)可以重寫(xiě)父類(lèi)的方法，及命名與父類(lèi)同名的成員變量。但Java不支持多重繼承，即一個(gè)類(lèi)從多個(gè)超類(lèi)派生的能力。
◇ 創(chuàng )建子類(lèi)
格式：
class SubClass extends SuperClass {
…
}
◇ 成員變量的隱藏和方法的重寫(xiě)
子類(lèi)通過(guò)隱藏父類(lèi)的成員變量和重寫(xiě)父類(lèi)的方法，可以把父類(lèi)的狀態(tài)和行為改變?yōu)樽陨淼臓顟B(tài)和行為。
例如：
class SuperClass{
int x; …
void setX( ){ x=0; } …
}
class SubClass extends SuperClass{
int x; //隱藏了父類(lèi)的變量x
…
void setX( ) { //重寫(xiě)了父類(lèi)的方法 setX()
x=5; } ….
}
注意：子類(lèi)中重寫(xiě)的方法和父類(lèi)中被重寫(xiě)的方法要具有相同的名字，相同的參數表和相同的返回類(lèi)型，只是函數體不同。
◇ super
java中通過(guò)super來(lái)實(shí)現對父類(lèi)成員的訪(fǎng)問(wèn)，super用來(lái)引用當前對象的父類(lèi)。Super 的使用有三種情況：
1）訪(fǎng)問(wèn)父類(lèi)被隱藏的成員變量，如：
super.variable;
2）調用父類(lèi)中被重寫(xiě)的方法，如：
super.Method([paramlist]);
3）調用父類(lèi)的構造函數，如：
super([paramlist]);
【例3-5】
import java.io.*;
class SuperClass{
int x;
SuperClass( ) {
x=3;
System.out.println("in SuperClass : x=" +x);
}
void doSomething( ) {
System.out.println("in SuperClass.doSomething()");
}
}
class SubClass extends SuperClass {
int x;
SubClass( ) {
super( ); //調用父類(lèi)的構造方法
x=5; //super( ) 要放在方法中的第一句
System.out.println("in SubClass :x="+x);
}
void doSomething( ) {
super.doSomething( ); //調用父類(lèi)的方法
System.out.println("in SubClass.doSomething()");
System.out.println("super.x="+super.x+" sub.x="+x);
}
}
public class Inheritance {
public static void main(String args[]) {
SubClass subC=new SubClass();
subC.doSomething();
}
}
查看運行結果3． 多態(tài)性
在java語(yǔ)言中，多態(tài)性體現在兩個(gè)方面：由方法重載實(shí)現的靜態(tài)多態(tài)性（編譯時(shí)多態(tài)）和方法重寫(xiě)實(shí)現的動(dòng)態(tài)多態(tài)性（運行時(shí)多態(tài)）。
1） 編譯時(shí)多態(tài)
在編譯階段，具體調用哪個(gè)被重載的方法，編譯器會(huì )根據參數的不同來(lái)靜態(tài)確定調用相應的方法。
2） 運行時(shí)多態(tài)
由于子類(lèi)繼承了父類(lèi)所有的屬性（私有的除外），所以子類(lèi)對象可以作為父類(lèi)對象使用。程序中凡是使用父類(lèi)對象的地方，都可以用子類(lèi)對象來(lái)代替。一個(gè)對象可以通過(guò)引用子類(lèi)的實(shí)例來(lái)調用子類(lèi)的方法。
◇ 重寫(xiě)方法的調用原則：java運行時(shí)系統根據調用該方法的實(shí)例，來(lái)決定調用哪個(gè)方法。對子類(lèi)的一個(gè)實(shí)例，如果子類(lèi)重寫(xiě)了父類(lèi)的方法，則運行時(shí)系統調用子類(lèi)的方法；如果子類(lèi)繼承了父類(lèi)的方法（未重寫(xiě)），則運行時(shí)系統調用父類(lèi)的方法。
在例3-6中，父類(lèi)對象a引用的是子類(lèi)的實(shí)例，所以，java運行時(shí)調用子類(lèi)B的callme方法。
【例3-6】
import java.io.*;
class A{
void callme( ) {
System.out.println("Inside A's callme()method");
}
}
class B extends A{
void callme( ) {
System.out.println("Inside B's callme() Method");
}
}
public class Dispatch{
public static void main(String args[]) {
A a=new B();
a.callme( );
}
}
查看運行結果◇ 方法重寫(xiě)時(shí)應遵循的原則：
1）改寫(xiě)后的方法不能比被重寫(xiě)的方法有更嚴格的訪(fǎng)問(wèn)權限（可以相同）。
2）改寫(xiě)后的方法不能比重寫(xiě)的方法產(chǎn)生更多的例外。
4． 其它
◇ final 關(guān)鍵字
final 關(guān)鍵字可以修飾類(lèi)、類(lèi)的成員變量和成員方法，但final 的作用不同。
1） final 修飾成員變量：
final修飾變量,則成為常量，例如
final type variableName;
修飾成員變量時(shí)，定義時(shí)同時(shí)給出初始值，而修飾局部變量時(shí)不做要求。
2） final 修飾成員方法：
final修飾方法，則該方法不能被子類(lèi)重寫(xiě)
final returnType methodName(paramList){
…
}
3） final 類(lèi)：
final修飾類(lèi)，則類(lèi)不能被繼承
final class finalClassName{
…
}
◇ 實(shí)例成員和類(lèi)成員
用static 關(guān)鍵字可以聲明類(lèi)變量和類(lèi)方法，其格式如下：
static type classVar;
static returnType classMethod({paramlist}) {
…
}
如果在聲明時(shí)不用static 關(guān)鍵字修飾，則聲明為實(shí)例變量和實(shí)例方法。
1） 實(shí)例變量和類(lèi)變量
每個(gè)對象的實(shí)例變量都分配內存，通過(guò)該對象來(lái)訪(fǎng)問(wèn)這些實(shí)例變量，不同的實(shí)例變量是不同的。
類(lèi)變量?jì)H在生成第一個(gè)對象時(shí)分配內存，所有實(shí)例對象共享同一個(gè)類(lèi)變量，每個(gè)實(shí)例對象對類(lèi)變量的改變都會(huì )影響到其它的實(shí)例對象。類(lèi)變量可通過(guò)類(lèi)名直接訪(fǎng)問(wèn)，無(wú)需先生成一個(gè)實(shí)例對象，也可以通過(guò)實(shí)例對象訪(fǎng)問(wèn)類(lèi)變量。
2） 實(shí)例方法和類(lèi)方法
實(shí)例方法可以對當前對象的實(shí)例變量進(jìn)行操作，也可以對類(lèi)變量進(jìn)行操作，實(shí)例方法由實(shí)例對象調用。
但類(lèi)方法不能訪(fǎng)問(wèn)實(shí)例變量，只能訪(fǎng)問(wèn)類(lèi)變量。類(lèi)方法可以由類(lèi)名直接調用，也可由實(shí)例對象進(jìn)行調用。類(lèi)方法中不能使用this或super關(guān)鍵字。
例3-7 是關(guān)于實(shí)例成員和類(lèi)成員的例子。
【例3-7】
class Member {
static int classVar;
int instanceVar;
static void setClassVar(int i) {
classVar=i;
// instanceVar=i; // 類(lèi)方法不能訪(fǎng)問(wèn)實(shí)例變量
}
static int getClassVar()
{ return classVar; }
void setInstanceVar(int i)
{ classVar=i; //實(shí)例方法不但可以訪(fǎng)問(wèn)類(lèi)變量，也可以實(shí)例變量
instanceVar=i; }
int getInstanceVar( )
{ return instanceVar; }
}
public class MemberTest{
public static void main(String args[]) {
Member m1=new member();
Member m2=new member();
m1.setClassVar(1);
m2.setClassVar(2);
System.out.println("m1.classVar="+m1.getClassVar()+"
m2.ClassVar="+m2.getClassVar());
m1.setInstanceVar(11);
m2.setInstanceVar(22);
System.out.println("m1.InstanceVar="+m1.getInstanceVar
()+" m2.InstanceVar="+m2.getInstanceVar());
}
}
查看運行結果◇ 類(lèi)java.lang.Object
類(lèi)java.lang.Object處于java開(kāi)發(fā)環(huán)境的類(lèi)層次的根部，其它所有的類(lèi)都是直接或間接地繼承了此類(lèi)。該類(lèi)定義了一些最基本的狀態(tài)和行為。下面，我們介紹一些常用的方法。
equals() ：比較兩個(gè)對象(引用)是否相同。
getClass()：返回對象運行時(shí)所對應的類(lèi)的表示，從而可得到相應的信息。
toString()：用來(lái)返回對象的字符串表示。
finalize()：用于在垃圾收集前清除對象。
notify(),notifyAll(),wait()：用于多線(xiàn)程處理中的同步。
1． 抽象類(lèi)
java語(yǔ)言中，用abstract 關(guān)鍵字來(lái)修飾一個(gè)類(lèi)時(shí)，這個(gè)類(lèi)叫做抽象類(lèi)，用abstract 關(guān)鍵字來(lái)修飾一個(gè)方法時(shí)，這個(gè)方法叫做抽象方法。格式如下：
abstract class abstractClass{ …} //抽象類(lèi)
abstract returnType abstractMethod([paramlist]) //抽象方法
抽象類(lèi)必須被繼承，抽象方法必須被重寫(xiě)。抽象方法只需聲明，無(wú)需實(shí)現；抽象類(lèi)不能被實(shí)例化，抽象類(lèi)不一定要包含抽象方法。若類(lèi)中包含了抽象方法，則該類(lèi)必須被定義為抽象類(lèi)。
2． 接口
接口是抽象類(lèi)的一種，只包含常量和方法的定義，而沒(méi)有變量和方法的實(shí)現，且其方法都是抽象方法。它的用處體現在下面幾個(gè)方面：
◇ 通過(guò)接口實(shí)現不相關(guān)類(lèi)的相同行為,而無(wú)需考慮這些類(lèi)之間的關(guān)系。
◇ 通過(guò)接口指明多個(gè)類(lèi)需要實(shí)現的方法。
◇ 通過(guò)接口了解對象的交互界面,而無(wú)需了解對象所對應的類(lèi)。
1）接口的定義
接口的定義包括接口聲明和接口體。
接口聲明的格式如下：
[public] interface interfaceName[extends listOfSuperInterface] { … }
extends 子句與類(lèi)聲明的extends子句基本相同，不同的是一個(gè)接口可有多個(gè)父接口，用逗號隔開(kāi)，而一個(gè)類(lèi)只能有一個(gè)父類(lèi)。
接口體包括常量定義和方法定義
常量定義格式為：type NAME=value; 該常量被實(shí)現該接口的多個(gè)類(lèi)共享; 具有public ,final, static的屬性。
方法體定義格式為：(具有 public和abstract屬性)
returnType methodName([paramlist])；
2）接口的實(shí)現
在類(lèi)的聲明中用implements子句來(lái)表示一個(gè)類(lèi)使用某個(gè)接口，在類(lèi)體中可以使用接口中定義的常量，而且必須實(shí)現接口中定義的所有方法。一個(gè)類(lèi)可以實(shí)現多個(gè)接口,在implements子句中用逗號分開(kāi)。
3） 接口類(lèi)型的使用
接口作為一種引用類(lèi)型來(lái)使用。任何實(shí)現該接口的類(lèi)的實(shí)例都可以存儲在該接口類(lèi)型的變量中，通過(guò)這些變量可以訪(fǎng)問(wèn)類(lèi)所實(shí)現的接口中的方法。
1． 內部類(lèi)的定義和使用：
內部類(lèi)是在一個(gè)類(lèi)的內部嵌套定義的類(lèi)，它可以是其它類(lèi)的成員，也可以在一個(gè)語(yǔ)句塊的內部定義，還可以在表達式內部匿名定義。
內部類(lèi)有如下特性：
◇ 一般用在定義它的類(lèi)或語(yǔ)句塊之內,在外部引用它時(shí)必須給出完整的名稱(chēng).名字不能與包含它的類(lèi)名相同。
◇ 可以使用包含它的類(lèi)的靜態(tài)和實(shí)例成員變量,也可以使用它所在方法的局部變量。
◇ 可以定義為abstract。
◇ 可以聲明為private或protected。
◇ 若被聲明為static,就變成了頂層類(lèi),不能再使用局部變量。
◇ 若想在Inner Class中聲明任何static成員,則該Inner Class必須聲明為static。
例3-8 是一個(gè)說(shuō)明內部類(lèi)如何使用的例子，其中，定義了兩個(gè)內部類(lèi)：MouseMotionHandler和MouseEventHandler，分別用來(lái)處理鼠標移動(dòng)事件和鼠標點(diǎn)按事件。
【例3-8】
import java.awt.*;
import java.awt.event.*;
public class TwoListenInner {
private Frame f;
private TextField tf;
public static void main(String args[]) {
TwoListenInner that=new TwoListenInner();
that.go();
}
public void go() {
f=new Frame("Two listeners example");
f.add("North",new Label("Click and drag the mouse"));
tf=new TextField(30);
f.add("South",tf);
f.addMouseMotionListener(new MouseMotionHandler());
f.addMouseListener(new MouseEventHandler());
f.setSize(300,300);
f.setVisible(true);
}
public class MouseMotionHandler extends MouseMotionAdapter {
public void mouseDragged(MouseEvent e){
String s="Mouse dragging:X="+e.getX()+"Y="+e.getY();
tf.setText(s);
}
}
public class MouseEventHandler extends MouseAdapter {
public void mouseEntered(MouseEvent e){
String s="The mouse entered";
tf.setText(s);
}
public void mouseExited(MouseEvent e){
String s="The mouse left the building";
tf.setText(s);
}
}
}
同學(xué)們可以運行一下這個(gè)程序，看一看它的運行結果。當你將鼠標移入frame時(shí)，文本框中會(huì )出現："The mouse entered"；當你在frame中拖曳鼠標時(shí)，文本框中會(huì )出現："Mouse dragging:X=64 Y=117"；當鼠標離開(kāi)文本框時(shí)，文本框中出現："The mouse left the building"。
2． 匿名類(lèi)的定義和使用：
匿名類(lèi)是一種特殊的內部類(lèi)，它是在一個(gè)表達式內部包含一個(gè)完整的類(lèi)定義。通過(guò)對例6-7中g(shù)o()部分語(yǔ)句的修改，我們可以看到匿名類(lèi)的使用情況。
public void go() {
f=new Frame("Two listeners example");
f.add("North",new Label("Click and drag the mouse"));
tf=new TextField(30);
f.add("South",tf);
f.addMouseMotionListener(new MouseMotionHandler(){
/*定義了一個(gè)匿名類(lèi)，類(lèi)名沒(méi)有顯式地給出，只是該類(lèi)是
MouseMotionHandler類(lèi)的子類(lèi)*/
public void mouseDragged(MouseEvent e){
String s="Mouse dragging:X="+e.getX()+"Y
="+e.getY();
tf.setText(s);
}
});
f.addMouseListener(new MouseEventHandler());
f.setSize(300,300);
f.setVisible(true);
}
3． 內部類(lèi)的優(yōu)缺點(diǎn)：
◇ 優(yōu)點(diǎn):節省編譯后產(chǎn)生的字節碼文件的大小
◇ 缺點(diǎn):使程序結構不清楚
