Javaのグローバル変数

Javaでグローバル変数をどのように定義しますか？

グローバル変数を定義するには、静的キーワードを使用できます

public class Example {
    public static int a;
    public static int b;
}

これで、どこからでもaとbにアクセスできます。

Example.a;

Example.b;

あなたはしません。これは仕様によるものです。できてもそれをするべきではありません。

そうは言っても、Globalsという名前のクラスに一連のパブリック静的メンバーを作成することができます。

public class Globals {
   public static int globalInt = 0;
   ///
}

しかし、あなたは本当にすべきではない:)。真剣に..それをしないでください。

別の方法は、次のようなインターフェースを作成することです。

public interface GlobalConstants
{
  String name = "Chilly Billy";
  String address = "10 Chicken head Lane";
}

それらを使用する必要があるクラスは、インターフェースを実装するだけです：

public class GlobalImpl implements GlobalConstants
{
  public GlobalImpl()
  {
     System.out.println(name);
  }
}

依存性注入を使用するほうがよいです。

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

public class UsesGlobals {
    private final Globals globals;
    public UsesGlobals(Globals globals) {
        this.globals = globals;
    }
}

良い答えはたくさんありますが、別のクラスがクラスの変数にアクセスするためのより適切な方法である、ゲッターとセッターを使用するため、この例を挙げたいと思います。

変数を単にpublicにするのではなく、このようにゲッターとセッターを使用する理由は次のとおりです。あなたの変数が、あなたがプログラムの実行中に誰かに絶対に変更してほしくない（チームでコードを開発している場合）、おそらくウェブサイトのURLのようなグローバルパラメータになるとしましょう。理論的には、これは変更される可能性があり、プログラムで何度も使用される可能性があるため、グローバル変数を使用して一度に更新できるようにする必要があります。しかし、誰かがこの変数を変更することを望まないでしょう（おそらくそれがどれほど重要であるかを理解していない）。その場合は、setterメソッドを含めず、getterメソッドのみを含めます。

public class Global{
    private static int var = 5;

    public static int getVar(){
        return Global.var;
    }

    //If you do not want to change the var ever then do not include this
    public static void setVar(int var){
        Global.var = var;
    }
}

Javaにはグローバル変数はありません

それにもかかわらず、私たちが持っているのはstaticキーワードであり、それが私たちに必要なすべてです。Javaのクラス外には何も存在しません。staticキーワードは、インスタンス変数に反して、唯一のコピーとその値は任意の時点で、すべてのインスタンスに変更してアクセスすることができることを意味する作成そのクラスのすべてのインスタンス、横切ってその超越を有し、そのクラス変数を表します。

スコープを超えてアクセスできるグローバル変数が必要な場合、これは必要な変数ですが、そのスコープはクラスがある場所にのみ存在し、それですべてになります。

真に言えば、Java OOプログラムには「グローバル」の概念はありません。

それでも、プログラムの任意の部分でメソッドを実行したい場合があるため、質問の背後にいくつかの真実があります。たとえば、Phrase-O-Maticアプリのrandom（）メソッドです。これは、プログラムのどこからでも呼び出すことができるメソッドです。

したがって、上記の「グローバルのような変数とメソッドが必要です」のようなものを満たすために

変数をグローバルとして宣言します。

 1.Mark the variable as public static final While declaring.

メソッドをグローバルとして宣言する。

 1. Mark the method as public static While declaring.

グローバル変数とメソッドを静的として宣言したので、次のコードの助けを借りて、好きな場所で呼び出すことができます

ClassName.X

注：Xは、要件に従ってメソッド名または変数名のいずれかであり、ClassNameは、それらを宣言したクラスの名前です。

定数を除いて、何もグローバルであってはなりません。

public class MyMainClass {
    public final static boolean DEBUGMODE=true;
}

これをメインクラス内に配置します。他の.javaファイルでは、次のように使用します。

if(MyMainClass.DEBUGMODE) System.out.println("Some debugging info");

コードをカッティングルームの床から移動してリリースするときに、この機能を削除またはコメントアウトしてください。

ランダマイザーのような強力な方法がある場合は、「ツールボックス」パッケージを作成することをお勧めします。すべてのコーダーに1つ必要です。それを.javaで使用したいときはいつでもインポートしてください。

