/*************************************************

function:java language Technology
author  :chinayaosir   QQ:44633197 
blog    :http://blog.csdn.net/chinayaosir
note    :禁止其它網站轉載此文章

**************************************************/
/**------------------------------------------------------------------------------*/
1.download j2sdk from Sun Microsystems, Inc. website
we install  j2sdk into c:/j2sdk1.4
/**------------------------------------------------------------------------------*/
2.j2sdk setup option with windows 2000/xp
classpath= .;C:/j2sdk1.4/lib;
lib=C:/j2sdk1.4/lib;
path=C:/j2sdk1.4/bin;

/**------------------------------------------------------------------------------*/
目錄
　　2.1 簡單資料型別
　　　2．1．1 識別符號和保留字
　　　2．1．2 資料型別概述
　　　2．1．3 簡單資料型別
　　　2．1．4 簡單資料型別中各型別資料間的優先關係和相互轉換

　　2.2 運算子和表示式
　　　2．2．1 運算子
　　　2．2．2 表示式

　　2.3 控制語句
　　　2．3．1 分支語句
　　　2．3．2 迴圈語句
　　　2．3．3 跳轉語句
　　　2．3．4 例外處理語句

　　2.4 陣列
　　　2．4．1 一維陣列
　　　2．4．2 多維陣列

　　2.5 字串的處理
　　　2．5．1 字串的表示
　　　2．5．2 訪問字串
　　　2．5．3 修改字串
　　　2．5．4 其它操作

　　3．1 面向物件技術基礎
　　　 3．1．1 面向物件的基本概念
　　　 3．1．2 面向物件的基本特徵
　　　 3．1．3 面向物件的程式設計方法

　　3．2 Java語言的面向物件特性
　　　 3．2．1 類
　　　 3．2．2 物件
　　　 3．2．3面向物件特性
　　　 3．2．4抽象類和介面
　　　 3．2．5內部類

/**------------------------------------------------------------------------------*/
2．1簡單資料型別
2．1．1 識別符號和保留字
1．識別符號
　　程式設計師對程式中的各個元素加以命名時使用的命名記號稱為識別符號（identifier）。
Java語言中，識別符號是以字母，下劃線（_）,美元符($)開始的一個字元序列，
後面可以跟字母，下劃線，美元符，數字。
例如，identifier，userName，User_Name，_sys_val， $change為合法的識別符號，
而2mail room#，class 為非法的識別符號。

　2．保留字
　　具有專門的意義和用途，不能當作一般的識別符號使用，這些識別符號稱為保留字(reserved word),也稱為關鍵字，
下面列出了java語言中的所有保留字：

bstract，break，byte，boolean，catch，case，class，char，continue，default，double，
do，else，extends，false，final，float，for，finally，if，import，implements，int，
interface，instanceof，long，length，native，new，null，package，
private，protected，public，return，switch，synchronized，short，static，
super，try，true，this，throw，throws，threadsafe，transient，void，while 。
java語言中的保留字均用小寫字母表示。
/**------------------------------------------------------------------------------*/
2．1．2 資料型別概述
1． java中的資料型別劃分
　　java語言的資料型別有簡單型別和複合型別：
　　簡單資料型別包括：
　　　　　整數型別（Integer）：byte， short， int， long
　　　　　浮點型別（Floating）：float，double
　　　　　字元型別（Textual）：char
　　　　　布林型別（Logical）：boolean

　　複合資料型別包括：
　　　　　class
　　　　　interface
　　　　　陣列

　2．常量和變數
　　常量：用保留字final來實現
　　　　　final typeSpecifier varName=value[,varName[=value]…];
　　　　　如：final int NUM=100;

