עקרונות אנקפסולציה ב-Java

שלום! ההרצאה היום תוקדש לאנקפסולציה ומיד נתחיל אותה בדוגמאות :) לפניכם מכונת סודה מוכרת. יש לי שאלה אחת אליך: איך זה עובד? נסו לענות בפירוט: מאיפה מגיעה הכוס, איך שומרים על הטמפרטורה בפנים, איפה מאחסנים את הקרח, איך המכונה מבינה איזה סירופ להוסיף וכו'. סביר להניח שאין לך תשובות לשאלות האלה. ובכן, אולי לא כולם משתמשים במכונות כאלה; הן לא כל כך פופולריות בימינו. בואו ננסה לתת דוגמה נוספת. משהו שאתה יודע שאתה משתמש בו פעמים רבות בכל יום. אה, יש לי רעיון! ספר לנו כיצד פועל מנוע החיפוש של גוגל . איך בדיוק הוא מחפש מידע על סמך המילים שהזנת? מדוע התוצאות הללו נמצאות בראש ולא אחרות? למרות שאתה משתמש בגוגל כל יום, אתה כנראה לא יודע את זה. אבל זה לא חשוב. אחרי הכל, אתה לא צריך לדעת את זה. אתה יכול להזין שאילתות למנוע חיפוש מבלי לחשוב איך זה בדיוק עובד. אתה יכול לקנות סודה ממכונה אוטומטית בלי לדעת איך זה עובד. אתה יכול לנהוג במכונית בלי להתעמק בפעולת מנוע הבעירה הפנימית, ובלי לדעת פיזיקה בכלל, אפילו ברמת בית הספר. כל זה אפשרי הודות לאחד העקרונות העיקריים של תכנות מונחה עצמים - אנקפסולציה . במהלך קריאת מאמרים שונים בנושא זה, בטח נתקלת בעובדה שיש שני מושגים נפוצים בתכנות - אנקפסולציה והסתרה . ובמילה "אנקפסולציה" מתכוונים המחברים לדבר כזה או אחר (כמו שזה קורה). אנו נפרק את שני המונחים כך שתהיה לך הבנה מלאה. המשמעות המקורית של המילה " אנקפסולציה " בתכנות היא השילוב של נתונים ושיטות עבודה עם נתונים אלה בחבילה אחת ("קפסולה"). ב-Java, המחלקה פועלת כחבילת קפסולה . מחלקה מכילה גם נתונים (שדות מחלקה) וגם שיטות לעבודה עם נתונים אלה. זה נראה לך מובן מאליו, אבל בתפיסות תכנות אחרות הכל עובד אחרת. לדוגמה, בתכנות פונקציונלי, הנתונים מופרדים בקפדנות מהפעולות עליהם. ב-OOP (תכנות מונחה עצמים), תוכניות מורכבות ממחלקות קפסולה, שהן גם נתונים וגם פונקציות לעבודה איתם. עכשיו בואו נדבר על הסתרה . איך זה שאנחנו משתמשים בכל מיני מנגנונים מורכבים בלי להבין איך הם עובדים ועל מה מבוססת העבודה שלהם? זה פשוט: היוצרים שלהם סיפקו ממשק פשוט וידידותי למשתמש. במכונת סודה, הממשק הוא כפתורים על לוח. על ידי לחיצה על כפתור אחד, אתה בוחר את עוצמת הקול של הזכוכית. על ידי לחיצה על השני, אתה בוחר את הסירופ. השלישי אחראי על הוספת קרח. וזה כל מה שאתה צריך לעשות. זה לא משנה איך בדיוק המכונה מתוכננת בפנים. העיקר שהוא מעוצב בצורה כזו שכדי לקבל סודה, המשתמש צריך ללחוץ על שלושה כפתורים . זה אותו דבר עם מכונית. זה לא משנה מה קורה בתוכו. העיקר שכשלוחצים על הדוושה הימנית, המכונית מתקדמת, וכשלוחצים על הדוושה השמאלית היא מאטה . זו בדיוק מהות ההסתרה. כל ה"פנים" של התוכנית מוסתרים מהמשתמש. מבחינתו המידע הזה מיותר ומיותר. המשתמש צריך את התוצאה הסופית, לא את התהליך הפנימי. בואו נסתכל על הכיתה כדוגמה Auto:

public class Auto {

   public void gas() {

       /*some complicated things are happening inside the car
       as a result of which it goes forward*/
   }

   public void brake() {

       /*some complicated things are happening inside the car
       as a result of which it slows down*/
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // How everything looks to the user

       //pressed one pedal - went
       auto.gas();

       //pressed another pedal - braked
       auto.brake();
   }
}

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

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

אולי אתה זוכר מההרצאה האחרונה מה הבעיה של השיעור הזה? אם לא, בואו נזכור. הבעיה היא שהנתונים (השדות) שלו פתוחים לכולם, ומתכנת אחר יכול בקלות ליצור חתול חסר שם בתוכנית במשקל של 0 וגיל של -1000 שנים:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

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

1. משנה גישה ( פרטי , מוגן , ברירת מחדל של חבילה );
2. מגדירים וקובעים.

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

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


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


3. שינויים בקוד אינם משפיעים על המשתמשים. אנחנו עושים את כל השינויים בתוך השיטות. זה לא ישפיע על המשתמש: הוא כתב auto.gas() עבור הגז של המכונית, אז הוא יכתוב את זה. והעובדה ששינינו משהו בפעולת שיטת הגז() תישאר בלתי נראית לו: הוא, כמו קודם, פשוט יקבל את התוצאה הרצויה.