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

מאמר זה מכוון לאלה שנתקלו לראשונה במושג דפוסים, שמעו על Singleton'e, או איכשהו עשו אותו, אבל עדיין לא הבין כלום. ברוך הבא! תלמידי JavaRush נתקלים בדפוסים בפעם הראשונה ברמה 15, כאשר באופן בלתי צפוי הכובע מבקש "לתקן" וליישם דפוס Singletonביישום עצלן. לסטודנטים ששומעים על זה בפעם הראשונה Singletonיש מיד שלל שאלות: מה זה דפוס, למה הוא נחוץ, איזה סוג של דפוס זה, Singletonולבסוף, איזה סוג של יישום עצלן זה. נתחיל לענות לפי הסדר:

מה זה בכלל דפוס?

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

למה אנחנו צריכים דפוסים (דפוסי עיצוב)

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

סוף סוף דפוס סינגלטון

Singletonמתייחס לדפוסים גנרטיביים . התרגום המילולי שלו מתבודד. דפוס זה מבטיח שלמחלקה יש רק אובייקט אחד (מופע אחד של המחלקה) ושנקודת גישה גלובלית מסופקת לאותו אובייקט. מהתיאור צריך להיות ברור שיש להשתמש בדפוס זה בשני מקרים:

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


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

שתי הבעיות הללו נפתרות על ידי Singleton: חייב להיות רק אובייקט אחד בתוכנית וחייבת להיות גישה גלובלית אליו. בדוגמה ברמה 15, הכובע מבקש ליישם את הדפוס הזה עבור המשימה הבאה (הנה התיאור שלה): לאחר קריאה מדוקדקת של התנאי, מתברר מדוע בדיוק Singleton(סינגל) יש צורך כאן. אחרי הכל, התוכנה מבקשת ממך ליצור אובייקט אחד מכל מחלקה: Sun, Moon, Earth. וזה הגיוני להניח שכל מחלקה בתוכנית צריכה ליצור לא יותר משמש/ירח/כדור הארץ אחד, אחרת זה יהיה אבסורדי, אלא אם כן אתה כמובן כותב גרסה משלך למלחמת הכוכבים. תכונה של יישום SingletonJava בשלושה שלבים התנהגות Singleton ב-Java לא ניתנת ליישום באמצעות בנאי רגיל מכיוון שהקונסטרוקטור תמיד מחזיר אובייקט חדש. לכן, כל ההטמעות של Singleton'a מסתכמות בהסתרת הקונסטרוקטור ויצירת שיטה סטטית ציבורית שתשלוט בקיומו של אובייקט בודד ו"תהרוס" את כל האובייקטים החדשים שיופיעו. אם Singletonנקרא 'a, עליו ליצור אובייקט חדש (אם הוא עדיין לא בתוכנית) או להחזיר אובייקט שכבר נוצר. כדי לעשות זאת: #1. - אתה צריך להוסיף שדה סטטי פרטי למחלקה המכילה אובייקט בודד:

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance; //#1
}

#2. – הפוך את בנאי המחלקה (בנאי ברירת המחדל) לפרטי (כדי שהגישה אליו תיסגר מחוץ למחלקה, ואז הוא לא יוכל להחזיר אובייקטים חדשים):

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance;
private LazyInitializedSingleton(){} // #2
}

#3 . – הכריז על שיטת יצירה סטטית שתשמש להשגת הסינגלטון:

public class LazyInitializedSingleton {
    private static LazyInitializedSingleton instance;
        private LazyInitializedSingleton(){}
        public static LazyInitializedSingleton getInstance(){ // #3
        if(instance == null){		//if the object has not been created yet
            instance = new LazyInitializedSingleton();	//create a new object
        }
        return instance;		// return the previously created object
    }
}

הדוגמה לעיל היא מעט מגושמת, כי אנחנו פשוט מסתירים את הבנאי ומספקים שיטה משלנו במקום הבנאי הסטנדרטי. מכיוון שמאמר זה נועד לאפשר לתלמידי JavaRush לבוא במגע עם דפוס זה (ודפוסים בכלל) בפעם הראשונה, תכונות היישום של Singletons מורכבות יותר לא יינתנו כאן. נציין רק כי בהתאם למורכבות התוכנית, ייתכן שיידרש חידוד מפורט יותר של דפוס זה. לדוגמה, בסביבת ריבוי-שרשורים (ראה את נושא השרשורים), מספר שרשורים שונים יכולים לקרוא בו-זמנית לשיטת ה-Singleton's getter, והקוד המתואר לעיל יפסיק לעבוד, מכיוון שכל שרשור בודד יוכל ליצור מספר מופעים של המחלקה בבת אחת. לכן, עדיין קיימות מספר גישות שונות ליצירת יחידות נכונות בטוחות לחוטים. אבל זה כבר סיפור אחר =) ולבסוף. מהי אתחול העצל שהכובע ביקש ? אתחול העצל נקרא גם אתחול העצל. זוהי טכניקת תכנות שבה פעולה עתירת משאבים (ויצירת אובייקט היא פעולה עתירת משאבים) מתבצעת לפי דרישה, ולא מראש. וזה בעצם מה שקורה בקוד שלנו Singletonא. במילים אחרות, האובייקט שלנו נוצר ברגע הגישה אליו, ולא מראש. אין להניח שהמושג של אתחול עצלן קשור איכשהו בקפדנות Singletonלאום. אתחול עצלן משמש גם בתבניות עיצוב גנרטיביות אחרות, למשל ב-Proxy ו-Factory Method, אבל זה כבר סיפור אחר =) המקורות הבאים שימשו בהכנת המאמר:

1. שיטות עבודה מומלצות לדפוסי עיצוב של Java Singleton עם דוגמאות
2. תבניות עיצוב
3. תקן Singleton בג'אווה