Variabili globali in Java

Come si definiscono le variabili globali in Java?

Per definire la variabile globale è possibile utilizzare parole chiave statiche

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

ora puoi accedere a eb da qualsiasi luogo chiamando

Example.a;

Example.b;

Tu no. Questo è di progettazione. Non dovresti farlo anche se potessi.

Detto questo, potresti creare un insieme di membri statici pubblici in una classe chiamata Globals.

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

ma non dovresti davvero :). Seriamente .. non farlo.

Un altro modo è creare un'interfaccia come questa:

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

Qualsiasi classe che deve usarli deve solo implementare l'interfaccia:

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

Stai meglio usando l'iniezione delle dipendenze:

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

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

Molte buone risposte, ma voglio dare questo esempio in quanto è considerato il modo più appropriato per accedere alle variabili di una classe da un'altra classe: usare getter e setter.

Il motivo per cui usi getter e setter in questo modo invece di rendere pubblica la variabile è il seguente. Diciamo che il tuo var sarà un parametro globale che non vuoi MAI cambiare qualcuno durante l'esecuzione del tuo programma (nel caso in cui stai sviluppando codice con un team), qualcosa come forse l'URL di un sito web. In teoria questo potrebbe cambiare e potrebbe essere usato molte volte nel tuo programma, quindi vuoi usare un var globale per poterlo aggiornare tutto in una volta. Ma non vuoi che qualcun altro entri e cambi questo var (possibilmente senza rendersi conto di quanto sia importante). In tal caso semplicemente non includi un metodo setter e includi solo il metodo 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;
    }
}

Non esiste una variabile globale in Java

Tuttavia, ciò che abbiamo è una staticparola chiave e questo è tutto ciò di cui abbiamo bisogno. Non esiste nulla al di fuori della classe in Java. La staticparola chiave rappresenta una variabile di classe che, contrariamente alla variabile di istanza, ha solo una copia e che trascende attraverso tutte le istanze di quella classe creata, il che significa che il suo valore può essere modificato e accessibile in tutte le istanze in qualsiasi momento.

Se hai bisogno di una variabile globale a cui è possibile accedere oltre gli ambiti, questa è la variabile di cui hai bisogno, ma il suo ambito esiste solo dove si trova la classe e sarà tutto.

In verità, non esiste un concetto di "GLOBALE" in un programma OO Java

Tuttavia c'è qualche verità dietro la tua domanda perché ci saranno alcuni casi in cui vuoi eseguire un metodo in qualsiasi parte del programma. Ad esempio il metodo --- random () nell'app Phrase-O-Matic; è un metodo che può essere richiamato da qualsiasi programma.

Quindi, al fine di soddisfare le cose come sopra "Dobbiamo avere variabili e metodi di tipo globale"

DICHIARARE UN VARIABILE COME GLOBALE.

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

DICHIARARE UN METODO COME GLOBALE .

 1. Mark the method as public static While declaring.

Poiché ho dichiarato variabili e metodi globali come statici, puoi chiamarli ovunque tu voglia semplicemente con l'aiuto del seguente codice

ClassName.X

NOTA : X può essere il nome del metodo o il nome della variabile secondo il requisito e ClassName è il nome della classe in cui sono stati dichiarati.

Nulla dovrebbe essere globale, tranne le costanti.

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

Inserisci questo nella tua classe principale. In altri file .java, usalo attraverso:

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

Assicurati di spostare il codice dal pavimento della sala di taglio e di rilasciarlo rimuovendo o commentando questa funzionalità.

Se hai un metodo cavallo di battaglia, come un randomizzatore, ti suggerisco di creare un pacchetto "Toolbox"! Tutti i programmatori dovrebbero averne uno, quindi ogni volta che vuoi usarlo in un .java, importalo!

Non esiste una variabile veramente globale in Java. Ogni variabile statica deve appartenere a una classe (come System.out), ma quando hai deciso in quale classe andrà, puoi farvi riferimento da qualsiasi punto caricato dallo stesso classloader.

Si noti che le variabili statiche devono sempre essere protette durante l'aggiornamento per evitare condizioni di gara.

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

In questo modo è possibile accedervi con GlobalClass.xeGlobalClass.s

public class GlobalImpl {   

 public static int global = 5;

}

puoi chiamare dove vuoi:

GlobalImpl.global // 5

Come probabilmente indovini dalla risposta, non ci sono variabili globali in Java e l'unica cosa che puoi fare è creare una classe con membri statici:

public class Global {
    public static int a;
}