　　變數：是java 程式中的基本儲存單元，它的定義包括變數名、變數型別和作用域幾個部分。其定義格式如下：
　　　　　typeSpecifier varName[=value[,varName[=value]…];
    　如：int count; char c='a';

　　變數的作用域指明可訪問該變數的一段程式碼，宣告一個變數的同時也就指明瞭變數的作用域。
按作用域來分，變數可以有下面幾種：區域性變數、類變數、方法引數和例外處理引數。
在一個確定的域中，變數名應該是唯一的。
區域性變數在方法或方法的一個塊程式碼中宣告，它的作用域為它所在的程式碼塊（整個方法或方法中的某塊程式碼）。
類變數在類中宣告，而不是在類的某個方法中宣告，它的作用域是整個類。方法引數傳遞給方法，它的作用域就是這個方法。
例外處理引數傳遞給例外處理程式碼，它的作用域就是例外處理部分。
/**------------------------------------------------------------------------------*/
2．1．3 簡單資料型別
1．布林型別--boolean
　　布林型資料只有兩個值true和false，且它們不對應於任何整數值。
    布林型變數的定義如：　　boolean b=true;

2．字元型別--char
　　字元常量：　　字元常量是用單引號括起來的一個字元，如'a'，'A';
　　字元型變數：　型別為char，它在機器中佔16位，其範圍為0～65535。
    字元型變數的定義如：char c='a'; /*指定變數c為char型，且賦初值為'a'*/

3．整型資料
　　整型常量：
　　◇ 十進位制整數
　　　 如123，－456，0
　　◇ 八進位制整數
　　　 以0開頭，如0123表示十進位制數83，－011表示十進位制數－9。
　　◇ 十六進位制整數
　　　 以0x或0X開頭，如0x123表示十進位制數291，－0X12表示十進位制數－18。

整型變數：


資料型別 所佔位數 數的範圍
byte 8 -27～27-1
bhort 16 -215～215-1
int 32 -231～231-1
long 64 -263～263-1


4．浮點型（實型）資料

實型常量：
　　<>十進位制數形式
　　　 由數字和小數點組成，且必須有小數點，如0.123, 1.23, 123.0
　　<>科學計數法形式
　　　 如：123e3或123E3，其中e或E之前必須有數字，且e或E後面的指數必須為整數。
　  <>float型的值,必須在數字後加f或F,如1.23f。

實型變數：

資料型別 所佔位數 數的範圍
float  32 3.4e-038 ～3.4e+038
double 64 1.7e-038 ～1.7e+038

5．簡單資料型別的例子：

【例2．1】
　　public class Assign {
　　　public static void main (String args [ ] ) {
　　　int x , y ; //定義x，y兩個整型變數
　　　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
　　　}
　　}

/**------------------------------------------------------------------------------*/
2．1．4 簡單資料型別中各型別資料間的優先關係和相互轉換
1．不同型別資料間的優先關係如下：

　　　低------------------------------------------->高
　　　byte,short,char-> int -> long -> float -> double

2．自動型別轉換規則

整型,實型,字元型資料可以混合運算。
運算中，不同型別的資料先轉化為同一型別，然後進行運算，轉換從低階到高階；

運算元1型別                 運算元2型別 轉換後的型別 
byte、short、char              int 　　　 int 
byte、short、char、int 　　　        long 　　　long
byte、short、char、int、long 　　　    float 　　 float
byte、short、char、int、long、float 　　double 　　double
　　
3．強制型別轉換
高階資料要轉換成低階資料，需用到強制型別轉換，如：
　　int i;
　　byte b=(byte)i; /*把int型變數i強制轉換為byte型*/
/**------------------------------------------------------------------------------*/
2．2 運算子和表示式

對各種型別的資料進行加工的過程成為運算，表示各種不同運算的符號稱為運算子，
參與運算的資料稱為運算元，按運算元的數目來分，可有：
　　◇ 一元運算子：＋＋，－－，＋，－
　　◇ 二元運算子：＋，－，>
　　◇ 三元運算子：？：

　　基本的運算子按功能劃分，有下面幾類：

1　算術運算子： +，―，*，/，%，++，――。
　　 例如：
　　　　3+2;
　　　　a-b;
　　　　i++;
　　　　--i;

2　關係運算符： >，<，>=，<=，==，!=。
　　　例如：
　　　 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　其它：
　　包括分量運算子· ，下標運算子 []，例項運算子instanceof，
    記憶體分配運算子new，強制型別轉換運算子 (型別)，方法呼叫運算子 () 等。例如：
　　System.out.println("hello world");
　　int array1[]=new int[4];
/**------------------------------------------------------------------------------*/
2．2．2 表示式

表示式是由運算元和運算子按一定的語法形式組成的符號序列。
一個常量或一個變數名字是最簡單的表示式，其值即該常量或變數的值；
表示式的值還可以用作其他運算的運算元，形成更復雜的表示式。

1．表示式的型別

表示式的型別由運算以及參與運算的運算元的型別決定，可以是簡單型別，也可以是複合型別：
布林型表示式： x&&y||z;
整型表示式： num1+num2;

2．運算子的優先次序

表示式的運算按照運算子的優先順序從高到低進行,同級運算子從左到右進行：

優先次序 運算子
1 . [] () 
2 ++ -- ! ~ instanceof
3 new (type)
4 * / % 
5 + - 
6 >> >>> <<
7 > < >= <= 
8 = = != 
9 &
10 ^
11 | 
12 &&
13 ||
14 ?:
15 = += -= *= /= %= ^=
16 &= |= <<= >>= >>>= 

例如，下述條件語句分四步完成：
Result=sum==0?1:num/sum;
第1步：result=sum==0?1:(num/sum)
第2步：result=(sum==0)?1:(num/sum)
第3步：result=((sum==0)?1:(num/sum))
第4步：result=

/**------------------------------------------------------------------------------*/
2．3控制語句
　Java程式通過控制語句來執行程式流，完成一定的任務。
程式流是由若干個語句組成的，語句可以是單一的一條語句，如c=a+b,也可以是用大括號{}括起來的一個複合語句。
Java中的控制語句有以下幾類：
　　◇ 分支語句：if-else, switch
　　◇ 迴圈語句：while, do-while, for
　　◇ 與程式轉移有關的跳轉語句：break, continue, return
　　◇ 例外處理語句：try-catch-finally, throw
　　◇ 註釋語句：//，/* */， /** */

2．3．1 分支語句(if-else和switch)
分支語句提供了一種控制機制，使得程式的執行可以跳過某些語句不執行，而轉去執行特定的語句。
　　1．條件語句 if-else

　　　if(boolean-expression)
　　　　statement1;
　　　[else statement2;]

　　2．多分支語句 switch

　　　switch (expression){
　　　　case value1 : statement1;
　　　break;
　　　　case value2 : statement2;
　　　break;
　　　…………
　　　　case valueN : statemendN;
　　　break;
　　　　[default : defaultStatement; ]
　　　}

　　◇ 表示式expression的返回值型別必須是這幾種型別之一：int,byte,char,short。
　　◇ case子句中的值valueN必須是常量，而且所有case子句中的值應是不同的。
　　◇ default子句是可選的。
　　◇break語句用來在執行完一個case分支後，使程式跳出switch語句，
即終止switch語句的執行（在一些特殊情況下，多個不同的case值要執行一組相同的操作，這時可以不用break）。

/**------------------------------------------------------------------------------*/
2．3．2 迴圈語句(while/do-while/for)
　　迴圈語句的作用是反覆執行一段程式碼，直到滿足終止迴圈的條件為止。Java語言中提供的迴圈語句有：
　　　◇ while語句
　　　◇ do-while語句
　　　◇ for語句
1．while語句

　　[initialization]
　　while (termination){
　　　　body;
　　[iteration;]
　　}

　2．do-while語句

　　[initialization]
　　do {
　　　　body;
　　[iteration;]
　　} while (termination);

　3．for語句

　　for (initialization; termination; iteration){
　　　　body;
　　}
　　◇ for語句執行時，首先執行初始化操作，然後判斷終止條件是否滿足，如果滿足，則執行迴圈體中的語句，最後執行迭代部分。
       完成一次迴圈後，重新判斷終止條件。
　　◇ 初始化、終止以及迭代部分都可以為空語句(但分號不能省)，三者均為空的時候，相當於一個無限迴圈。
　　◇ 在初始化部分和迭代部分可以使用逗號語句，來進行多個操作。逗號語句是用逗號分隔的語句序列。
　　　for( i=0, j=10; i<j; i++, j--){
　　　　……
　　　}

/**------------------------------------------------------------------------------*/
2．3．3 跳轉語句(break/continue/return)

　　◇ break語句
　　◇ continue語句
　　◇ 返回語句return
1．break語句

　　◇ 在switch語中，break語句用來終止switch語句的執行。使程式從switch語句後的第一個語句開始執行。
　　◇ 在Java中，可以為每個程式碼塊加一個括號，一個程式碼塊通常是用大括號{}括起來的一段程式碼。加標號的格式如下：
　　BlockLabel: { codeBlock }
　　break語句的第二種使用情況就是跳出它所指定的塊，並從緊跟該塊的第一條語句處執行。例如：
　　break BlockLabel；
　　break語句
　　a:{…… //標記程式碼塊a
　　b:{…… //標記程式碼塊b
　　c:{…… //標記程式碼塊c
　　break b;
　　　…… //此處的語句塊不被執行
　　}
　　　…… /此處的語句塊不被執行
　　}
　　　…… //從此處開始執行
　　}

　2．continue語句

　　continue語句用來結束本次迴圈，跳過迴圈體中下面尚未執行的語句，接著進行終止條件的判斷，以決定是否繼續迴圈。
對於for語句，在進行終止條件的判斷前，還要先執行迭代語句。它的格式為：
　　　continue；

　　也可以用continue跳轉到括號指明的外層迴圈中，這時的格式為
　　　continue outerLable;

　　例如：
　　　outer: for( int i=0; i<10; i++ ){ //外層迴圈
　　　inner: for( int j=0; j<10; j++ ){ //內層迴圈
　　　if( i<j ){
　　　　　……
　　　continue outer;


　　　}
　　　　　……
　　　}
　　　　　……
　　　}

　3．返回語句return　　　
　　return語句從當前方法中退出，返回到呼叫該方法的語句處，並從緊跟該語句的下一條語句繼續程式的執行。
    返回語句有兩種格式：
　　return expression ;
　　return;

　　return語句通常用在一個方法體的最後,否則會產生編譯錯誤,除非用在if-else語句中

/**------------------------------------------------------------------------------*/
2．3．4 例外處理語句

　　包括try,catch,finally,throw語句; 與c/c++相比,是Java特有的語句。
/**------------------------------------------------------------------------------*/
2．4 陣列
　　java語言中，陣列是一種最簡單的複合資料型別。陣列是有序資料的集合，
陣列中的每個元素具有相同的資料型別，可以用一個統一的陣列名和下標來唯一地確定陣列中的元素。
陣列有一維陣列和多維陣列。
1． 一維陣列的定義

　　type arrayName[ ]；
　　型別(type)可以為Java中任意的資料型別，包括簡單型別和複合型別。
　　例如：
　　　int intArray[ ]；
　　　Date dateArray[];


　2．一維陣列的初始化

　　◇ 靜態初始化
　　　　int intArray[]={1,2,3,4};
　　　　String stringArray[]={"abc", "How", "you"};

　　◇ 動態初始化
　　　 1）簡單型別的陣列
　　　　int intArray[];
　　　　intArray = new int[5];

　　　2）複合型別的陣列
　　　　String stringArray[ ];
　　　　String stringArray = new String[3];/*為陣列中每個元素開闢引用
　　　　　　　　　　　　　　　　　　　　　 空間(32位) */
　　　　stringArray[0]= new String("How");//為第一個陣列元素開闢空間
　　　　stringArray[1]= new String("are");//為第二個陣列元素開闢空間
　　　　stringArray[2]= new String("you");// 為第三個陣列元素開闢空間

　3．一維陣列元素的引用

　　陣列元素的引用方式為：
　　　　　arrayName[index]

　　index為陣列下標，它可以為整型常數或表示式，下標從0開始。每個陣列都有一個屬性length指明它的長度，
例如：intArray.length指明陣列intArray的長度。

/**------------------------------------------------------------------------------*/
2．4．2 多維陣列
　　Java語言中，多維陣列被看作陣列的陣列。
1．二維陣列的定義

　　type arrayName[ ][ ]；
　　type [ ][ ]arrayName;

　2．二維陣列的初始化

　　◇ 靜態初始化
　　int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};

