הרשאות גישה - Modifiers
private: רק המחלקה עצמה רואה את החבר. זו ברירת המחדל לחברים (data members) של מחלקה.protected: המחלקה עצמה ומחלקות היורשות ממנה. מחוץ למחלקה, למשל ב-Main, החבר לא נראה.internal: כל מקום בפרויקט הנוכחי, כולל מחלקות אחרות שנמצאות באותו פרויקט.protected internal: שילוב של השניים. נגיש למחלקות היורשות, גם כשהן בפרויקט אחר, וגם לכל מי שנמצא בפרויקט הנוכחי.public: נגיש מכל מקום, כשיש לנו גישה לאובייקט.internal. לטיפוס עצמו מותר להגדיר רק internal או public.public.private ו-protected הם הנפוצים ביותר, ואילו protected internal נדיר מאוד. בחירת רמת הגישה הנכונה לכל חבר וטיפוס היא חלק מתכנון נכון של הפרויקט.פרקי ההרצאה: הרשאות גישה - Modifiers
תמלול ההרצאה: הרשאות גישה - Modifiers
הטקסט המלא של הדקות הראשונות בהרצאה «הרשאות גישה - Modifiers» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו עוברים לראות אילו הרשאות גישה נוספות קיימות באובג'קט אוריינטד. אנחנו כבר הכרנו את פרייבט ואת פאבליק, אבל בואו נראה אילו עוד הרשאות גישה קיימות. לצורך כך אני אבנה כאן איזושהי מחלקה, אפשר כמובן לבנות אותה בקובץ נפרד, אבל אני כרגע אבנה אותה כאן.
יש לנו פה קלאס, אני אקרא לה בייס קלאס, ובתוך הבייס קלאס הזאת אני רוצה לבנות דאטה ממברס מהרשאות הגישה השונות שקיימות. הרשעת גישה ראשונה שכבר ראינו נקראת פרייבט.
אז בואו נגדיר איזשהו משתנה אינטג'רי ונקרא לו private data member בכדי שנדע שזה הפרייבט. הרשעת גישה נוספת שקיימת נקראת protected. ניקח עוד משתנה ונקרא לו protected data member.
הרשעת גישה נוספת שקיימת נקראת אינטרנל, נפתח פה אינטרנל data member. הרשעת גישה נוספת שקיימת בדוטנט נקראת פרוטקטד אינטרנל היא בנויה משתי המילים האלה, נפתח פה דאטה ממבר ונקרא לו פרוטקטד קודם כל אינטג'ר והרשאת גישה האחרונה שקיימת מפאבליק.
עכשיו בואו נבין מה ההבדל בין כל אחת מהן ולמה צריך כל אחת מהן. נפתח פה איזושהי פונקציה, נקרא לה פרינט, נרשום דיס שזה בעצם המחלקה עצמה או יותר נכון האובייקט הנוכחי ולכן אם אנחנו רושמים נקודה אנחנו אמורים לראות את כל מה שניתן לראות.
ואנחנו רואים את כל הרשאות הגישה, כל חמש הרשאות הגישה ניתנות לצפייה פה. אנחנו רואים פה את ה-Private Data Member, זאת אומרת שיש לנו גישה אליו, יש לנו את ה-Protected, יש לנו את ה-Internal, יש לנו את ה-Protected-Internal ואת ה-Public.
זאת אומרת, אם אני נמצא בתוך המחלקה אני נגיש כמובן להכל. עכשיו, מה קורה אם אני לא נמצא בתוך המחלקה אלא נמצא מחוץ למחלקה?
כלומר נניח אני נמצא במיין, זאת אומרת אני חייב לבנות איזשהו אובייקט, בייס קלאס opt שווה new בייס קלאס. obj נקודה, בואו נסתכל עכשיו את מי אני יכול לראות.
קודם כל אני לא רואה את הפרייבט ואני לא רואה גם את הפרוטקטד. מה שאני רואה זה את האינטרנל, את הפרוטקטד אינטרנל ואת הפאבליק. תכף אנחנו נבין בדיוק מה זה אומר כל אחד מהם.
אבל בוא נניח שאני נמצא באיזשהי קלאס שנקראת derived קלאס והיא יורשת את הבייס קלאס. עכשיו בואו נניח שיש לי פה public void print ואני רושם בייס או דיס לא משנה נקודה עכשיו אני רואה שאת הפרייבט אני לא מצליח לראות את האינטרנל אני כן רואה את הפרוטקטד אני כן רואה את הפרוטקטד אינטרנל אני כן רואה ואת הפאבליק אני כן רואה אוקיי מקודם לא ראיתי
את הפרוטקטד בתוך המיין וכרגע אני כן רואה אותו אז מה בעצם ההבדלים ביניהם אז בואו נסתכל פרייבט מציין מי שיכול לגשת למשתנה או לפונקציה ואך ורק המחלקה עצמה.
פרוטקטד מציין מי שיכול לגשת למשתנה או לפונקציה, זה אך ורק המחלקה ומחלקות שיורשות אותה. ראינו שמהדירה אפשר לגשת לפרוטקטד. אינטרנל מציין שמי שיכול לגשת למשתנה או לפונקציה או לפרופרטי, לא משנה שהם מוגדרים על ידי אינטרנל, המחלקה עצמה וכל מחלקה אחרת שנמצאת בפרויקט הנוכחי.
שימו לב, כל זה זה פרויקט, יכול להיות לי פה הרבה מחלקות וכל מחלקה אחרת שנמצאת בתוך הפרויקט יכולה לגשת לאותו אייטם שהוגדר כאינטרנל.
עכשיו, מה זה אומר? מי שלא נמצא בפרויקט, תכף אנחנו נראה את זה, פרוטקטד אינטרנל זה בעצם גם פרוטקטד וגם אינטרנל. זאת אומרת, מי שיכול לגשת לאותו משתנה זה כל מי שיורש את המחלקה שלנו, גם המחלקה עצמה כמובן, וכל מי שנמצא בפרויקט הנוכחי, גם אם הוא לא יורש את המחלקה.
זאת אומרת, כל מי שנמצא בפרויקט הנוכחי, בין אם הוא יורש את המחלקה שלנו ובין אם הוא לא, וגם מחלקות אחרות שנמצאות בפרויקטים אחרים, אבל רק אם הן יורשות את המחלקה, וזה הקטע של ה-protected.
public מציין שהdata member הזה או הפונקציה נגישים מכל מקום. זאת הסיבה שהצלחנו לראות אותם גם מהמיין. אלה חמשת הרשאות הגישה ובואו נבין מה זה אומר בדיוק ה-internal.
אינטרנל מדבר על מצב שבו אנחנו רוצים לכתוב רויקט שיש בו טיפוסי נתונים והוא מיועד לשרת פרויקטים אחרים. במילים אחרות אנחנו בונים משהו שנקרא dynamic link library.
לבריא זה ספרייה של טיפוסי נתונים וDynamic Link Library או בקיצור DLL זה בעצם פרויקט שמחזיק בתוכו טיפוסי נתונים שונים שנדרשים לשימוש במספר פרויקטים ולכן לא הגיוני שניקח טיפוס נתונים מסוים ונשכפל אותו בפרויקטים שונים.
דוגמה, יש לנו טיפוס נתונים שאנחנו בונים שנקרא אדם person ואנחנו רוצים להשתמש איתו גם בפרויקט של מכללה שאנחנו בונים וגם בפרויקט לניהול מפעל שאנחנו בונים וגם בפרויקט אחר של צ'אט שאנחנו בונים.
במקום לקחת את המחלקה פרסון ופשוט להעתיק אותה ולהדביק אותה בכל אחד מהפרויקטים האלה, אנחנו יכולים להוציא אותה החוצה ל-DLL, ואז כל הפרויקטים האחרים יכולים להשתמש עם ה-DLL.
באחד המודולים של תכנות מתקדם, יהיה לנו בעצם קירה יותר עמוקה לגבי DLLים, אבל בואו נראה בצורה פשוטה מה זה אומר להוסיף DLL.
זה אומר שאנחנו יכולים ללחוץ מקש ימני על הסולושן, לא על הפרויקט, לסלושן, לבצע add new project ואנחנו רוצים לבחור משהו שנקרא class library. Class library זה בעצם dll.
בואו נקרא ל-dll הזה mytypes/library אנחנו רואים שיש לנו עכשיו שני פרויקטים תחת הסלושן. הפרויקט שאנחנו רואים מושחר זה הפרויקט שהולך לרוץ כאשר אנחנו הולכים לעשות ctrl f5 או להריץ את הפרויקט וזה בעצם הפרויקט הקודם שהתחלנו לבנות.
כאן אנחנו רואים איזשהו dll ומחלקה אחת בתוכו. זאת אומרת אם אנחנו נלך וניקח את המחלקה הזאת, את ה-base class הזאת ונעתיק אותה ונדביק אותה כאן, זאת אומרת היא תהיה חלק מתוך ה-dll השני, אפילו נשנה את השם של הקובץ כך שהשם של הקובץ יהיה באותו השם של המחלקה ה-base class,
אנחנו נוכל להשתמש עם המחלקה הזאת בפרויקט אחר עם כמה דברים יתקיימו. דבר ראשון, אנחנו צריכים לצרף את ה-DLL לפרויקט שלנו למקום הזה שנקרא References.
מכה שימני, Add Reference, אנחנו יכולים לאתר אותו פה בפרויקט. הנה הוא פה, My Types Library, אוקיי. אנחנו רואים שיש לנו עכשיו גישה לכל ה-DLL הזה.
דבר השני שאנחנו צריכים זה לחשוף את הטיפוס החוצה. נגדיר פה כרגע Public ועוד מעט אנחנו נדבר על זה. עכשיו הטיפוס הזה ניתן לשימוש מחוץ ל-DLL.
זאת אומרת אם אנחנו באים לכאן כל מה שאנחנו צריכים לעשות זה לפתוח פה את הדבר הזה ליצור using שעל זה אנחנו גם נדבר בהמשך וכעת אנחנו רואים שהפרויקט שלנו מכיר את המחלקה base class למרות שהיא לא הוגדרה בפרויקט שלנו אלא הוגדרה בפרויקט חיצוני.
כך אנחנו יכולים לבצע משהו שנקרא reusability של קוד זאת אומרת אנחנו יכולים לכתוב מחלקה בתוך dll ולהשתמש איתה בכל מיני פרויקטים אחרים שאנחנו רוצים.
כלי מאוד חזק בפיתוח תוכנה. עכשיו בואו נראה מי יכול לראות את ה-Base Class. אז אם יש לי עכשיו אובייקט מה-Base Class, אני רואה רק את ה-Public, זאת אומרת אני לא מצליח לראות את ה-Internal כמו שראינו מקודם, מפני שאני לא נמצא באותו פרויקט.
גם אני לא רואה את ה-Protected Internal כי אני לא נמצא באותו פרויקט. זאת אומרת, Base Class נמצאת בפרויקט אחר מהפרויקט שלנו, אנחנו לא מצליחים לראות את כל מה שהוגדר כ-Internal.
כמובן לא מה שהוגדר כPrivate כי רק המחלקה יכולה לראות אותו וגם