Глобальні змінні в 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;
    }
}

Дуже багато хороших відповідей, але я хочу навести цей приклад, оскільки це вважається більш правильним способом доступу до змінних класу іншим класом: за допомогою getters та setters.

Причина, чому ви використовуєте геттери та сетери таким чином, а не просто оприлюднювати змінну, полягає в наступному. Скажімо, ваш var стане глобальним параметром, який ви НІКОЛИ не бажаєте, щоб хтось міняв під час виконання вашої програми (у випадку, коли ви розробляєте код з командою), на зразок URL-адреси веб-сайту. Теоретично це може змінитися і може використовуватися багато разів у вашій програмі, тому ви хочете використовувати глобальний var, щоб мати можливість оновити все це відразу. Але ви не хочете, щоб хтось інший заходив і міняв цю вару (можливо, не усвідомлюючи, наскільки це важливо). У такому випадку ви просто не включаєте метод 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 нічого не існує поза класом. ThestaticКлючове слово являє собою змінний клас , який, в відміну від змінного екземпляра, має тільки одну копії і яка виходить за межі у всіх примірниках цього класу , створених, а це значить , що його значення може бути змінено і доступом в усіх випадках , в будь-який момент.

Якщо вам потрібна глобальна змінна, до якої можна отримати доступ понад рамки, то ця змінна вам потрібна, але її область існує лише там, де є клас, і це буде все.

По-справжньому, в програмі java OO не існує поняття "GLOBAL"

Тим не менш, за вашим запитанням є якась правда, оскільки в деяких випадках програми ви хочете запустити метод. Наприклад --- метод random () у додатку Phrase-O-Matic; це метод, який слід викликати з будь-якої програми програми.

Отже, щоб задовольнити такі речі, як Вище "Нам потрібно мати глобальні змінні та методи"

ДЕКЛАРАЦІЮВАТИ ВАРІАНТУ ЯК ГЛОБАЛЬНО.

 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");

Переконайтеся, що коли ви переміщуєте код з підлоги різальної кімнати, а у звільненні ви видаляєте та коментуєте цю функціональність.

Якщо у вас є метод робочого коня, як-от рандомізатор, я пропоную створити пакет "Toolbox"! Усі кодери повинні мати його, тоді, коли ви хочете використовувати його в .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 для використання 1-го рішення, просто чудово. Це можна зробити і в додатку, якщо, наприклад, глобальні змінні є спеціальними для вашої поточної програми тощо:

Створіть клас на початку та декларуйте там свої змінні:

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

Потім ви можете отримати доступ до цих змінних - використовуючи їх як "Globals.month_number" тощо. - з будь-якого місця у вашій програмі.

Якщо вам потрібно оновити глобальну властивість, простий клас getter / setter обгортки може використовуватися як глобальна змінна. Типовий приклад показаний нижче.

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

За принципом, глобальні змінні, також відомі як змінна інстанція, є змінними рівня класу, тобто вони визначаються всередині класу, але поза методами. Для того, щоб зробити їх доступними повністю та використовувати їх, надайте статичне ключове слово. Отже, якщо я пишу програму для простої арифметичної роботи, і їй потрібна пара чисел, то дві змінні екземпляра визначаються як такі:

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

Крім того, використання статичного ключового слова до змінних екземплярів дозволяє нам не вказувати типи даних для одних і тих же змінних знову і знову. Просто запишіть змінну безпосередньо.

Загалом, у 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 - це програма Java, яка використовує AOP, і хоча вона традиційно використовується для веб-додатків, основний додаток може використовуватися універсально у всій системі Java (включено 8.0). Це може бути напрямок, який ви хочете вивчити більше.

Розуміння проблеми

Я розглядаю кваліфікацію глобальної змінної як змінну, до якої можна отримати доступ і змінити будь-де в коді, не піклуючись про статичний / виклик екземпляра або передачу будь-якої посилання з одного класу в інший.

Зазвичай, якщо у вас клас А

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 ... Ви можете уникнути NullPointerException, помістивши всередину свого конструктора MidLet (ініціалізація прогресії) цей рядок коду:

new Tools();

Це гарантує, що Інструменти будуть виділені перед будь-якою інструкцією, яка ним користується.

Це воно!