在標題為面向對象的編程概念課程中對面向對象概念的介紹以自行車課為例，以賽車，山地自行車和雙人自行車為子類，下面是可能實現Bicycle類的示例代碼，為你提供類聲明的概述，本課程的后續部分將逐步備份和解釋類聲明，目前，不要關心細節。

public class Bicycle {
        
    // the Bicycle class has
    // three fields
    public int cadence;
    public int gear;
    public int speed;
        
    // the Bicycle class has
    // one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }
        
    // the Bicycle class has
    // four methods
    public void setCadence(int newValue) {
        cadence = newValue;
    }
        
    public void setGear(int newValue) {
        gear = newValue;
    }
        
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
        
    public void speedUp(int increment) {
        speed += increment;
    }
        
}

作為Bicycle的子類的MountainBike類的類聲明可能如下所示：

public class MountainBike extends Bicycle {
        
    // the MountainBike subclass has
    // one field
    public int seatHeight;

    // the MountainBike subclass has
    // one constructor
    public MountainBike(int startHeight, int startCadence,
                        int startSpeed, int startGear) {
        super(startCadence, startSpeed, startGear);
        seatHeight = startHeight;
    }   
        
    // the MountainBike subclass has
    // one method
    public void setHeight(int newValue) {
        seatHeight = newValue;
    }   

}

MountainBike繼承了Bicycle的所有字段和方法，并增加了seatHeight和設置它的方法（山地自行車有座位，可以根據地形要求上下移動）。

你已經看到以下列方式定義的類：

class MyClass {
    // field, constructor, and 
    // method declarations
}

這是一個類聲明，類主體（大括號之間的區域）包含為從類創建的對象的生命周期提供的所有代碼：用于初始化新對象的構造函數，提供類及其對象狀態的字段的聲明，以及實現類及其對象行為的方法。

前面的類聲明是最小的，它僅包含類聲明所需的那些組件，你可以在類聲明的開頭提供有關該類的更多信息，例如其超類的名稱，是否實現任何接口等等，例如：

class MyClass extends MySuperClass implements YourInterface {
    // field, constructor, and
    // method declarations
}

表示MyClass是MySuperClass的子類，它實現了YourInterface接口。

你也可以在最開始添加public或private等修飾符 — 這樣你就可以看到類聲明的開頭行可能變得非常復雜，public和private修飾符決定了其他類可以訪問MyClass的內容，本課程稍后將對此進行討論。關于接口和繼承的課程將解釋如何以及為什么在類聲明中使用extends和implements關鍵字，目前你不需要擔心這些額外的。

通常，類聲明可以按順序包含這些組件：

修飾符，例如public、private以及稍后你將遇到的許多其他修飾符。

類名，首字母大寫。

類的父級（超類）的名稱（如果有）以關鍵字extends開頭，一個類只能extend（子類）一個父類。

由類實現的以逗號分隔的接口列表（如果有），前面是關鍵字implements，一個類可以implement多個接口。

類體，被括號圍繞，{}。

有幾種變量：

類中的成員變量 — 這些變量稱為字段。

方法或代碼塊中的變量 — 這些變量稱為局部變量。

方法聲明中的變量 — 這些變量稱為參數。

Bicycle類使用以下代碼行來定義其字段：

public int cadence;
public int gear;
public int speed;

字段聲明按順序由三個部分組成：

零個或多個修飾符，例如public或private。

該字段的類型。

該字段的名稱。

Bicycle的字段被命名為cadence、gear和speed，并且都是整數數據類型（int），public關鍵字將這些字段標識為公共成員，可由任何可以訪問該類的對象訪問。

使用的第一個（最左側）修飾符允許你控制哪些其他類可以訪問成員字段，目前，只考慮public和private，其他訪問修飾符將在后面討論。

public修飾符 — 可以從所有類訪問該字段。

private修飾符 — 該字段只能在其自己的類中訪問。