Javaには、真のグローバル変数などはありません。すべての静的変数は、何らかのクラス（System.outなど）に属している必要がありますが、どのクラスに入るかを決定したら、同じクラスローダーによってロードされたどこからでも参照できます。

競合状態を回避するために、更新時には静的変数を常に保護する必要があることに注意してください。

public class GlobalClass {
     public static int x = 37;
     public static String s = "aaa";
}

このようにしてGlobalClass.x、およびでそれらにアクセスできますGlobalClass.s

public class GlobalImpl {   

 public static int global = 5;

}

あなたはどこにでも電話をかけることができます：

GlobalImpl.global // 5

おそらく回答から推測できるように、Javaにはグローバル変数はなく、実行できる唯一のことは、静的メンバーを持つクラスを作成することです。

public class Global {
    public static int a;
}

Global.a他の場所でも使用できます。ただし、Java 1.5以上を使用している場合は、import staticマジックを使用して、実際のグローバル変数としてさらに見栄えをよくすることができます。

import static test.Global.*;

public class UseGlobal {
    public void foo() {
        int i = a;
    }
}

そして、ほら！

これはベストプラクティスとはほど遠いので、コマーシャルでわかるように、これを自宅で行わないでください。

Javaにはグローバル変数はありませんが、パブリックフィールドを持つグローバルクラスがあります。Java 5の静的インポート機能を使用して、ほとんどグローバル変数のように見せることができます。

一般的にグローバル変数（私はあなたがC、Cppと比較していると思います）は次のように定義します public static final

お気に入り

class GlobalConstant{
    public static final String CODE  = "cd";
}

ENUMは、このようなシナリオでも役立ちます。

例 Calendar.JANUARY）

独立したファイルを作成します。最初のソリューションを使用するExample.javaは問題ありません。たとえば、グローバル変数が現在のアプリに特別である場合などは、アプリ内でも行うことができます。

最初にクラスを作成し、そこで変数を宣言します。

class Globals {
  static int month_number;
  static String month_name;
}

その後、これらの変数に「Globals.month_number」などとして使用して、アプリのどこからでもアクセスできます。

グローバルプロパティを更新する必要がある場合は、単純なゲッター/セッターラッパークラスをグローバル変数として使用できます。以下に代表的な例を示します。

public class GlobalHolder {

    private static final GlobalHolder INSTANCE = new GlobalHolder();

    private volatile int globalProperty;

    public static GlobalHolder getInstance() {
        return INSTANCE;
    }

    public int getGlobalProperty() {
        return globalProperty;
    }

    public void setGlobalProperty(int globalProperty) {
        this.globalProperty = globalProperty;
    }

    public static void main(String[] args) {
        GlobalHolder.getInstance().setGlobalProperty(10);
        System.out.println(GlobalHolder.getInstance().getGlobalProperty());
    }
}

概念的に言うと、インスタンス変数とも呼ばれるグローバル変数は、クラスレベルの変数です。つまり、クラスの内部で定義されていますが、メソッドの外部では定義されていません。それらを完全に使用可能にし、それらを直接使用するには、staticキーワードを提供します。したがって、単純な算術演算用のプログラムを作成していて、数値のペアが必要な場合は、2つのインスタンス変数がそのように定義されます。

public class Add {
    static int a;
    static int b; 
    static int c;

    public static void main(String arg[]) {
        c=sum();
        System.out.println("Sum is: "+c); 
    }

    static int sum() {
       a=20;
       b=30;
       return a+b;   
    }
}

Output: Sum is: 50

さらに、インスタンス変数の前にstaticキーワードを使用すると、同じ変数のデータ型を何度も指定する必要がなくなります。変数を直接書き込むだけです。

一般に、Javaにはグローバル変数がありません。ローカル変数以外のすべての変数は、プログラムで定義されているクラスのスコープに含まれます。静的変数を使用して、グローバル変数のスコープを設定できます。

staticこれなしでも可能です：

class Main {
  String globalVar = "Global Value";

  class Class1 {
    Class1() {
      System.out.println("Class1: "+globalVar);
      globalVar += " - changed";
  } }
  class Class2 {
    Class2() {
      System.out.println("Class2: "+globalVar);
  } }

  public static void main(String[] args) {  
    Main m = new Main();
    m.mainCode();
  }
  void mainCode() {
    Class1 o1 = new Class1();
    Class2 o2 = new Class2();
  }
}