　　Java語言中，由於把二維陣列看作是陣列的陣列，陣列空間不是連續分配的，所以不要求二維陣列每一維的大小相同。

　　◇ 動態初始化
　　1) 直接為每一維分配空間，格式如下：
　　arrayName = new type[arrayLength1][arrayLength2];
　　int a[ ][ ] = new int[2][3]；

　　2) 從最高維開始，分別為每一維分配空間：
　　arrayName = new type[arrayLength1][ ];
　　arrayName[0] = new type[arrayLength20];
　　arrayName[1] = new type[arrayLength21];
　　…
　　arrayName[arrayLength1-1] = new type[arrayLength2n];

　　3) 例：
　　二維簡單資料型別陣列的動態初始化如下,
　　int a[ ][ ] = new int[2][ ]；
　　a[0] = new int[3];
　　a[1] = new int[5];

　　對二維複合資料型別的陣列，必須首先為最高維分配引用空間，然後再順次為低維分配空間。
　　而且，必須為每個陣列元素單獨分配空間。

　　例如：
　　String s[ ][ ] = new String[2][ ];
　　s[0]= new String[2];//為最高維分配引用空間
　　s[1]= new String[2]; //為最高維分配引用空間
　　s[0][0]= new String("Good");// 為每個陣列元素單獨分配空間
　　s[0][1]= new String("Luck");// 為每個陣列元素單獨分配空間
　　s[1][0]= new String("to");// 為每個陣列元素單獨分配空間
　　s[1][1]= new String("You");// 為每個陣列元素單獨分配空間