本著封裝的精神，將字段設為private是很常見的，這意味著它們只能從Bicycle類直接訪問，但是，我們仍然需要訪問這些值，這可以通過添加為我們獲取字段值的公共方法間接完成：

public class Bicycle {
        
    private int cadence;
    private int gear;
    private int speed;
        
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }
        
    public int getCadence() {
        return cadence;
    }
        
    public void setCadence(int newValue) {
        cadence = newValue;
    }
        
    public int getGear() {
        return gear;
    }
        
    public void setGear(int newValue) {
        gear = newValue;
    }
        
    public int getSpeed() {
        return speed;
    }
        
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
        
    public void speedUp(int increment) {
        speed += increment;
    }
}

所有變量都必須具有類型，你可以使用原始類型，如int、float、boolean等，或者你可以使用引用類型，例如字符串、數組或對象。

所有變量（無論是字段、局部變量還是參數）都遵循“語言基礎”課程“變量命名”中介紹的相同命名規則和約定。

在本課程中，請注意相同的命名規則和約定用于方法和類名稱，除了：

類名的第一個字母應該大寫。

方法名稱中的第一個（或唯一）單詞應該是動詞。

以下是典型方法聲明的示例：

public double calculateAnswer(double wingSpan, int numberOfEngines,
                              double length, double grossTons) {
    //do the calculation here
}

方法聲明中唯一必需的元素是方法的返回類型、名稱、一對圓括號()和大括號之間的主體{}。

更一般地，方法聲明有六個組件，順序如下：

修飾符 — 例如public、private和其他你將在稍后了解的內容。

返回類型 — 方法返回的值的數據類型，如果方法未返回值，則返回void。

方法名稱 — 字段名稱的規則也適用于方法名稱，但約定略有不同。

括號中的參數列表 — 以逗號分隔的輸入參數列表，前面是數據類型，括在括號中()，如果沒有參數，則必須使用空括號。

一個異常列表 — 稍后討論。

括號之間的方法體 — 方法的代碼，包括局部變量的聲明，在這里。

修飾符、返回類型和參數將在本課程的后面部分討論，異常將在后面的課程中討論。

定義：方法聲明的兩個組件包括方法簽名 — 方法的名稱和參數類型。

上面聲明的方法的簽名是：

calculateAnswer(double, int, double, double)

雖然方法名稱可以是任何合法標識符，但代碼約定限制方法名稱，按照慣例，方法名稱應該是小寫的動詞或以小寫的動詞開頭的多單詞名稱，后跟形容詞、名詞等。在多單詞名稱中，第二個和后面每個單詞的第一個字母應該大寫，這里有些例子：

run
runFast
getBackground
getFinalData
compareTo
setX
isEmpty

通常，方法在其類中具有唯一名稱，但是，由于方法重載，方法可能與其他方法具有相同的名稱。

Java編程語言支持重載方法，Java可以區分具有不同方法簽名的方法，這意味著如果類中的方法具有不同的參數列表，則它們可以具有相同的名稱（有一些條件，將在標題為“接口和繼承”的課程中討論）。

假設你有一個類可以使用書法來繪制各種類型的數據（字符串、整數等），并且包含繪制每種數據類型的方法，為每個方法使用新名稱很麻煩 — 例如，drawString、drawInteger、drawFloat等等。在Java編程語言中，你可以對所有繪圖方法使用相同的名稱，但是為每個方法傳遞不同的參數列表，因此，數據繪圖類可能會聲明四個名為draw的方法，每個方法都有一個不同的參數列表。

public class DataArtist {
    ...
    public void draw(String s) {
        ...
    }
    public void draw(int i) {
        ...
    }
    public void draw(double f) {
        ...
    }
    public void draw(int i, double f) {
        ...
    }
}

重載方法由傳遞給方法的參數的數量和類型區分，在代碼示例中，draw(String s)和draw(int i)是不同且唯一的方法，因為它們需要不同的參數類型。

你不能聲明具有相同名稱和相同數量和類型的參數的多個方法，因為編譯器無法區分它們。