/*
Output:
Class1: Global Value
Class2: Global Value - changed
*/

オブジェクト指向プログラミングは、変数のスコープがそれらの変数をカプセル化するクラスオブジェクトに密接に排他的であることを理解して構築されています。

「グローバル変数」を作成する際の問題は、Javaの業界標準ではないことです。複数のクラスで非同期にデータを操作できるため、業界標準ではありません。マルチスレッドアプリケーションを実行している場合、スレッドの安全性の点で少し複雑で危険になります。グローバル変数の使用が効果がない理由は他にもさまざまですが、それを回避したい場合は、アスペクト指向プログラミングを使用することをお勧めします。

アスペクト指向プログラミングは、「助言」と呼ばれるものを通してスコープを担当する親クラスを置くことによってこの問題を打ち消します。これは実際にコードを変更せずにコードに追加の動作を追加します。横断的な懸念やグローバル変数の使用に対するソリューションを提供します。

Springは、AOPを利用するJavaフレームワークであり、従来はWebアプリケーションで使用されていましたが、コアアプリケーションはJavaフレームワーク（8.0を含む）全体で普遍的に使用できます。これはあなたがもっと探求したい方向かもしれません。

問題を理解する

私は、グローバル変数の修飾を、静的/インスタンス呼び出しを気にしたり、あるクラスから別のクラスへの参照を渡したりすることなく、コード内のどこからでもアクセスおよび変更できる変数と見なしています。

通常、クラスAの場合

public class A {
    private int myVar;

    public A(int myVar) {
        this.myVar = myVar;
    }

    public int getMyVar() {
        return myVar;
    }

    public void setMyVar(int mewVar) {
        this.myVar = newVar;
    }
}

myvarクラスBでアクセスして更新したい

public class B{

    private A a;

    public void passA(A a){
        this.a = a;
    }

    public void changeMyVar(int newVar){
        a.setMyvar(newVar);
    }
}

クラスAのインスタンスの参照を取得し、次のようにクラスBの値を更新する必要があります。

int initialValue = 2;
int newValue = 3;
A a = new A(initialValue);
B b = new B();
b.passA(a);
b.changeMyVar(newValue);
assertEquals(a.getMyVar(),newValue); // true

解決

したがって、これに対する私の解決策は（たとえそれが良い習慣かどうかわからない場合でも）シングルトンを使用することです。

public class Globals {
    private static Globals globalsInstance = new Globals();

    public static Globals getInstance() {
        return globalsInstance;
    }

    private int myVar = 2;

    private Globals() {
    }

    public int getMyVar() {
        return myVar;
    }

    public void setMyVar(int myVar) {
        this.myVar = myVar;
    }
}

これで、グローバルな一意のインスタンスをどこでも取得できます。

Globals globals = Globals.getInstance();
// and read and write to myVar with the getter and setter like 
int myVar = globals.getMyVar();
global.setMyVar(3);

// Get the access of global while retaining priveleges.
// You can access variables in one class from another, with provisions.
// The primitive must be protected or no modifier (seen in example).

// the first class
public class farm{

  int eggs; // an integer to be set by constructor
  fox afox; // declaration of a fox object

  // the constructor inits
  farm(){
    eggs = 4;
    afox = new fox(); // an instance of a fox object

    // show count of eggs before the fox arrives
    System.out.println("Count of eggs before: " + eggs);

    // call class fox, afox method, pass myFarm as a reference
    afox.stealEgg(this);

    // show the farm class, myFarm, primitive value
    System.out.println("Count of eggs after : " + eggs);

  } // end constructor

  public static void main(String[] args){

    // instance of a farm class object
    farm myFarm = new farm();

  }; // end main

} // end class

// the second class
public class fox{

  // theFarm is the myFarm object instance
  // any public, protected, or "no modifier" variable is accessible
  void stealEgg(farm theFarm){ --theFarm.eggs; }

} // end class

グローバル変数を定義するには、静的キーワードを使用できます

public final class Tools {
  public static int a;
  public static int b;
}

これで、どこからでもaとbにアクセスできます。

Tools.a;
Tools.b;

Yoyは正解です。特にJ2MEの場合は、次のコード行をMidLetコンストラクター（プログレッシブ初期化）に入れることにより、NullPointerExceptionを回避できます。

new Tools();

これにより、ツールを使用する命令の前にツールが割り当てられます。

それでおしまい！