　3．二維陣列元素的引用
　　
　　對二維陣列中的每個元素，引用方式為：arrayName[index1][index2]
　　例如： num[1][0];

　4．二維陣列舉例：

【例2．2】兩個矩陣相乘
　　public class MatrixMultiply{
　　　public static void main(String args[]){
　　　int i,j,k;
　　　int a[][]=new int [2][3]; //動態初始化一個二維陣列
　　　int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//靜態初始化
　　　　　　　　　　　　　　　　　　　　　　　　　　 一個二維陣列
　　　int c[][]=new int[2][4]; //動態初始化一個二維陣列
　　　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();
　　　　　　}
　　　　　}
　　　}

/**------------------------------------------------------------------------------*/
2．5 字串的處理
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() ; 生成一個空串

　　下面用不同方法生成字串"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個字元的緩衝區*/
　　StringBuffer( int len ); /*分配len個字元的緩衝區*/
　　StringBuffer( String s ); /*除了按照s的大小分配空間外,再分配16個字元的緩衝區*/

/**------------------------------------------------------------------------------*/
2．5．2 訪問字串
1．類String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。
　　◇ public int length() 此方法返回字串的字元個數
　　◇ public char charAt(int index) 此方法返回字串中index位置上的字元，其中index 值的 範圍是0~length-1
　　◇ public int indexOf(int ch)
　　 　public lastIndexOf(in ch)
　　
　　返回字元ch在字串中出現的第一個和最後一個的位置
　　◇ public int indexOf(String str)
　　　 public int lastIndexOf(String str)
　　返回子串str中第一個字元在字串中出現的第一個和最後一個的位置
　　◇ public int indexOf(int ch,int fromIndex)
　　　 public lastIndexOf(in ch ,int fromIndex)
　　返回字元ch在字串中位置fromIndex以後出現的第一個和最後一個的位置
　　◇ public int indexOf(String str,int fromIndex)
　　　 public int lastIndexOf(String str,int fromIndex)
　　返回子串str中的第一個字元在字串中位置fromIndex後出現的第一個和最後一個的位置。
　　◇ public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
　　 srcbegin 為要提取的第一個字元在源串中的位置， end為要提取的最後一個字元在源串中的位置，字元陣列buf[]存放目的字串，　　　 dstbegin 為提取的字串在目的串中的起始位置。
　　◇public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
　　引數及用法同上，只是串中的字元均用8位表示。

2．類StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。

　　方法capacity()用來得到字串緩衝區的容量，它與方法length()所返回的值通常是不同的。

/**------------------------------------------------------------------------------*/

2．5．3 修改字串

　　修改字串的目的是為了得到新的字串，類String和類StringBuffer都提供了相應的方法。
有關各個方法的使用，參考java 2 API。
/**------------------------------------------------------------------------------*/
1．String類提供的方法：
　　　concat( )
　　　replace( )
　　　substring( )
　　　toLowerCase( )
　　　toUpperCase( )

　　◇ public String contat(String str);
　　用來將當前字串物件與給定字串str連線起來。
　　◇ public String replace(char oldChar,char newChar);
　　用來把串中出現的所有特定字元替換成指定字元以生成新串。
　　◇ public String substring(int beginIndex)；
　　public String substring(int beginIndex,int endIndex);
　　用來得到字串中指定範圍內的子串。
　　◇ public String toLowerCase();
　　把串中所有的字元變成小寫。
　　◇ public String toUpperCase();
　　把串中所有的字元變成大寫。

　2．StringBuffer類提供的方法：
　　append( )
　　insert( )
　　setCharAt( )

　　如果操作後的字元超出已分配的緩衝區,則系統會自動為它分配額外的空間。
　　◇ public synchronized StringBuffer append(String str);
　　用來在已有字串末尾新增一個字串str。
　　◇ public synchronized StringBuffer insert(int offset, String str);
　　用來在字串的索引offset位置處插入字串str。
　　◇ public synchronized void setCharAt(int index,char ch);
　　用來設定指定索引index位置的字元值。

　　注意：String中對字串的操作不是對源操作串物件本身進行的，
    而是對新生成的一個源操作串物件的拷貝進行的，其操作的結果不影響源串。
　　相反，StringBuffer中對字串的連線操作是對源串本身進行的，操作之後源串的值發生了變化，變成連線後的串。

/**------------------------------------------------------------------------------*/
2．5．4 字串其它操作
1．字串的比較

　　String中提供的方法：
　　equals( )和equalsIgnoreCase( )
　　它們與運算子'= ='實現的比較是不同的。運算子'= ='比較兩個物件是否引用同一個例項，
而equals( )和equalsIgnoreCase( )則比較　　兩個字串中對應的每個字元值是否相同。