在區分方法時編譯器不考慮返回類型，因此即使它們具有不同的返回類型，也不能聲明具有相同簽名的兩個方法。

注意：應謹慎使用重載方法，因為它們會使代碼的可讀性降低。

類包含被調用以從類藍圖創建對象的構造函數，構造函數聲明看起來像方法聲明 — 除了它們使用類的名稱并且沒有返回類型，例如，Bicycle有一個構造函數：

public Bicycle(int startCadence, int startSpeed, int startGear) {
    gear = startGear;
    cadence = startCadence;
    speed = startSpeed;
}

要創建一個名為myBike的新Bicycle對象，new運算符將調用構造函數：

Bicycle myBike = new Bicycle(30, 0, 8);

new Bicycle(30, 0, 8)為對象創建內存空間并初始化其字段。

雖然Bicycle只有一個構造函數，但它可能有其他構造函數，包括一個無參構造函數：

public Bicycle() {
    gear = 1;
    cadence = 10;
    speed = 0;
}

Bicycle yourBike = new Bicycle();調用無參構造函數來創建一個名為yourBike的新Bicycle對象。

兩個構造函數都可以在Bicycle中聲明，因為它們具有不同的參數列表，與方法一樣，Java平臺根據列表中的參數數量及其類型來區分構造函數。你不能為相同類編寫兩個具有相同參數數量和類型的構造函數，因為平臺無法區分它們，這樣做會導致編譯時錯誤。

你不必為你的類提供任何構造函數，但在執行此操作時必須小心，編譯器自動為沒有構造函數的任何類提供無參數的默認構造函數，此默認構造函數將調用超類的無參數構造函數，在這種情況下，如果超類沒有無參數構造函數，編譯器將會報錯，因此你必須驗證它是否有，如果你的類沒有顯式的超類，那么它有一個隱式的超類Object，它有一個無參數的構造函數。

你可以自己使用超類構造函數，本課開頭的MountainBike類就是這樣做的，稍后將在有關接口和繼承的課程中對此進行討論。

你可以在構造函數的聲明中使用訪問修飾符來控制哪些其他類可以調用構造函數。

注意：如果另一個類不能調用MyClass構造函數，則無法直接創建MyClass對象。

方法或構造函數的聲明聲明該方法或構造函數的參數的數量和類型，例如，以下是根據貸款金額、利率、貸款期限（期數）和貸款的未來價值計算住房貸款的每月付款的方法：

public double computePayment(
                  double loanAmt,
                  double rate,
                  double futureValue,
                  int numPeriods) {
    double interest = rate / 100.0;
    double partial1 = Math.pow((1 + interest), 
                    - numPeriods);
    double denominator = (1 - partial1) / interest;
    double answer = (-loanAmt / denominator)
                    - ((futureValue * partial1) / denominator);
    return answer;
}

此方法有四個參數：貸款金額、利率、未來價值和期數，前三個是雙精度浮點數，第四個是整數，參數在方法體中使用，并且在運行時將采用傳入的參數的值。

注意：參數是指方法聲明中的變量列表，參數是調用方法時傳遞的實際值，調用方法時，使用的參數必須與聲明參數的類型和順序匹配。

你可以將任何數據類型用于方法或構造函數的參數，這包括原始數據類型，如在computePayment方法中看到的雙精度數、浮點數和整數，以及引用數據類型，如對象和數組。

這是一個接受數組作為參數的方法示例，在此示例中，該方法創建一個新的Polygon對象，并從Point對象數組中初始化它（假設Point是一個表示x，y坐標的類）：

public Polygon polygonFrom(Point[] corners) {
    // method body goes here
}

注意：如果要將方法傳遞給方法，請使用lambda表達式或方法引用。

你可以使用名為可變參數的構造將任意數量的值傳遞給方法，當你不知道將多少特定類型的參數傳遞給該方法時，你可以使用可變參數，這是手動創建數組的快捷方式（前一種方法可以使用可變參數而不是數組）。

