מושגי תכנות מונחה עצמים של JAVA

JAVA מבוסס על המושגים של תכנות מונחה עצמים, המאפשר לך לעבור לרמת הפשטה גבוהה יותר כדי לפתור כל בעיה בצורה מציאותית. הגישה מונחה עצמים משיגה את הפתרון לבעיה במונחים של אובייקטים בעולם האמיתי שקל יותר לעשות בהם שימוש חוזר באפליקציה. לדוגמה, Chair(כיסא), Fan(מאוורר), Dog(כלב), Computer(מחשב) וכן הלאה. ב-JAVA, מחלקה היא פריסה, תבנית או אב טיפוס המגדירים את ההתנהגות הכללית של אובייקט מסוג נתון. מופע הוא מימוש נפרד של מחלקה, ולכל המופעים של מחלקה אותם מאפיינים, המתוארים בהגדרת המחלקה. לדוגמה, ניתן להגדיר מחלקה בשם בית עם מספר חדרים כתכונה וליצור מופעים של המחלקה כגון בית שני חדרים, בית שלושה חדרים וכן הלאה. יתרונות: להלן כמה יתרונות של פיתוח תוכנה מונחה עצמים.

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

ישנם ארבעה מאפיינים עיקריים של OOP:

• כימוס
• יְרוּשָׁה
• רב צורתיות
• הַפשָׁטָה

כימוס

אנקפסולציה פועלת כחוזה לאובייקט מה עליו להסתיר ומה עליו לפתוח לגישה לאובייקטים אחרים. ב-JAVA, אנו משתמשים במשנה גישה privateכדי להסתיר שיטה ולהגביל גישה למשתנה מהעולם החיצון. ל-JAVA יש גם מגני גישה שונים: public, ברירת מחדל, protected, private, המשמשים להגבלת הראות ברמות שונות. אבל המטרה הסופית היא לכלול את הדברים שאסור לשנות. הגישה שעובדת הכי טוב היא שלכיתה צריכה להיות רק סיבה אחת לשנות, ואנקפסולציה הופכת את העיצוב של אותה "סיבה אחת" למציאות. הגישה הנכונה לאנקפסולציה היא להסתיר דברים המשתנים לעתים קרובות כדי להימנע מפגיעה במחלקות אחרות. יתרונות: להלן כמה מהיתרונות של אנקפסולציה:

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

רב צורתיות

פולימורפיזם בתכנות הוא היכולת לספק את אותו ממשק עבור צורות בסיס שונות (סוגי נתונים). משמעות הדבר היא שמחלקות בעלות פונקציונליות שונה חולקות את אותו ממשק וניתן לקרוא אותן באופן דינמי על ידי העברת פרמטרים באמצעות הפניה. דוגמה קלאסית היא המחלקה Shape(צורה) וכל המחלקות היורשות ממנה: square(מרובע), circle(עיגול), dodecahedron(דודקהדרון), irregular polygon(מצולע לא סדיר), splat(בלוב) וכן הלאה. בדוגמה זו, לכל מחלקה תהיה שיטה משלה Draw()וקוד הלקוח יכול פשוט לעשות:

Shape shape = new Shape();

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

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

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

while(it.hasNext()) {
Shape s = (Shape) it.next();
totalArea += s.area(dim); //будет применен полиморфизм и вызван нужный метод для каждого an object.
}

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

List<String> list = new ArrayList<String>();

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

יְרוּשָׁה

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

• שימוש חוזר בקוד משופר.
• היחס הלוגי "הוא" (הוא מישהו, משהו) נוצר. לדוגמה: כלב הוא חיה n . (כלב הוא חיה).
• מודולריזציה של קוד.
• חזרות אינן נכללות.

פְּגָם:

• צמודה הדוקה: תת-מחלקה תלויה ביישום של מחלקת אב, מה שהופך את הקוד לצמוד הדוק.

הַפשָׁטָה

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

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