　2．字串的轉化

　　java.lang.Object中提供了方法toString( )把物件轉化為字串。

　3．字串"+"操作

　　運算子'+'可用來實現字串的連線：
　　String s = "He is "+age+" years old.";
　　其他型別的資料與字串進行"+"運算時，將自動轉換成字串。具體過程如下：
　　String s=new StringBuffer("he is").append(age).append("years old").toString();

　　注意：除了對運算子"+"進行了過載外，java不支援其它運算子的過載。

/**------------------------------------------------------------------------------*/
3．1 面向物件技術基礎
3．1．1 面向物件的基本概念
　　面向物件的基本思想
　　面向物件是一種新興的程式設計方法,或者是一種新的程式設計規範(paradigm),
其基本思想是使用物件、類、繼承、封裝、訊息等基本概念來進行程式設計。
從現實世界中客觀存在的事物（即物件）出發來構造軟體系統，並且在系統構造中儘可能運用人類的自然思維方式。
開發一個軟體是為了解決某些問題，這些問題所涉及的業務範圍稱作該軟體的問題域。
其應用領域不僅僅是軟體，還有計算機體系結構和人工智慧等。

1． 物件的基本概念
　　物件是系統中用來描述客觀事物的一個實體，它是構成系統的一個基本單位。
一個物件由一組屬性和對這組屬性進行操作的一組服務組成。
從更抽象的角度來說，物件是問題域或實現域中某些事物的一個抽象，
它反映該事物在系統中需要儲存的資訊和發揮的作用；
它是一組屬性和有權對這些屬性進行操作的一組服務的封裝體。
客觀世界是由物件和物件之間的聯絡組成的。
主動物件是一組屬性和一組服務的封裝體，其中至少有一個服務不需要接收訊息就能主動執行（稱作主動服務）。
　　
2． 類的基本概念
　　把眾多的事物歸納、劃分成一些類是人類在認識客觀世界時經常採用的思維方法。
分類的原則是抽象。類是具有相同屬性和服務的一組物件的集合，它為屬於該類的所有物件提供了統一的抽象描述，
其內部包括屬性和服務兩個主要部分。在面向物件的程式語言中，類是一個獨立的程式單位，
它應該有一個類名幷包括屬性說明和服務說明兩個主要部分。
類與物件的關係就如模具和鑄件的關係，類的例項化結果就是物件，而對一類物件的抽象就是類。
　　
3． 訊息

　　訊息就是向物件發出的服務請求，它應該包含下述資訊：
提供服務的物件標識、服務標識、輸入資訊和回答資訊。服務通常被稱為方法或函式。

/**------------------------------------------------------------------------------*/
3．1．2 面向物件的基本特徵
1．封裝性

　　封裝性就是把物件的屬性和服務結合成一個獨立的相同單位，並儘可能隱蔽物件的內部細節，包含兩個含義：
　　◇ 把物件的全部屬性和全部服務結合在一起，形成一個不可分割的獨立單位（即物件）。
　　◇ 資訊隱蔽，即儘可能隱蔽物件的內部細節，對外形成一個邊界〔或者說形成一道屏障〕，
只保留有限的對外介面使之與外部發生聯絡。
　　封裝的原則在軟體上的反映是：要求使物件以外的部分不能隨意存取物件的內部資料（屬性），
從而有效的避免了外部錯誤對它的"交叉感染"，使軟體錯誤能夠區域性化，大大減少查錯和排錯的難度。
　　
　2．繼承性

　　特殊類的物件擁有其一般類的全部屬性與服務，稱作特殊類對一般類的繼承。
例如，輪船、客輪；人、大人。一個類可以是多個一般類的特殊類，它從多個一般類中繼承了屬性與服務，
這稱為多繼承。例如，客輪是輪船和客運工具的特殊類。在java語言中，
通常我們稱一般類為父類（superclass,超類），特殊類為子類(subclass)。

　3．多型性

　　物件的多型性是指在一般類中定義的屬性或服務被特殊類繼承之後，
可以具有不同的資料型別或表現出不同的行為。
這使得同一個屬性或服務在一般類及其各個特殊類中具有不同的語義。
例如："幾何圖形"的"繪圖"方法，"橢圓"和"多邊形"都是"幾何圖"的子類，其"繪圖"方法功能不同。

/**------------------------------------------------------------------------------*/
3．1．3 面向物件程式設計方法
OOA－Object Oriented Analysis 　　　　面向物件的分析
OOD－Object Oriented Design 　　　　　面向物件的設計　
OOI－Object Oriented Implementation 　面向物件的實現
/**------------------------------------------------------------------------------*/
3．2 Java語言的面向物件特性
3．2．1 類
　　類是java中的一種重要的複合資料型別，是組成java程式的基本要素。
它封裝了一類物件的狀態和方法，是這一類物件的原形。一個類的實現包括兩個部分：類宣告和類體。
1．類宣告：

　　[public][abstract|final] class className
                [extends superclassName] [implements interfaceNameList]
　　{……}

　　其中，修飾符public,abstract,final 說明了類的屬性，className為類名，
     superclassName為類的父類的名字，interfaceNameList為類所實現的介面列表。

2．類體

　　類體定義如下：
　　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: 靜態變數（類變數）；相對於例項變數
　　final: 常量
　　transient: 暫時性變數，用於物件存檔
　　volatile: 貢獻變數，用於併發執行緒的共享

4．成員方法

　　方法的實現包括兩部分內容：方法宣告和方法體。
　　[public | protected | private ] [static]
　　[final　| abstract] [native] [synchronized]
　　returnType methodName([paramList])
　　[throws exceptionList] 　　　　　　　　　　　//方法宣告
　　　{statements} 　　　　　　　　　　　　　　　//方法體

