-> abstract：表示該類是不允許被實例化的類，也就是說該類需要被擴展繼承。被這樣聲明的類也稱為抽象類。  

            顯而易見，final和abstract不能同時使用。  

            -方法修飾符  

            -> 
            abstract：被聲明的方法稱為抽象方法，不含任何代碼，需要其繼承的子類的相應(yīng)方法覆蓋重載。這里需要注意的是被聲明有abstract方法的類必須被聲明為abstract。 
             

            -> final：聲明的方法不允許被覆蓋重載。  

            -> 
            static：聲明的方法被成為類方法，不依賴于任何的對象，不需要實例化對象即可直接使用類名來調(diào)用該方法。注意的是在該方法體內(nèi)不可訪問實例變量。 
             

            -> 變量修飾符  

            -> static：被聲明為static的變量實際可以看作就是全局變量，同樣不需要實例化對象即可直接使用類名來引用之。  

            -> final：被聲明的變量的內(nèi)容不可以被修改，實際可以被看作是一個常量，類似于C或者C++中的const。  

            2.3 缺省構(gòu)造函數(shù)  
            我們都知道當(dāng)對象被實例化的時候，構(gòu)造函數(shù)總是被調(diào)用。如果我們在定義類的時候不指定一個構(gòu)造函數(shù)，Java會自行創(chuàng)建一個不帶參數(shù)的缺省構(gòu)造函數(shù)。而如果我們定義有了一個構(gòu)造函數(shù)，則Java不會再創(chuàng)建缺省構(gòu)造函數(shù)。 
             

            更值得注意的是，如果子類的超類不含有不帶參數(shù)的構(gòu)造函數(shù)，那么子類在使用缺省構(gòu)造函數(shù)就會出錯，Java不會為子類創(chuàng)建不帶參數(shù)的缺省構(gòu)造函數(shù)。因此，我們在使用缺省構(gòu)造函數(shù)的時候要比較小心。我們可以看如下的例子： 
             

            代碼:  
            class Fruit {  

                public Fruit ( String color ) {  

                   System.out.print ( “color = ” + color ) ;  

                }  

            }  

            class Apple extends Fruit {  

                public static void main ( String [ ] args ) {  

                   Apple m = new Apple () ;  

                   }  

            }  

            運行結(jié)果出錯：  

            Fruit.java:6: No constructor matching Fruit ( ) found in class 
             Fruit .  

            Class Apple extends Fruit {  

            1 error  

            2.4 合法的返回類型  
            由于在方法調(diào)用的時候，方法返回的類型有可能與實際聲明的類型不同，因此我們需要關(guān)心什么樣的返回類型才是合法的。實際上，系統(tǒng)采用了隱式的類型轉(zhuǎn)換來處理類型的返回。以下幾種情況的是合法的： 
             

            -> 如果聲明的是浮點類型，那么可返回整型類型。  

            -> 如果聲明的是整型類型，那么只要返回的整型類型范圍小于或等于聲明的類型，返回合法。  

            -> 如果聲明的是對象類型，那么只要返回的是該對象類型，或者是其子類的對象類型，合法。 
            3 運算符  
            同大多數(shù)的編程語言一樣，Java語言也包含了許多的運算符。如果大家學(xué)習(xí)過C或者C++，會發(fā)現(xiàn)下面介紹的各種Java的運算符都與之類似。  

            3.1.1 賦值運算符 =  
            這是任何編程語言的最基本的運算符，它用來給變量指定一個值。對于基本類型來說，賦值都便于理解，將新的值賦給變量并保存在變量中供使用。但對于對象類型來說，這里就有一點區(qū)別，特別需要提醒大家注意。 
             

            對象類型并不是把實際的值（這里是實例）賦給了對象類型的變量，而是賦給的一個參考指針。這樣，源對象類型的變量和新的這個變量實際上是指向的同一個實例，如果使用其中一個讓實例改變，那么相應(yīng)的另一個所指向的實例也會改變。這里我們可以借用C里面的指針的概念來方便理解，但實際上Java是不具有指針的概念和定義的。 
             

            我們通過下面的例子可以進(jìn)一步來理解這個概念。  

            代碼:  
            import java.awt.Dimension;  
            class ReferenceTest {  
              Dimension a = new Dimension ( 5,10 );  
              System.out.println (“a.height = ” + a.height ) ;  
              Dimension b = a ;  
              b.height = 30 ;  
              System.out.println (“a.height = ” + a.height + “after change to b 
            ”);  
            }  
            }  

            運行結(jié)果：  

            c:\java Project\Reference>java ReferenceTest  

            a.height = 10  

            a. height = 30 afer change to b  

            另外，賦值運算符還可以和其他的運算符，聯(lián)合組成新的賦值符。如*=、/=、+=、-=等等，這于C或者C++類似。  

            3.1.2 比較運算符  
            比較運算符是用來對相同數(shù)據(jù)類型的變量進(jìn)行大小或者是否相等、相同的比較，返回的是Boolean類型的值。因此也就大概分為兩類。  

            n >、>=、<、<=  

            這是比較變量的大小關(guān)系，與我們學(xué)過的任何編程語言相同，就不再介紹了。  

            n = = 、! =  

            這是比較變量是否相等或相同。這對于平常的比較基本類型的變量容易理解，只是我們要強調(diào)一下對對象類型的比較。與我們前面介紹的賦值運算符類似的是，它也是進(jìn)行的對其參考指針的比較，而并不是比較兩個內(nèi)容上的差別。我們可以借助下面的例子來理解。 
             

            代碼:  
            import java.awt.Button  
            class CompareRefernce {  
                public static void main ( String [ ] args ) {  
                   Button a = new Button ( “Exit”);  
                   Button b = new Button ( “Exit”);  
                   Button c = a;  
                   System.out.println ( “Is refernce a = = b ? ” + ( a = = b) ) 
            ;  
                   System.out.println ( “Is refernce a = = c ? ” + ( a = = c) ) 
            ;  
            }  
            }  


            運行結(jié)果：  

            Is refernce a = = b ? false  

            Is refernce a = = c ? true  

            3.1.3 instanceof運算符  
            這個是Java語言特殊的一個運算符，它是用來測試其對象是否屬于某類或其超類。但是這里需要提醒大家的是，如果你使用instanceof來比較不是一個繼承關(guān)系樹上的類，Java能夠編譯通過，但運行的時候會報錯。另外，你可以對null對象使用這個運算符，只是無論對于什么類測試的結(jié)果都是false。 
             

            3.1.4 算術(shù)運算符  
            加+、減-、乘*、除/和取模%運算，這與其他的編程語言類似，不再詳述。  

            3.1.5 自增++、自減--運算符  
            Java的自增和自減運算符，與C語言類似，同樣需要注意的是其放置的位置不同，可能的結(jié)果也不同。如果放置在變量的前面，表示先自增（減）再參與下步運算，而如果放置在后面則表示先參與運算再自增（減）。如下的例子說明了自增運算符的使用： 
             

            代碼:  
            class IncDec{  
                public static void main ( String [ ] args ) {  
                   int a = 1;  
                   int b = 1;  
                   int c;  
            int d;  
            c = ++b;  
            d = a++;  
            c++;  
                   System.out.println ( “a = ” + a );  
                   System.out.println ( “b = ” + b );  
                   System.out.println ( “c = ” + c );  
                   System.out.println ( “d = ” + d );  
            }  
            }  


            運行結(jié)果：  

            a = 2  
            b = 2  
            c = 3  
            d = 1  

            3.1.6 字符串連接運算符 +  
            Java語言與C語言類似，也使用+作為連接字符串的運算符，這實際是對String類重載了+運算符。  

            3.1.7 位運算符  
            包括位移運算和位邏輯運算，這也與C語言相似。  

            -> 位移運算  

            >>右移、<<左移、>>>無符號右移。  

            -> 位邏輯運算  

            &與、|或、^異或、~非運算，這于其他的編程語言類似，不再詳述。  

            3.1.8 邏輯運算符  
            與&&、或||，這于其他的編程語言類似，不再詳述。只是需要提醒大家不要把它們和位邏輯運算符混淆，這也是初學(xué)者最容易犯的錯誤。  

            3.1.9 條件運算符 ？：  
            這與C語言完全相同，具體不再解釋。  

            3.1.10 類型轉(zhuǎn)換  
            我們在編寫程序的時候經(jīng)常需要對變量的類型進(jìn)行轉(zhuǎn)換，Java語言與其他的編程語言類似，也提供兩種類型轉(zhuǎn)換方式，即顯式轉(zhuǎn)換和隱式轉(zhuǎn)換。轉(zhuǎn)換的對象可分為兩類，一是基本類型，二是對象類型。 
             

            這里需要掌握這樣一個要點。對于基本類型來說，凡是大轉(zhuǎn)小（以類型的寬度考慮）需要使用顯式轉(zhuǎn)換，也就是需要在變量前面強制給出需要轉(zhuǎn)換成的類型。而對小轉(zhuǎn)大來說，系統(tǒng)會自行進(jìn)行隱式轉(zhuǎn)換。 
             

            對于對象類型來說，也與之類似。凡是超類轉(zhuǎn)子類則需要使用顯式強制轉(zhuǎn)換，而子類轉(zhuǎn)超類系統(tǒng)可自行進(jìn)行隱式轉(zhuǎn)換。另外還需要注意的一點是，對于不在一個繼承關(guān)系樹上的類要進(jìn)行強制轉(zhuǎn)換，Java編譯可通過，但實際運行會出錯。 
             

            3.2 equals()方法  
            equals（）方法實際與= 
            =運算符作用相同，也是用來比較相同類型的兩個變量是否相同或相等。只是有點區(qū)別的是，對于String類來說，它重載equals（）方法，使用它不是比較兩個參考指針的區(qū)別，而是實際對所指向的具體內(nèi)容進(jìn)行比較，這也滿足了平時我們對比較字符串的實際需求。當(dāng)然，對其他類來說，你也可以重載equals（）方法，使其滿足你的實際需要，來比較兩個對象類型的變量。 
             

            3.3 優(yōu)先級  
            與其他編程語言類似的，Java語言的運算符同樣涉及到優(yōu)先級別的問題，書上130頁從高到低給出了所有運算符的優(yōu)先級。建議大家，如果對某些運算符之間的優(yōu)先級不是很清楚的時候，可以使用（）來改變它們的優(yōu)先級關(guān)系。 
             

            3.4 方法的參數(shù)傳遞  
            最后，簡單討論一下方法的傳遞的問題。Java語言的參數(shù)傳遞類型主要可以分為兩種，值傳遞和引用傳遞。借助C語言的概念，我們知道，第一種就是把參數(shù)值直接復(fù)制成方法體的參數(shù)，這樣對方法體中的參數(shù)的改變不會影響到調(diào)用它的參數(shù)。而對于第二種，參數(shù)的引用（或者說是個指針）被傳遞給了方法體的參數(shù)，該引用用來訪問調(diào)用中指定的實際參數(shù)。這樣，對方法體參數(shù)的改變將會影響到調(diào)用方法體的參數(shù)。 
             
            由于沒有指針的概念，Java的參數(shù)傳遞相對比較簡單。對于一般的基本類型來說，都采用的是值傳遞；而對于對象類型則是使用的引用傳遞。