要使用可變參數，你通過省略號跟隨最后一個參數的類型（三個點，...），然后是空格和參數名稱，然后可以使用任何數量的參數調用該方法，包括無參數。

public Polygon polygonFrom(Point... corners) {
    int numberOfSides = corners.length;
    double squareOfSide1, lengthOfSide1;
    squareOfSide1 = (corners[1].x - corners[0].x)
                     * (corners[1].x - corners[0].x) 
                     + (corners[1].y - corners[0].y)
                     * (corners[1].y - corners[0].y);
    lengthOfSide1 = Math.sqrt(squareOfSide1);

    // more method body code follows that creates and returns a 
    // polygon connecting the Points
}

你可以看到，在方法內部，corners被視為數組，可以使用數組或參數序列調用該方法，在任何一種情況下，方法體中的代碼都會將參數視為數組。

你最常見的是使用打印方法的可變參數，例如，這個printf方法：

public PrintStream printf(String format, Object... args)

允許你打印任意數量的對象，它可以像這樣調用：

System.out.printf("%s: %d, %s%n", name, idnum, address);

或者像這樣：

System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email);

或者還有不同數量的參數。

向方法或構造函數聲明參數時，為該參數提供名稱，此名稱在方法體內用于引用傳入的參數。

參數的名稱在其范圍內必須是唯一的，它不能與同一方法或構造函數的另一個參數的名稱相同，也不能是方法或構造函數中的局部變量的名稱。

參數可以與類的某個字段具有相同的名稱，如果是這種情況，則稱該參數遮蔽該字段，遮蔽字段可能使你的代碼難以閱讀，并且通常僅在設置特定字段的構造函數和方法中使用，例如，考慮以下Circle類及其setOrigin方法：

public class Circle {
    private int x, y, radius;
    public void setOrigin(int x, int y) {
        ...
    }
}

Circle類有三個字段：x，y和radius，setOrigin方法有兩個參數，每個參數與其中一個字段具有相同的名稱，每個方法參數都會影響共享其名稱的字段，因此，在方法體內使用簡單名稱x或y是指參數，而不是字段。要訪問該字段，你必須使用限定名稱，這將在本課程后面的“使用this關鍵字”一節中討論。

原始參數（如int或double）按值傳遞給方法，這意味著對參數值的任何更改都僅存在于方法的范圍內，方法返回時，參數消失，對它們的任何更改都將丟失，這是一個例子：

public class PassPrimitiveByValue {

    public static void main(String[] args) {
           
        int x = 3;
           
        // invoke passMethod() with 
        // x as argument
        passMethod(x);
           
        // print x to see if its 
        // value has changed
        System.out.println("After invoking passMethod, x = " + x);
           
    }
        
    // change parameter in passMethod()
    public static void passMethod(int p) {
        p = 10;
    }
}

運行此程序時，輸出為：

After invoking passMethod, x = 3

引用數據類型參數（如對象）也按值傳遞給方法，這意味著當方法返回時，傳入的引用仍然引用與以前相同的對象，但是，如果對象的字段的值具有適當的訪問級別，則可以在該方法中更改它們的值。

例如，考慮任意類中移動Circle對象的方法：

public void moveCircle(Circle circle, int deltaX, int deltaY) {
    // code to move origin of circle to x+deltaX, y+deltaY
    circle.setX(circle.getX() + deltaX);
    circle.setY(circle.getY() + deltaY);
        
    // code to assign a new reference to circle
    circle = new Circle(0, 0);
}

使用這些參數調用該方法：

moveCircle(myCircle, 23, 56)

在方法內部，circle最初引用的是myCircle，該方法將circle引用的對象（即myCircle）的x和y坐標分別改變23和56，方法返回時，這些更改將保持不變。然后circle被賦予新的Circle對象的引用，其中x = y = 0，但是，這種重新分配沒有永久性，因為引用是按值傳遞的，不能更改，在該方法中，circle指向的對象已更改，但是，當方法返回時，myCircle仍然引用與調用方法之前相同的Circle對象。