　　方法宣告中的限定詞的含義：
　　static: 類方法，可通過類名直接呼叫
　　abstract: 抽象方法，沒有方法體
　　final: 方法不能被重寫
　　native: 整合其它語言的程式碼
　　synchronized: 控制多個併發執行緒的訪問

　　◇ 方法宣告
　　方法宣告包括方法名、返回型別和外部引數。
其中引數的型別可以是簡單資料型別，也可以是複合資料型別（又稱引用資料型別）。

　　對於簡單資料型別來說，java實現的是值傳遞，方法接收引數的值，但不能改變這些引數的值。
如果要改變引數的值，則用引用資料型別，因為引用資料型別傳遞給方法的是資料在記憶體中的地址，
方法中對資料的操作可以改變資料的值。
例3-1說明了簡單資料型別與引用資料的區別。

【例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); /*值引數
　　　　　　　　　　　　　　　　　　　 值的修改，沒有影響值引數的值*/
　　pt.ptValue=101f;
　　System.out.println("Original ptValue is:"+pt.ptValue);
　　pt.changeObjValue(pt); //引用型別的引數
　　System.out.println("ptValue after Change is:"+pt.ptValue);
    /* 引用引數值的修改，改變了引用引數的值*/
　　}
　　public void changeInt(int value){
　　value=55; 　　　　　　　　　　　//在方法內部對值引數進行了修改
　　}
　　public void changeObjValue(PassTest ref){
　　ref.ptValue=99f; 　　　　　　 //在方法內部對引用引數進行了修改
　　　　}
　　}

　　檢視執行結果

　　◇ 方法體
　　方法體是對方法的實現，它包括區域性變數的宣告以及所有合法的Java指令。
方法體中宣告的區域性變數的作用域在該方法內部。若區域性變數與類的成員變數同名，則類的成員變數被隱藏。

　　例3-2 說明了區域性變數z和類成員變數z的作用域是不同的。

【例3-2】
　　import java.io.*;
　　class Variable{
　　int x=0,y=0,z=0; 　　　　 　　　　　　 　//類的成員變數
　　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()方法的引數名與類的成員變數x,y的名字相同，
而引數名會隱藏成員變數，所以在方法中，為了區別引數和類的成員變數，我們必須使用this。
this-----用在一個方法中引用當前物件，它的值是呼叫該方法的物件。
返回值須與返回型別一致，或者完全相同，或是其子類。當返回型別是介面時，返回值必須實現該介面。

5．方法過載
　
　　方法過載是指多個方法享有相同的名字，但是這些方法的引數必須不同，或者是引數的個數不同，
或者是引數型別不同。返回型別不能用來區分過載的方法。

　　引數型別的區分度一定要足夠，例如不能是同一簡單型別的引數，如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);

　　　　}　
　　}

　　檢視執行結果(編譯器會根據引數的個數和型別來決定當前所使用的方法)

6． 構造方法

　　◇ 構造方法是一個特殊的方法。Java 中的每個類都有構造方法，用來初始化該類的一個物件。
　　◇ 構造方法具有和類名相同的名稱，而且不返回任何資料型別。
　　◇ 過載經常用於構造方法。
　　◇ 構造方法只能由new運算子呼叫

【例3-4】
　　class Point{
　　int x,y;
　　Point(){
　　x=0; y=0;
　　}
　　Point(int x, int y){
　　this.x=x;
　　this.y=y;
　　　　}
　　}


/**------------------------------------------------------------------------------*/
3．2．2 物件
　　類例項化可生成物件，物件通過訊息傳遞來進行互動。
訊息傳遞即啟用指定的某個物件的方法以改變其狀態或讓它產生一定的行為。
一個物件的生命週期包括三個階段：生成、使用和消除。
1. 物件的生成

　　物件的生成包括宣告、例項化和初始化。
　　格式為：
　　type objectName=new type([paramlist]);

　　◇ 宣告：type objectName
　　宣告並不為物件分配記憶體空間，而只是分配一個引用空間；
物件的引用類似於指標，是32位的地址空間，它的值指向一箇中間的資料結構，
它儲存有關資料型別的資訊以及當前物件所在的堆的地址，
而對於物件所在的實際的記憶體地址是不可操作的，這就保證了安全性。
　　◇ 例項化：運算子new為物件分配記憶體空間，它呼叫物件的構造方法，返回引用；
一個類的不同物件分別佔據不同的記憶體空間。

　　◇ 生成：執行構造方法，進行初始化；根據引數不同調用相應的構造方法。

2. 物件的使用

　　通過運算子"."可以實現對變數的訪問和方法的呼叫。
變數和方法可以通過設定訪問許可權來限制其它物件對它的訪問。

　　◇呼叫物件的變數
　　格式：objectReference.variable
　　objectReference是一個已生成的物件，也可以是能生成物件的表示式
　　例：　p.x= 10;
　　　　　tx=new Point( ).x;

　　◇呼叫物件的方法
　　格式：objectReference.methodName([paramlist]);
　　例如：p.move(30,20);
　　　　　new Point( ).move(30,20);

3. 物件的清除

　　當不存在對一個物件的引用時，該物件成為一個無用物件。
    Java的垃圾收集器自動掃描物件的動態記憶體區，把沒有引用的物件作為垃圾收集起來並釋放。
　　System.gc( );　　
　　當系統記憶體用盡或呼叫System.gc( )要求垃圾回收時，垃圾回收執行緒與系統同步執行。


