Zmienne globalne w Javie

Jak definiujesz zmienne globalne w Javie?

Aby zdefiniować zmienną globalną, możesz użyć statycznego słowa kluczowego

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

teraz możesz uzyskać dostęp do aib z dowolnego miejsca, dzwoniąc

Example.a;

Example.b;

Ty nie. To z założenia. Nie powinieneś tego robić, nawet jeśli możesz.

Biorąc to pod uwagę, możesz stworzyć zestaw publicznych statycznych członków w klasie o nazwie Globals.

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

ale naprawdę nie powinieneś :). Poważnie ... nie rób tego.

Innym sposobem jest utworzenie takiego interfejsu:

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

Każda klasa, która musi z nich korzystać, musi jedynie zaimplementować interfejs:

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

Lepiej jest użyć wstrzykiwania zależności:

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

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

Wiele dobrych odpowiedzi, ale chcę podać ten przykład, ponieważ jest on uważany za bardziej właściwy sposób uzyskiwania dostępu do zmiennych klasy przez inną klasę: za pomocą metod pobierających i ustawiających.

Powód, dla którego używasz getterów i seterów w ten sposób, zamiast po prostu upubliczniać zmienną, jest następujący. Powiedzmy, że twój var będzie globalnym parametrem, którego NIGDY nie chcesz, aby ktoś zmienił podczas wykonywania twojego programu (w przypadku, gdy tworzysz kod z zespołem), coś w rodzaju adresu URL strony internetowej. Teoretycznie może się to zmienić i może być używane wiele razy w twoim programie, więc chcesz użyć globalnego var, aby móc zaktualizować wszystko naraz. Ale nie chcesz, aby ktoś inny wszedł i zmienił ten var (być może nie zdając sobie sprawy z tego, jak ważne jest). W takim przypadku po prostu nie podajesz metody ustawiającej, a jedynie metodę gettera.

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;
    }
}

W Javie nie ma globalnej zmiennej

Niemniej jednak mamy staticsłowo kluczowe i to wszystko, czego potrzebujemy. W Javie nie ma nic poza klasą. Thestatic kluczowe reprezentuje zmienną klasy, która w przeciwieństwie do zmiennej instancji, ma tylko jedną kopię i która przekracza wszystkie instancje utworzonej klasy, co oznacza, że ​​jej wartość można zmienić i uzyskać do niej dostęp we wszystkich instancjach w dowolnym momencie.

Jeśli potrzebujesz zmiennej globalnej, do której można uzyskać dostęp poza zasięgiem, jest to zmienna, której potrzebujesz, ale jej zakres istnieje tylko tam, gdzie jest klasa, i to wszystko.

Prawdę mówiąc, nie ma pojęcia „GLOBALNY” w programie Java OO

Niemniej jednak za twoim pytaniem kryje się trochę prawdy, ponieważ będą przypadki, w których będziesz chciał uruchomić metodę w dowolnej części programu. Na przykład --- metoda random () w aplikacji Phrase-O-Matic; jest to metoda, którą można wywoływać z dowolnego programu.

Aby więc spełnić powyższe wymagania „Musimy mieć globalne zmienne i metody”

OŚWIADCZENIE O ZMIENNEJ JAKO GLOBALNEJ.

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

OŚWIADCZENIE METODY JAKO GLOBALNEJ .

 1. Mark the method as public static While declaring.

Ponieważ zadeklarowałem zmienne globalne i metodę jako statyczne, możesz je wywoływać w dowolnym miejscu, po prostu za pomocą następującego kodu

ClassName.X

UWAGA : X może być nazwą metody lub nazwą zmiennej zgodnie z wymaganiami, a ClassName to nazwa klasy, w której je zadeklarowano.

Nic nie powinno być globalne, z wyjątkiem stałych.

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

Umieść to w swojej głównej klasie. W innych plikach .java użyj go poprzez:

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

Upewnij się, że po przeniesieniu kodu z podłogi krojowni i wydaniu usuniesz lub skomentujesz tę funkcję.

Jeśli masz metodę konia pociągowego, taką jak randomizator, sugeruję utworzenie pakietu „Toolbox”! Wszyscy koderzy powinni go mieć, a następnie za każdym razem, gdy chcesz go użyć w .java, po prostu zaimportuj go!

W Javie nie ma czegoś takiego jak prawdziwie globalna zmienna. Każda zmienna statyczna musi należeć do jakiejś klasy (np. System.out), ale kiedy zdecydujesz, do której klasy ona wejdzie, możesz odwoływać się do niej z dowolnego miejsca ładowanego przez ten sam moduł ładujący klasy.

Należy pamiętać, że zmienne statyczne należy zawsze chronić podczas aktualizacji, aby uniknąć warunków wyścigu.

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

W ten sposób możesz uzyskać do nich dostęp za pomocą GlobalClass.xiGlobalClass.s

public class GlobalImpl {   

 public static int global = 5;

}

możesz zadzwonić gdziekolwiek chcesz:

GlobalImpl.global // 5

Jak zapewne zgadniesz z odpowiedzi, w Javie nie ma zmiennych globalnych, a jedyne, co możesz zrobić, to stworzyć klasę z elementami statycznymi:

public class Global {
    public static int a;
}

