Zmienne globalne w Javie: kiedy ich używać?

Cześć! W tym artykule porozmawiamy o zmiennych globalnych, ich deklaracji i przykładach odpowiedniego użycia. Mała uwaga: nie będziemy brać pod uwagę zmiennych klas globalnych, czyli takich, do których można uzyskać dostęp w ramach dowolnej klasy. Porozmawiamy o zmiennych globalnych całej aplikacji - takich, do których można uzyskać dostęp w ramach całej aplikacji.

Jak utworzyć zmienne globalne

Zmienne globalne to zmienne, do których można uzyskać dostęp z dowolnego miejsca w aplikacji. Inaczej mówiąc, ich zakresem jest cała aplikacja. Aby utworzyć taką zmienną w Javie, musisz utworzyć publiczną zmienną statyczną w klasie publicznej:

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

Zmienne a, bi str- stały się globalne. Mamy do nich dostęp bezpośrednio z innych klas wewnątrz aplikacji:

public class GlobalVarsDemo {
    public static void main(String[] args) {
        Example.a = 4;
        Example.b = 5;
        Example.str = "Global String variable value";

        System.out.println(Example.a);
        System.out.println(Example.b);
        System.out.println(Example.str);
    }
}

Jeśli uruchomimy metodę main, zobaczymy następujący wynik:

4
5
Global String variable value

Zmienne globalne można podzielić na 2 typy:

• zmienne, które można edytować;
• zmienne, które można tylko odczytać.

Te ostatnie nazywane są stałymi globalnymi. Aby utworzyć stałą globalną, należy utworzyć zmienną finali przypisać jej wartość podczas definiowania zmiennej:

public class Constants {

    public static final double PI = 3.1415926535897932384626433832795;
    public static final String HELLO_WORLD_STR = "Hello, World!";

}

Zgodnie z konwencją nazewnictwa Java wszystkie stałe muszą być nazywane wielkimi literami, oddzielając słowa znakiem podkreślenia. Stworzyliśmy więc stałe i teraz nie będziemy mogli zmienić ich wartości: Możemy jednak odczytać ich wartości:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(Constants.HELLO_WORLD_STR);
    }
}

Wniosek:

Hello, World!

public class ConstantsDemo {
    public static void main(String[] args) {
        double r = 10;
        String message = String.format("Площадь круга с радиусом %f=%f", r, getCircleSquare(r));
        System.out.println(message);

    }

    static double getCircleSquare(double r) {
        return Constants.PI * r * r;
    }
}

Wniosek:

Площадь круга с радиусом 10,000000=314,159265

Czy powinieneś używać zmiennych globalnych?

W Internecie można znaleźć wiele artykułów, których główny przekaz jest taki: zmienne globalne są złe, złe i okropne. Czy to naprawdę? Spróbujmy podać zalety i wady zmiennych globalnych, aby każdy mógł wyciągnąć własne wnioski. Zacznijmy od wad. Wyobraźmy sobie aplikację posiadającą klasę ze zmiennymi globalnymi, które można czytać i edytować. Z biegiem czasu rośnie liczba klas w projekcie, liczba zmiennych globalnych i metod, które korzystają ze zmiennych globalnych, czyli inaczej od nich zależą. Z biegiem czasu każda zmienna globalna jest odczytywana w różnych częściach systemu w różnych celach. Wartość zmiennej można aktualizować w różnych częściach systemu. Ogólny obraz świata tej aplikacji staje się znacznie bardziej skomplikowany, a to prowadzi do następujących wad :

1. Zmniejszona czytelność i zwiększona trudność w zrozumieniu kodu.
2. Zwiększona złożoność konserwacji kodu.
3. Aby zmienić jedną zmienną globalną, należy przeanalizować cały kod, aby nie ustawić zmiennej na wartość nieprawidłową dla innych części systemu.
4. Wzrost liczby błędów bardzo trudnych do usunięcia.

   Wyobraźmy sobie zmienną globalną, tablicę obiektów. W jednej części systemu w tej tablicy oczekiwane są na przykład ciągi znaków, a w innej części systemu ktoś zdecydował się na użycie liczb zmiennoprzecinkowych. Mało prawdopodobne, żeby ktokolwiek chciał to zrozumieć.