/**------------------------------------------------------------------------------*/
3．2．3 面向物件特性
　　java語言中有三個典型的面向物件的特性：封裝性、繼承性和多型性，下面將詳細闡述。

1． 封裝性
　　java語言中，物件就是對一組變數和相關方法的封裝，其中變量表明瞭物件的狀態，
方法表明了物件具有的行為。通過物件的封裝，實現了模組化和資訊隱藏。
通過對類的成員施以一定的訪問許可權，實現了類中成員的資訊隱藏。

　　◇ 類體定義的一般格式：
　　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類中的限定詞
　　java語言中有四種不同的限定詞，提供了四種不同的訪問許可權。

　　1） private
　　類中限定為private的成員，只能被這個類本身訪問。
　　如果一個類的構造方法宣告為private,則其它類不能生成該類的一個例項。

　　2） default
　　類中不加任何訪問許可權限定的成員屬於預設的（default）訪問狀態，可以被這個類本身和同一個包中的類所訪問。

　　3） protected
　　類中限定為protected的成員，可以被這個類本身、
    它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問。

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

表3-1列出了這些限定詞的作用範圍。

【表3-1】　java中類的限定詞的作用範圍比較

 同一個類 同一個包  不同包的子類  不同包非子類
private *   
default  * *  
protected * * * 
public * * * *

2． 繼承性
　　通過繼承實現程式碼複用。Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的。
繼承而得到的類稱為子類，被繼承的類稱為父類。子類不能繼承父類中訪問許可權為private的成員變數和方法。
子類可以重寫父類的方法，及命名與父類同名的成員變數。
但Java不支援多重繼承，即一個類從多個超類派生的能力。

　　◇ 建立子類
　　格式：
　　class SubClass extends SuperClass {
　　…
　　}

　　◇ 成員變數的隱藏和方法的重寫
　　子類通過隱藏父類的成員變數和重寫父類的方法，可以把父類的狀態和行為改變為自身的狀態和行為。

　　例如：
　　class SuperClass{
　　　　int x; …
　　　　void setX( ){ x=0; } …
　　}
　　class SubClass extends SuperClass{
　　　　int x; 　　//隱藏了父類的變數x
　　　　…
　　　　void setX( ) { //重寫了父類的方法 setX()
　　　　x=5; } ….
　　}

　　注意：子類中重寫的方法和父類中被重寫的方法要具有相同的名字，
相同的引數表和相同的返回型別，只是函式體不同。

　　◇ super
　　java中通過super來實現對父類成員的訪問，super用來引用當前物件的父類。Super 的使用有三種情況：

　　1）訪問父類被隱藏的成員變數，如：
　　　　super.variable;

　　2）呼叫父類中被重寫的方法，如：
　　　　super.Method([paramlist]);

　　3）呼叫父類的建構函式，如：
　　　　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( ); 　　　//呼叫父類的構造方法
　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句
　　　　　System.out.println("in SubClass :x="+x);
　　　　}
　　　　　void doSomething( ) {
　　　　　super.doSomething( ); //呼叫父類的方法
　　　　　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． 多型性

　　在java語言中，多型性體現在兩個方面：由方法過載實現的靜態多型性（編譯時多型）
和方法重寫實現的動態多型性（執行時多型）。

　　1） 編譯時多型
　　在編譯階段，具體呼叫哪個被過載的方法，編譯器會根據引數的不同來靜態確定呼叫相應的方法。

　　2） 執行時多型
　　由於子類繼承了父類所有的屬性（私有的除外），所以子類物件可以作為父類物件使用。
程式中凡是使用父類物件的地方，都可以用子類物件來代替。一個物件可以通過引用子類的例項來呼叫子類的方法。

　　◇ 重寫方法的呼叫原則：java執行時系統根據呼叫該方法的例項，來決定呼叫哪個方法。
對子類的一個例項，如果子類重寫了父類的方法，則執行時系統呼叫子類的方法；
如果子類繼承了父類的方法（未重寫），則執行時系統呼叫父類的方法。
　　在例3-6中，父類物件a引用的是子類的例項，所以，java執行時呼叫子類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( );
　　　　　}
　　}
　　　　檢視執行結果
　　◇ 方法重寫時應遵循的原則：
　　1）改寫後的方法不能比被重寫的方法有更嚴格的訪問許可權（可以相同）。
　　2）改寫後的方法不能比重寫的方法產生更多的例外。

　4． 其它
　　◇ final 關鍵字
　　final 關鍵字可以修飾類、類的成員變數和成員方法，但final 的作用不同。
　　
　　1） final 修飾成員變數：
　　final修飾變數,則成為常量，例如
　　final type variableName;
　　修飾成員變數時，定義時同時給出初始值，而修飾區域性變數時不做要求。

　　2） final 修飾成員方法：
　　final修飾方法，則該方法不能被子類重寫
　　final returnType methodName(paramList){
　　…
　　}

　　3） final 類：
　　final修飾類，則類不能被繼承
　　final class finalClassName{
　　…
　　}

　　◇ 例項成員和類成員
　　用static 關鍵字可以宣告類變數和類方法，其格式如下：
　　static type classVar;
　　static returnType classMethod({paramlist}) {
　　…
　　}
　
　　如果在宣告時不用static 關鍵字修飾，則宣告為例項變數和例項方法。
　　1） 例項變數和類變數
　　每個物件的例項變數都分配記憶體，通過該物件來訪問這些例項變數，不同的例項變數是不同的。
　　類變數僅在生成第一個物件時分配記憶體，所有例項物件共享同一個類變數，
每個例項物件對類變數的改變都會影響到其它的例項物件。
類變數可通過類名直接訪問，無需先生成一個例項物件，也可以通過例項物件訪問類變數。