Puoi usarlo con Global.aaltrove. Tuttavia, se usi Java 1.5 o meglio, puoi usare la import staticmagia per renderlo ancora più una vera variabile globale:

import static test.Global.*;

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

E voilà !

Ora questa è tutt'altro che una buona pratica, come puoi vedere negli spot pubblicitari: non farlo a casa

Non ci sono variabili globali in Java, ma ci sono classi globali con campi pubblici. È possibile utilizzare la funzione di importazione statica di java 5 per far sembrare quasi variabili globali.

La variabile generalmente globale (suppongo che la stia confrontando con C, Cpp) definisce come public static final

piace

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

Gli ENUM sono utili anche in tale scenario:

Per esempio Calendar.JANUARY)

Creazione di un file indipendente, ad es. Esempio.java di usare la prima soluzione, va bene. Puoi farlo anche all'interno dell'app, se ad esempio le variabili globali sono speciali per la tua app corrente, ecc .:

Crea una classe all'inizio e dichiara le tue variabili lì dentro:

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

Puoi quindi accedere a queste variabili, usandole come "Globals.month_number", ecc. - da qualsiasi punto della tua app.

Se è necessario aggiornare la proprietà globale, una semplice classe wrapper getter / setter può essere utilizzata come variabile globale. Un esempio tipico è mostrato di seguito.

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

Seguendo il concetto, le variabili globali, note anche come variabili di istanza sono le variabili a livello di classe, cioè sono definite all'interno di una classe ma metodi esterni. Per renderli completamente disponibili e utilizzarli, fornire direttamente la parola chiave statica. Quindi, se sto scrivendo un programma per una semplice operazione aritmetica e richiede una coppia di numeri, allora due variabili di istanza sono definite come tali:

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

Inoltre, l'uso di parole chiave statiche prima delle variabili di istanza ci consente di non specificare più volte tipi di dati per le stesse variabili. Basta scrivere direttamente la variabile.

In generale, Java non ha variabili globali. Oltre alle variabili locali, tutte le variabili rientrano nell'ambito di qualsiasi classe definita nel programma. Possiamo avere variabili statiche per avere l'ambito delle variabili globali.

senza staticquesto è anche possibile:

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

La programmazione orientata agli oggetti è costruita con la consapevolezza che l'ambito delle variabili è strettamente esclusivo dell'oggetto classe che incapsula tali variabili.

Il problema con la creazione di "variabili globali" è che non è uno standard industriale per Java. Non è uno standard industriale perché consente a più classi di manipolare i dati asincronati, se si esegue un'applicazione multi-thread, questo diventa un po 'più complicato e pericoloso in termini di sicurezza dei thread. Vi sono vari altri motivi per cui l'uso delle variabili globali è inefficace, ma se si desidera evitarlo, suggerisco di ricorrere alla programmazione orientata agli aspetti .

La programmazione orientata all'aspetto annulla questo problema mettendo la classe genitrice responsabile dell'ambito attraverso qualcosa chiamato "consigli", che aggiunge un ulteriore comportamento al codice senza modificarlo effettivamente. Offre soluzioni a problemi trasversali o utilizzo variabile globale.

Spring è un framework Java che utilizza AOP e, sebbene sia tradizionalmente utilizzato per applicazioni Web, l'applicazione principale può essere utilizzata universalmente in tutto il framework Java (8.0 incluso). Questa potrebbe essere una direzione che vuoi esplorare di più.

Comprensione del problema

Considero la qualificazione della variabile globale come una variabile a cui è possibile accedere e modificare in qualsiasi punto del codice senza preoccuparsi della chiamata statica / di istanza o passando qualsiasi riferimento da una classe all'altra.

Di solito se hai la classe 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;
    }
}

e vuoi accedere e aggiornare myvarin una classe B,

public class B{

    private A a;

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

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

dovrai avere un riferimento a un'istanza della classe A e aggiornare il valore nella classe B in questo modo:

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

Soluzione

Quindi la mia soluzione a questo, (anche se non sono sicuro che sia una buona pratica), è usare un singleton:

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

Ora puoi ottenere l'istanza unica globale ovunque con:

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

Per definire la variabile globale è possibile utilizzare parole chiave statiche

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

ora puoi accedere a eb da qualsiasi luogo chiamando

Tools.a;
Tools.b;

Hai ragione ... specialmente in J2ME ... Puoi evitare NullPointerException inserendo nel tuo costruttore MidLet (inizializzazione non corretta) questa riga di codice:

new Tools();

Ciò garantisce che gli strumenti vengano allocati prima di qualsiasi istruzione che lo utilizza.

Questo è tutto!