ההבדל בין הפשטה לאנקפסולציה Encapsulation היא אסטרטגיה המשמשת כחלק מהפשטה. אנקפסולציה מתייחסת למבנה של אובייקט: אובייקטים עוטפים את תכונותיהם ומסתירים אותם מגישה חיצונית. משתמשי מחלקה מקיימים איתה אינטראקציה באמצעות השיטות שלה, אך אין להם גישה ישירה למבנה המחלקה. בדרך זו, הכיתה מפשטת פרטי יישום הקשורים לעיצוב שלה. הפשטה היא מונח כללי יותר. ניתן להשיג אותו, בין היתר, באמצעות תת מחלקות. לדוגמה, מחלקה List(רשימה) בספרייה הסטנדרטית היא הפשטה לרצף של אלמנטים, המאונדקסים לפי מקומם ברשימה. דוגמאות ספציפיות לרשימה Listהן ArrayListאו LinkedList. קוד שמקיים אינטראקציה עם רשימה Listמרחיק את הפרטים של איזו רשימה הוא משתמש. לעתים קרובות הפשטה אינה אפשרית מבלי להסתיר את המצב הבסיסי באמצעות אנקפסולציה. אם מחלקה חושפת את המבנה הפנימי שלה, היא לא יכולה לשנות את הפעולות הפנימיות שלה, ולכן לא ניתן להפשטה. מהן מחלקה מופשטת ושיטה מופשטת? קורה שבמהלך הפיתוח אתה רוצה שמחלקת בסיס תספק רק ממשק למחלקות הנגזרות שלה. כלומר, אתה לא רוצה שאף אחד יצור מופעים של מחלקת הבסיס. אתה צריך להשתמש בממשק בצורה כזו שאתה מטיל אליו רק אובייקטים (זהו קאסט מרומז שמאפשר התנהגות פולימורפית). זה מושג על ידי הפיכת מחלקה זו למופשטת באמצעות מילת המפתח abstract. זה מטיל כמה הגבלות, כגון חוסר היכולת ליצור מופעים של מחלקה מופשטת; כאשר משתמשים במחלקה מופשטת, יש צורך ליישם שיטות מופשטות. זה מבטיח פולימורפיזם. מחלקה מופשטת יכולה להכיל שיטות מופשטות וקונקרטיות כאחד. אם לפחות שיטה אחת במחלקה מוכרזת כמופשטת, יש להכריז גם על המחלקה כולה כמופשטת. עם זאת, אין צורך להקפיד על הכלל בכיוון ההפוך. אם מחלקה מוכרזת מופשטת, ייתכן שהיא לא תכיל שיטות מופשטות. שיטה שרק מגדירה את חתימותיה ואינה מספקת יישום נקראת אבסטרקטית. היישום בפועל שלו נותר לתת-מחלקות שלו, שמרחיבות את המחלקה המופשטת. אובייקט לא יכול להשתמש בשיטה מופשטת, רק מחלקה אחרת יכולה להרחיב אותה. מתי כדאי להשתמש בשיעור מופשט? מחלקות מופשטות מאפשרות לך להגדיר התנהגות ברירת מחדל מסוימת, ושתת מחלקות מספקות כל התנהגות ספציפית. לדוגמה: List(רשימה) הוא ממשק, בתורו AbstractListמגדיר את ההתנהגות הבסיסית של רשימה, שניתן להשתמש בה כפי שהיא או לזקק בתת-מחלקה, למשל, ב- ArrayList(מערך רשימה). מהו ממשק? הרעיון של ממשק הוא מחלקה מופשטת, אבל הממשק (מוגדר על ידי מילת המפתח interface) הולך צעד אחד קדימה. זה מונע כל יישום של שיטה או פונקציה בכלל. אתה יכול רק להצהיר על שיטה או פונקציה, אבל לא לספק את היישום שלה. המחלקה המיישמת את הממשק חייבת לדאוג לביצוע בפועל. ממשקים שימושיים מאוד ונמצאים בשימוש נרחב ב- OOP. מכיוון שהם חולקים את הממשק עצמו ואת היישום, הם מספקים יתרונות רבים לשימוש בהם:

1. ירושה מרובה .
2. צימוד רופף . יש הפשטה של ​​הפעולה, כמו שכבות, והיישום הקונקרטי יכול להיות כל דבר: JDBC, JPA, JTA וכו'.
3. תוכנית הממשק אינה מיושמת .
4. פולימורפיזם מחייב דינמי : ממשק התכנות של אובייקט נחשף מבלי לחשוף את היישום שלו בפועל.
5. רמות מופשטות , הפרדת פונקציונליות.

ההבדל בין ממשק למחלקה מופשטת.

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

הרכב

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

• בקרת נראות
• ניתן להחליף את המימוש בזמן הריצה
• צימוד רופף, מכיוון שמחלקת הממשק אינה תלויה ביישום.

הבדלים בין הרכב לירושה הערה: אל תשתמש בירושה רק כדי להבטיח שימוש חוזר בקוד. אם אין קשר "is a" (is), הרכב משמש למטרות אלו. ההבדל בין קומפוזיציה לצבירה הוא ביחסי אובייקט. צבירה היא מערכת יחסים שבה כיתה אחת מתאימה לאוסף. זהו חלק ממערכת יחסים שלמה, כאשר החלק יכול להתקיים ללא השלם. מערכות יחסים כאלה חלשות הרבה יותר. אין תלות מחזורית. לדוגמא: הזמנה ומוצר. קומפוזיציה היא מערכת יחסים שבה מחלקה אחת מתאימה לאוסף. זהו חלק ממערכת יחסים שלמה שבה החלק אינו יכול להתקיים ללא השלם. אם השלם ייהרס, גם כל מרכיביו יושמדו. זו מערכת יחסים חזקה יותר. לדוגמה: מצולע וקודקודיו, סדר ומרכיבו.