משתנים גלובליים ב-Java: מתי להשתמש בהם?

שלום! במאמר זה נדבר על משתנים גלובליים, הצהרתם ודוגמאות לשימוש מתאים. הערה קטנה: לא נשקול משתני מחלקה גלובליים, כלומר כאלה שניתן לגשת אליהם בתוך כל מחלקה אחת. נדבר על משתנים גלובליים של האפליקציה כולה - אלו שניתן לגשת אליהם בתוך האפליקציה כולה.

כיצד ליצור משתנים גלובליים

משתנים גלובליים הם משתנים הנגישים מכל מקום באפליקציה. במילים אחרות, היקפם הוא היישום כולו. כדי ליצור משתנה כזה ב-Java, עליך ליצור משתנה סטטי ציבורי במחלקה ציבורית:

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

המשתנים a, bו- strהפכו לגלובליים. אנו יכולים לגשת אליהם ישירות משיעורים אחרים בתוך האפליקציה:

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

אם נריץ את השיטה main, נראה את הפלט הבא:

4
5
Global String variable value

ניתן לחלק משתנים גלובליים ל-2 סוגים:

• משתנים שניתן לערוך;
• משתנים שניתן לקרוא רק.

האחרונים נקראים קבועים גלובליים. על מנת ליצור קבוע גלובלי, עליך ליצור משתנה finalולהקצות לו ערך בעת הגדרת המשתנה:

public class Constants {

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

}

על פי מוסכמות השמות של ג'אווה, כל הקבועים חייבים לקבל שמות באותיות גדולות, תוך הפרדה של מילים עם תו קו תחתון. אז, יצרנו קבועים, ועכשיו לא נוכל לשנות את הערכים שלהם: עם זאת, אנחנו יכולים לקרוא את הערכים שלהם:

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

סיכום:

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

סיכום:

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

האם להשתמש במשתנים גלובליים?

יש הרבה מאמרים באינטרנט, שהמסר העיקרי שלהם הוא זה: משתנים גלובליים הם רעים, רעים ונוראים. באמת? בואו ננסה לתת את היתרונות והחסרונות של משתנים גלובליים כדי שכל אחד יוכל להסיק את המסקנה שלו. נתחיל עם החסרונות. בואו נדמיין אפליקציה שיש לה מחלקה עם משתנים גלובליים שניתן לקרוא ולערוך. עם הזמן גדל מספר המחלקות בפרויקט, מספר המשתנים והשיטות הגלובליות המשתמשות במשתנים גלובליים, או במילים אחרות, תלויים בהם. עם הזמן, כל משתנה גלובלי נקרא בחלקים שונים של המערכת למטרות שונות. ניתן לעדכן את הערך של משתנה בחלקים שונים של המערכת. התמונה הכוללת של העולם של יישום זה הופכת מסובכת משמעותית, וזה מוביל לחסרונות הבאים :

1. הקריאה מופחתת והגברת הקושי בהבנת קוד.
2. מורכבות מוגברת של תחזוקת קוד.
3. כדי לשנות משתנה גלובלי אחד, יש צורך לנתח את כל הקוד כדי לא להגדיר את המשתנה לערך שאינו חוקי עבור חלקים אחרים של המערכת.
4. עלייה בשגיאות שקשה מאוד לנפות באגים.

   בואו נדמיין משתנה גלובלי, מערך של אובייקטים. בחלק אחד של המערכת, למשל, צפויות מחרוזות במערך הזה, ובחלק אחר של המערכת מישהו החליט להשתמש במספרי נקודה צפה. לא סביר שמישהו ירצה להבין את זה.

5. שמות המשתנים עשויים להיות זהים אם אתה משתמש במשתנים גלובליים בקוד שלך, כמו גם בספריות מסוימות אשר, בתורן, משתמשות גם במשתנים גלובליים. זה יכול להוביל לשגיאות הן בצד היישום שלך והן בצד הספרייה שבה אתה משתמש.
6. מגביר את הקישוריות בין חלקים שונים של המערכת המשתמשים במשתנים גלובליים. להיפך, עליך לשאוף לצימוד רופף של הקוד. עדיף שתת-מערכות קטנות רבות מחוברות זו לזו, מאשר דבר אחד כבד. כי למוח קל יותר להתמודד עם כמה דברים פשוטים מאשר עם דבר אחד מורכב ומבלבל מדי.
7. כתיבת מבחני יחידות הופכת לקשה יותר מכיוון שהמבחן אינו יודע אילו משתנים גלובליים נדרשים וכיצד יש לאתחל אותם.
8. ביישומים מרובי הליכי, השימוש במשתנים גלובליים על ידי שרשורים שונים מוביל לעלייה בשגיאות שקשה לנפות באגים ולעלייה במורכבות הפרויקט. בגלל זה, יש צורך להגדיר את הגישה למשתנים כאלה בצורה נכונה יותר, לצייד אותם בסנכרון ומנעולים. זה עלול להוביל לקצר חשמלי בעתיד. לדוגמה, שרשור A נעל את המשתנה X לעבודתו, והשרשור B נעל את המשתנה Y לעבודתו, והשרשור A זקוק כעת למשתנה Y, והשרשור B זקוק למשתנה X. כתוצאה מכך, התוכנית תתקע.

אבל כל זה לא מדויק. זהו תיאור של סיכונים שהסבירות להם עולה ככל שהפרויקט גדל ומספר המשתנים הגלובליים בו עולה. בואו נעבור ליתרונות :

1. בפרויקטים קטנים, משתנים גלובליים הם הדבר הפשוט ביותר לגרום לפרויקט לעבוד.
2. לפעמים החשש משימוש במשתנים גלובליים מוביל למורכבות עוד יותר בפרויקט. ואז מתכנתים מתחילים ליצור יחידות ולפנות לדפוסי עיצוב אחרים.
3. בתכנות, לעתים קרובות אתה צריך להסתמך על כמה ערכים בלתי ניתנים לשינוי.

   הדבר ההגיוני ביותר הוא לכתוב ערכים כאלה כקבוע, כי רק קבועים מבטיחים שערכו של משתנה לא ישתנה עם הזמן. קבועים כאלה ניתן למצוא כל הזמן ( Integer.MAX_VALUE, Integer.MIN_VALUE, Boolean.TRUE, Collections.EMPTY_LISTוכו'). אבל התכנות אינו מוגבל לשימוש בספריות סטנדרטיות. לעתים קרובות קורה שאתה צריך לכתוב איזשהו היגיון ייחודי, שיצטרך להסתמך על הקבועים הייחודיים שלך. זו הסיבה שלפעמים השימוש בקבועים (משתנים גלובליים לקריאה בלבד) באמת מקל על החיים.

באופן כללי, אין להשתמש יתר על המידה במשתנים גלובליים; אם אפשר, השתמש רק בקבועים. נאמר קודם ששימוש במשתנים גלובליים בפרויקטים קטנים זה לא רע. אבל עדיף למפתח מתחיל לא להשתמש בהם בכלל. משתי סיבות:

1. כל מה שמפתח מתחיל כותב הוא בעצם פרויקט קטן. ושימוש במשתנים גלובליים בפרויקטים שלו ילמד אותו להשתמש במשתנים גלובליים בכל מקום.
2. עדיף קודם כל ללמוד לעשות בלי "טריקים אסורים". ועם הניסיון, ההבנה מתי טכניקות כאלה מתאימות לשימוש תגיע מעצמה.