　　2） 例項方法和類方法
　　例項方法可以對當前物件的例項變數進行操作，也可以對類變數進行操作，例項方法由例項物件呼叫。
　　但類方法不能訪問例項變數，只能訪問類變數。
類方法可以由類名直接呼叫，也可由例項物件進行呼叫。
類方法中不能使用this或super關鍵字。

　　例3-7 是關於例項成員和類成員的例子。

【例3-7】
　　class Member {
　　　　static int classVar;
　　　　int instanceVar;
　　　　static void setClassVar(int i) {
　　　　　classVar=i;
　　　　　// instanceVar=i; // 類方法不能訪問例項變數
　　　　}
　　　　static int getClassVar()
　　　　　{ return classVar; }
　　　　void setInstanceVar(int i)
　　　　　{ classVar=i; //例項方法不但可以訪問類變數，也可以例項變數
　　　　　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());
　　　　　}
　　　　}

　　　　檢視執行結果

　　◇ 類java.lang.Object
　　類java.lang.Object處於java開發環境的類層次的根部，其它所有的類都是直接或間接地繼承了此類。
該類定義了一些最基本的狀態和行為。下面，我們介紹一些常用的方法。

　　equals() ：比較兩個物件(引用)是否相同。
　　getClass()：返回物件執行時所對應的類的表示，從而可得到相應的資訊。
　　toString()：用來返回物件的字串表示。
　　finalize()：用於在垃圾收集前清除物件。
　　notify(),notifyAll(),wait()：用於多執行緒處理中的同步。

/**------------------------------------------------------------------------------*/
3．2．4抽象類和介面
1． 抽象類

　　java語言中，用abstract 關鍵字來修飾一個類時，這個類叫做抽象類，
用abstract 關鍵字來修飾一個方法時，這個方法叫做抽象方法。
格式如下：
　　abstract class abstractClass{ …} //抽象類
　　abstract returnType abstractMethod([paramlist]) //抽象方法

　　抽象類必須被繼承，抽象方法必須被重寫。抽象方法只需宣告，無需實現；
抽象類不能被例項化，抽象類不一定要包含抽象方法。若類中包含了抽象方法，則該類必須被定義為抽象類。

　2． 介面

　　介面是抽象類的一種，只包含常量和方法的定義，而沒有變數和方法的實現，且其方法都是抽象方法。
它的用處體現在下面幾個方面：
　　◇ 通過介面實現不相關類的相同行為,而無需考慮這些類之間的關係。
　　◇ 通過介面指明多個類需要實現的方法。
　　◇ 通過介面瞭解物件的互動介面,而無需瞭解物件所對應的類。

　　1）介面的定義
　　介面的定義包括介面宣告和介面體。
　　介面宣告的格式如下：
　　[public] interface interfaceName[extends listOfSuperInterface] { … }
　　 extends 子句與類宣告的extends子句基本相同，不同的是一個介面可有多個父介面，
用逗號隔開，而一個類只能有一個父類。

　　介面體包括常量定義和方法定義
　　常量定義格式為：type NAME=value;
    該常量被實現該介面的多個類共享; 具有public ,final, static的屬性。
　　方法體定義格式為：(具有 public和abstract屬性)
　　returnType methodName([paramlist])；

　　2）介面的實現
　　在類的宣告中用implements子句來表示一個類使用某個介面，在類體中可以使用介面中定義的常量，
而且必須實現介面中定義的所有方法。一個類可以實現多個介面,在implements子句中用逗號分開。

　　3） 介面型別的使用
　　介面作為一種引用型別來使用。任何實現該介面的類的例項都可以儲存在該介面型別的變數中，
通過這些變數可以訪問類所實現的介面中的方法。

/**------------------------------------------------------------------------------*/
3．2．5 內部類

1． 內部類的定義和使用：
　　內部類是在一個類的內部巢狀定義的類，它可以是其它類的成員，
也可以在一個語句塊的內部定義，還可以在表示式內部匿名定義。
　　內部類有如下特性：

　　◇ 一般用在定義它的類或語句塊之內,在外部引用它時必須給出完整的名稱.
名字不能與包含它的類名相同。
　　◇ 可以使用包含它的類的靜態和例項成員變數,也可以使用它所在方法的區域性變數。
　　◇ 可以定義為abstract。
　　◇ 可以宣告為private或protected。
　　◇ 若被宣告為static,就變成了頂層類,不能再使用區域性變數。
　　◇ 若想在Inner Class中宣告任何static成員,則該Inner Class必須宣告為static。

　　例3-8 是一個說明內部類如何使用的例子，其中，
定義了兩個內部類：MouseMotionHandler和MouseEventHandler，分別用來處理滑鼠移動事件和滑鼠點按事件。

【例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);
    }
}
}

　　同學們可以執行一下這個程式，看一看它的執行結果。
當你將滑鼠移入frame時，文字框中會出現："The mouse entered"；
當你在frame中拖曳滑鼠時，文字框中會出現："Mouse dragging:X=64 Y=117"；
當滑鼠離開文字框時，文字框中出現："The mouse left the building"。

2． 匿名類的定義和使用：

　　匿名類是一種特殊的內部類，它是在一個表示式內部包含一個完整的類定義。
通過對例6-7中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(){
　　　　　　　　　/*定義了一個匿名類，類名沒有顯式地給出，只是該類是
　　　　　　　　　　MouseMotionHandler類的子類*/
　　　　　　　　　　　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． 內部類的優缺點：

　　◇ 優點:節省編譯後產生的位元組碼檔案的大小
　　◇ 缺點:使程式結構不清楚
/**------------------------------------------------------------------------------*/