Możesz go używać z Global.ainnym miejscem. Jeśli jednak używasz języka Java 1.5 lub nowszego, możesz użyć import staticmagii, aby wyglądała jeszcze bardziej jak prawdziwa zmienna globalna:

import static test.Global.*;

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

I voila !

Teraz nie jest to najlepsza praktyka, więc jak widać w reklamach: nie rób tego w domu

W Javie nie ma globalnych zmiennych, ale istnieją globalne klasy z polami publicznymi. Możesz użyć funkcji importowania statycznego w java 5, aby wyglądała prawie jak zmienne globalne.

Ogólnie Zmienna globalna (zakładam, że porównujesz ją z C, Cpp) zdefiniuj jako public static final

lubić

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

ENUM są również przydatne w takim scenariuszu:

Na przykład Calendar.JANUARY)

Tworzenie niezależnego pliku, np. Przykład.java, aby użyć pierwszego rozwiązania, jest w porządku. Możesz to zrobić również w aplikacji, jeśli np. Zmienne globalne są specjalne dla bieżącej aplikacji itp .:

Utwórz klasę na początku i zadeklaruj tam swoje zmienne:

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

Następnie możesz uzyskać dostęp do tych zmiennych - używając ich jako „Globals.month_number” itp. - z dowolnego miejsca w aplikacji.

Jeśli musisz zaktualizować właściwość globalną, jako zmienną globalną można użyć prostej klasy opakowania gettera / settera. Typowy przykład pokazano poniżej.

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());
    }
}

Zgodnie z tym pojęciem zmienne globalne, znane również jako zmienne instancji, są zmiennymi na poziomie klasy, tzn. Są zdefiniowane wewnątrz klasy, ale poza metodami. Aby udostępnić je całkowicie i użyć bezpośrednio, wpisz słowo kluczowe static. Więc jeśli piszę program do prostej operacji arytmetycznej i wymaga on pary liczb, wówczas dwie zmienne instancji są zdefiniowane jako takie:

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

Ponadto użycie statycznego słowa kluczowego przed zmiennymi instancji pozwala nam nie określać typów danych dla tych samych zmiennych raz za razem. Po prostu napisz zmienną bezpośrednio.

Ogólnie rzecz biorąc, Java nie ma żadnych zmiennych globalnych. Poza zmiennymi lokalnymi wszystkie zmienne wchodzą w zakres dowolnej klasy zdefiniowanej w programie. Możemy mieć zmienne statyczne, aby mieć zakres zmiennych globalnych.

bez statictego możliwe jest również:

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
*/

Programowanie obiektowe jest zbudowane ze zrozumieniem, że zakres zmiennych jest ściśle wyłączny dla obiektu klasy, który zawiera te zmienne.

Problem z tworzeniem „zmiennych globalnych” polega na tym, że nie jest to standard branżowy dla Javy. Nie jest to standard branżowy, ponieważ pozwala wielu klasom na asynchronizację danych. Jeśli korzystasz z aplikacji wielowątkowej, staje się to nieco bardziej skomplikowane i niebezpieczne pod względem bezpieczeństwa wątków. Istnieje wiele innych powodów, dla których używanie zmiennych globalnych jest nieskuteczne, ale jeśli chcesz tego uniknąć, sugeruję skorzystanie z programowania zorientowanego na aspekty .

Programowanie zorientowane na aspekt eliminuje ten problem, powierzając klasie nadrzędnej kontrolę nad zakresem poprzez coś zwanego „poradami”, co dodaje dodatkowe zachowanie do kodu bez jego modyfikacji. Oferuje rozwiązania przekrojowych problemów lub globalnego wykorzystania zmiennych.

Spring jest platformą Java, która wykorzystuje AOP i chociaż jest tradycyjnie używana w aplikacjach internetowych, podstawowa aplikacja może być używana uniwersalnie w całej platformie Java (w tym 8.0). To może być kierunek, w którym chcesz odkryć więcej.

Zrozumienie problemu

Rozważam kwalifikację zmiennej globalnej za zmienną, do której można uzyskać dostęp i zmienić ją w dowolnym miejscu kodu bez dbania o wywołanie statyczne / wystąpienie lub przekazywanie referencji z jednej klasy do drugiej.

Zwykle jeśli masz klasę 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;
    }
}

i chcesz uzyskać dostęp i aktualizować myvarw klasie B,

public class B{

    private A a;

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

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

musisz mieć odwołanie do instancji klasy A i zaktualizować wartość w klasie B w następujący sposó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

Rozwiązanie

Więc moim rozwiązaniem tego (nawet jeśli nie jestem pewien, czy to dobra praktyka) jest użycie singletonu:

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;
    }
}

Teraz możesz uzyskać globalną unikalną instancję w dowolnym miejscu dzięki:

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

Aby zdefiniować zmienną globalną, możesz użyć statycznego słowa kluczowego

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

teraz możesz uzyskać dostęp do aib z dowolnego miejsca, dzwoniąc

Tools.a;
Tools.b;

Racja ma rację ... szczególnie w J2ME ... Możesz uniknąć NullPointerException, umieszczając w swoim konstruktorze MidLet (inicjacja progresywna) następujący wiersz kodu:

new Tools();

Zapewnia to przydzielenie Narzędzi przed każdą instrukcją, która ich używa.

Otóż ​​to!