5. Nazwy zmiennych mogą być takie same, jeśli w kodzie używasz zmiennych globalnych, a także niektórych bibliotek, które z kolei również używają zmiennych globalnych. Może to prowadzić do błędów zarówno po stronie aplikacji, jak i po stronie używanej biblioteki.
6. Zwiększa łączność między różnymi częściami systemu korzystającymi ze zmiennych globalnych. Wręcz przeciwnie, należy dążyć do luźnego powiązania kodu. Lepiej mieć wiele małych podsystemów luźno ze sobą połączonych, niż mieć jeden mocny element. Ponieważ mózgowi łatwiej jest poradzić sobie z kilkoma prostymi rzeczami, niż z jedną zbyt złożoną i zagmatwaną.
7. Pisanie testów jednostkowych staje się trudniejsze, ponieważ test nie wie, które zmienne globalne są potrzebne i jak należy je zainicjować.
8. W aplikacjach wielowątkowych używanie zmiennych globalnych przez różne wątki prowadzi do wzrostu liczby błędów trudnych do debugowania i do wzrostu złożoności projektu. Z tego powodu konieczne jest bardziej poprawne skonfigurowanie dostępu do takich zmiennych, wyposażając je w synchronizacje i blokady. Może to w przyszłości prowadzić do zwarć. Na przykład wątek A zablokował zmienną X do działania, wątek B zablokował do działania zmienną Y, a wątek A potrzebuje teraz zmiennej Y, a wątek B potrzebuje zmiennej X. W rezultacie program się zawiesi.

Ale to wszystko jest nieprawdziwe. Jest to opis ryzyk, których prawdopodobieństwo wzrasta wraz z rozwojem projektu i wzrostem liczby w nim zmiennych globalnych. Przejdźmy do zalet :

1. W małych projektach zmienne globalne są najprostszą rzeczą, która sprawia, że ​​projekt działa.
2. Czasami strach przed użyciem zmiennych globalnych prowadzi do jeszcze większej złożoności projektu. Następnie programiści zaczynają tworzyć singletony i uciekać się do innych wzorców projektowych.
3. W programowaniu często trzeba polegać na pewnych niezmiennych wartościach.

   Najrozsądniej jest zapisywać takie wartości jako stałe, gdyż tylko stałe gwarantują, że wartość zmiennej nie będzie zmieniać się w czasie. Takie stałe można znaleźć cały czas ( Integer.MAX_VALUE, Integer.MIN_VALUE, Boolean.TRUE, Collections.EMPTY_LISTitd.). Ale programowanie nie ogranicza się do korzystania ze standardowych bibliotek. Często zdarza się, że trzeba napisać jakąś unikalną logikę, która będzie musiała opierać się na własnych unikalnych stałych. Dlatego czasami używanie stałych (zmiennych globalnych tylko do odczytu) naprawdę ułatwia życie.

Ogólnie rzecz biorąc, nie należy nadużywać zmiennych globalnych; jeśli to możliwe, używaj tylko stałych. Mówiono wcześniej, że używanie zmiennych globalnych w małych projektach nie jest złe. Ale dla początkującego programisty lepiej jest w ogóle ich nie używać. Z dwóch powodów:

1. Wszystko, co pisze początkujący programista, jest w zasadzie małym projektem. A używanie zmiennych globalnych w swoich projektach nauczy go, jak używać zmiennych globalnych wszędzie.
2. Lepiej najpierw nauczyć się obejść bez „zakazanych sztuczek”. Wraz z doświadczeniem zrozumienie, kiedy należy zastosować takie techniki, przyjdzie samo.