調用方法在對象上的Java

Question

這裏的骰子類的相關部分：

import java.util.*; 
class Dice 
{ 
    String name ; 
    int x ; 
    int[] sum ; 

...

public Dice (String name) 
    { 
     this.name = name ; 
     this.x = 0 ; 
     this.sum = new int[7] ; 
    } 

...

public void roll() 
    { 
     this.x = randNum(1, this.sum.length) ; 
     this.sum[x] ++ ; 
    } 

我調用此方法在一個單獨的類名爲Risk

class Risk 
{ 

繼承人的方法的第一行：

public static void IdiceRoll (Dice o) 

所以這個方法需要一個已經存在的paramater所以世界上沒有必要創建裏面一個新的骰子骰子。

Finaly這裏是如何我試圖調用roll上o：

o.Dice.roll() ; 

Answer 1

在你的其他類，在一些方法，你需要得到你想要的類的實例使用。如果你在另一個包中，你需要一個導入語句。

然後很簡單：

// Create an instance of class Dice named dice 
Dice dice = new Dice(); 

// call the method on the instance you just created 
dice.roll(); 

同時，請參閱Sun's documentation和嘗試的例子讓你在你的腳下。

修訂，以配合您的更改：

public class Risk 
{ 
    public static void IdiceRoll(Dice o) 
    { 
     o.roll(); 
    } 
} 

Answer 2

Dice dice = new Dice(); 
dice.roll; 

Answer 3

您實例化對象，然後調用方法：

Dice redSparklyPair = new Dice(); 
redSparklyPair.roll(); 

還是我誤解你的問題？

Answer 4

您將獲得對象的實例的引用，然後調用卷（）

Dice dice = new Dice(); 
dice.roll(); 

Answer 5

我不是你的要求很清楚。如果你有Dice類型的對象，你可以做

public class NotDice { 
    // ... 
    public int method() { 
    Dice dice = new Dice(); 
    dice.roll(); 
    // ... 
    } 
    // ... 
} 

如果您在Dice一個子類的時候，那麼你可以調用父類的方法與super關鍵字：

public class WeightedDice extends Dice { 
    // ... 
    public void roll() { 
    // ... 
    super.roll(); 
    // ... 
    } 
    // ... 
} 

super就像this一樣，只是它在類層次結構上看上去一層。據我所知，沒有辦法調用特定的超類的方法;你只能看上一層。儘管如此，這通常就足夠了。

Answer 6

使用最新更新的問題，你只需要說o.roll();

如果不工作，然後仔細檢查了roll()方法是公共和不私人。

Answer 7

您必須創建Dice類的實例，然後調用它。

假設你有一個Game類：

class Risk { 
    public static void IdiceRoll (Dice o) { 
     // You have to roll the dice 
     // The dice already exist, you just... roll it!! 
     o.roll(); 
     // And that's it 
    } 
} 

Dice是類的名稱，類就像一個模板或藍圖。它定義了一些東西（如變量和方法）。

要使用課程，您通常會從中創建對象。在這種情況下，你可以命名任何你想要的對象（在此情況下，它被命名爲o）

所以，當你聲明：

Dice o 

你說。有一個類型爲Dice的名爲o的變量，那麼編譯器知道哪些屬性以及可以從該對象調用哪些方法。

正如你所看到的，調用一個方法，你使用.的對象和方法，其次是它的參數那怎麼實例（非靜態）名稱（如果有的話）

o.roll(); 

上方法工作

靜態（類方法正式）方法在另一方面，在類本身操作，這就是爲什麼他們不需要一個實例。

So, it is possible to invoke them directly: 

Risk.IdiceRoll(aDiceInstance); 

我想你應該花點時間來閱讀：http://java.sun.com/docs/books/tutorial/java/concepts/和理解Java是如何實現這些概念。

Answer 8

從您的評論回覆可以看出，您可能不瞭解static與非靜態方法之間的區別。

要調用靜態方法，請使用類和方法名稱。讓我們稍微修改例如：

public class Dice { 

    private static final Random RANDOM = new Random(); 

    private int sides; 

    protected Dice(int sides) { 
     this.sides = sides; 
    } 

    public static Dice create(int sides) { 
     return new Dice(sides); 
    } 

    public int roll() { 
     synchronized(RANDOM) { 
      return RANDOM.nextInt(sides) + 1; 
     } 
    } 

} 

現在，我可以使用使用static方法調用的形式（類名+方法名）的靜態工廠方法創建一個新的Dice：

Dice d = Dice.create(6); 

但對於您調用它們的常規方法與實例化對象有關，因爲它們可能會使用該對象存儲的數據進行操作。在這種情況下，我創建了一個保存在參考變量d中的對象，並且此對象包含應該爲其生成數字的邊數。要調用它，請使用：

int value = d.roll(); 

使用常規方法比靜態方法有許多優點。不要過度使用static方法。靜態方法不是繼承的，也不是對象的一部分 - 它們只被認爲是類的一部分。這就是爲什麼使用類名稱調用靜態方法的原因（儘管Java不幸地允許使用object.method，但好的IDE會警告你）。沒有相關的內存狀態。然而，一個對象本身也具有內存狀態，並且可能有許多具有不同值的類的不同實例。在這裏，我們可以創建不同面的骰子：

Dice six = Dice.create(6); 
Dice twenty = Dice.create(20); 

// Use the dice for a 1D6 + 1D20 roll. 
int value = six.roll() + twenty.roll(); 

在這個例子中，我叫上兩個不同的對象實例的roll方法。使用Dice.roll()將不起作用，因爲必須針對實例調用滾動方法，以便知道有多少面（在本例中）用於執行滾動。

更多高級主題：該靜態方法是一個工廠，可以根據邊的數量創建具有不同特徵/隨機性的子類。例如，以後我可以創建一個特殊子類骰子叫TrickDice任何時候有人問他們得到其中的一個有5個骰子只需改變create方法：

public static Dice create(int sides) { 
    if (sides == 5) 
     return new TrickDice(5); 
    else 
     return new Dice(sides); 
} 

這並不會改變它被稱爲...

Dice d = Dice.create(5); // This really is a TrickDice 

這是static方法的有效用法之一。再說一次，儘管不要過度使用靜態方法，但應儘量使用正常方法，因爲您正在學習語言。

編輯：我在另一個question您使用此方法簽名注意到：

public static void printDice (Dice Dice) 

在這裏，你必須使用相同的字母大小寫命名類和變量。我在這個問題中解決這個問題，因爲這可能會幫助你解決你在這裏表達的一些困惑。你應該小心你用於類和變量的名字。奇怪的是，Java實際上接受這種語法。第一個Dice是類名（類型），第二個Dice是參數名稱。相反，你應該使用小寫字母的變量/參數名，所以它應該是這樣的：

public static void printDice (Dice dice) 

然後，它會在你使用一個對象引用（dice）是在方法中更清晰或班級名稱（Dice）。

此外，此打印方法可能應該是Dice類中的方法。使用OOP時，您應該考慮讓對象自行打印。這允許不同的子類提供不同的方式來打印自己，而不用試圖將所有的邏輯放在一個單獨的方法中。這是過度使用靜態方法的一個例子，它會降低類的價值和靈活性。