Java：替代全局變量將方法中的值傳遞給另一個

Question

只是出於好奇！如果我有一個方法需要用戶輸入並將其存儲爲一個int變量。有沒有辦法將這些方法傳遞給另一種方法？我知道返回值，但這只是（據我所知）的一個單一的數字，對象等...

當然，簡單的方法來計算結果在這個方法，但是它可能以某種方式通過這些ints：a，b。另一種方法，不使用全局變量？我只是想知道。

private void takeInput(int valueA, int valueB){ 
    println("Enter a number: (a) and (b), to calculate the Phytagoeran Theorem: (c)\n"); 
    int a = readInt("a:"); 
    println("you set the value of a to: "+a +"\n\nNext! set the value of b"); 
    int b = readInt("b:"); 
    println("you set the value of b to:"+b); 
} 

Answer 1

問題不清楚，但我想知道你是否發明了「依賴注入」？

難題的第一部分是，一個方法可以通過將它們包裝在一個對象中來返回多個值。

public class ValuePair { 
    public int a; 
    public int b; 
} 

public ValuePair takeInput(){ 
    ValuePair pair = new ValuePair(); 
    println("Enter a number: (a) and (b)\n"); 
    pair.a = readInt("a:"); 
    pair.b = readInt("b:"); 
    return pair; 
} 

有了這樣你可以做：

ValuePair p = takeInput(); 
System.out.println("Hypotenuse is " + calculateHypotenuse(p.a, p.b) + "\n"; 

（需要注意的是公共領域通常不被認爲是良好的作風 - 我使用他們在這裏，因爲代碼更短在實際代碼中使用getter和setter方法。 ）。

---

這可能是所有你需要的答案。但你問：

有沒有一種方法，我可以將這些方法傳遞給另一種方法？

嗯，是的，你可以，如果你把這種方法包裝在專門的目的類中。由於我希望會變得明顯的原因，我們將首先定義一個接口。

public interface ValuePairSource { 
    public ValuePair getPair(); 
} 

...和一個類實現它：

public class UserInputValuePairSource implements ValuePairSource { 
    @Override 
    public ValuePair getPair() { 
     ValuePair pair = new ValuePair(); 
     println("Enter a number: (a) and (b)\n"); 
     pair.a = readInt("a:"); 
     pair.b = readInt("b:"); 
     return pair; 
    } 
} 

現在，你可以創建一個可以告訴從哪裏得到它的值畢達哥拉斯類。

public class Pythagoras { 
    private ValuePairSource valuePairSource; 

    public Pythagoras(ValuePairSource source) { 
     this.valuePairSource = source; 
    } 

    public double hypotenuse() { 
     ValuePair pair = valuePairSource.getPair(); 
     return Math.sqrt(pair.a^2 + pair.b^2) 
    } 
} 

在構造函數中，我們告訴每個我們創建的Pythagoras對象，如何獲得一對值。所以我們可以這樣使用它：

Pythagoras p = new Pythagoras(new UserInputValuePairSource()); 
double hypotenuse = p.hypotenuse(); 

這是什麼用途？那麼，這意味着我們可以發明其他種類的ValuePairSource。例如，一個ShapeValuePairSource，它從我們設置的Shape對象中獲取值。

（這是假設類問題的目的）

所以，你可能會使用這樣的：

Triangle t = canvas.getLastTriangle(); // or whatever 
ValuePairSource vps = new ShapeValuePairSource(triangle); 
Pythagoras p = new Pythagoras(vps); 
double hypotenuse = p.hypotenuse(); 

因此，沒有在所有的改變畢達哥拉斯類，我們現在把它讀來自形狀對象的值，而不是用戶輸入。

好吧，這是一個有點人爲的例子，但它確實回答了「我可以將這些方法傳遞給另一種方法」的問題 - 這是Spring之類的基礎。

請注意，某些語言允許您直接將方法傳遞給其他方法，而無需像在此處那樣將它們包裝到類中。這被稱爲「函數式編程」，通常這些「方法」被稱爲「函數」。

Answer 2

你可以聲明這樣一種方法：

private void doSomething(int a, int b) { 
    ... 
} 

然後，從你的方法takeInput，你可以把它叫做：

doSomething(a, b); 

Answer 3

您可以創建包含2類值：

public class PairOfInt { 
    private final int a, b; 

    public PairOfInt(int a, int b) { 
     this.a = a; 
     this.b = b; 
    } 

    //getters 
} 


private PairOfInt takeInput(){ 
    println("Enter a number: (a) and (b), to calculate the Phytagoeran Theorem: (c)\n"); 
    int a = readInt("a:"); 
    println("you set the value of a to: "+a +"\n\nNext! set the value of b"); 
    int b = readInt("b:"); 
    println("you set the value of b to:"+b); 
    return new PairOfInt(a, b); 
} 

Answer 4

您應該創建一個包含所有想要操作的成員的類，並以相同的類創建方法，以便不需要通過方法傳遞變量，也不需要依賴全局變量。

class MyOperations { 

    private int valueA; 
    private int valueB; 

    public MyOperations (int valueA, int valueB) { 
     this.valueA = valueA; 
     this.valueB = valueB; 
    } 

    public void doOperationA(){ 
    // 
    } 

    public void doOperationB(){ 
    // 
    } 

} 

Answer 5

避免全局變量通常是一個好主意。

有通過多個返回值的兩種主要方式：在複合對象

把值代入作爲參數

第一傳遞的對象

1. 返回值方式涉及返回一個包含所有想要返回的值的對象。你可以使用一個類是已經上市，如地圖或列表：

   public List readIntegersFromInput() { 
        List l = new ArrayList(); 
        l.add(readInt("a: ")); 
        l.add(readInt("b: ")); 
        return l; 
   } 
   

   ...或者你可以創建一個類尤其是對你的需求：

   public class ValuesAandB { 
       public int a; 
       public int b; 
   } 
   

   ...使用像這樣：

   public ValuesAandB readIntegersFromInput() { 
        ValuesAandB ab = new ValuesAandB; 
        ab.a = readInt("a: "); 
        ab.b = (readInt("b: "); 
        return ab; 
   } 
   

   （在實際代碼，使用getter和setter方法，而不是公共領域）

   第二種方式涉及傳遞一個可變的對象作爲參數。可變對象是一個值可以改變的對象 - 就像我們剛剛創建的ValuesAandB類。

   public void readIntegersFromInput(ValuesAandB ab) { 
       ab.a = readInt("a: "); 
       ab.b = (readInt("b: "); 
   } 
   

   ...你會叫這樣的：

   ValuesAandB values = new ValuesAandB(); 
   readIntegersFromInput(values); 
   // use `values` 
   

   因此，這是最好的？您將在生產代碼中看到兩種樣式。現在普遍認爲，在大多數情況下，第一種風格是可取的。

   讓不變的類實際上是一個好主意，這是一個ValuesAandB，您在其中設置構造函數中的值，然後永遠不允許它們被更改。如果你需要不同的值，那麼你必須創建一個新的對象。你可以看到，用不可變的對象，第二種方式是無法完成的。它導致更清晰的代碼更容易理解。