האם אתה יכול להסביר את ההבדל בין תכנות פרוצדורלית ל- OOP?


תשובה 1:

שאלה מקורית:

האם אתה יכול להסביר את ההבדל בין תכנות פרוצדורלית ל- OOP?

תשובה:

ראשית, ראשית, בואו נגדיר מה המשמעות של תכנות פרוצדורלית ומכוונת עצמים.

הגדרה - מה המשמעות של שפה פרוצדוראלית? שפה פרוצדורלית היא סוג של שפת תכנות מחשבים המגדירה סדרה של צעדים ונהלים מובנים היטב בהקשר התכנות שלה לצורך הכנת תוכנית. הוא מכיל סדר שיטתי של הצהרות, פונקציות ופקודות להשלמת משימה או תוכנית חישובית. שפת פרוצדורציה ידועה גם כשפה חובה. טקופדיה מסבירה שפה פרוצדוראלית שפה פרוצדורלית, כפי שהשם מרמז, מסתמכת על נהלים מוגדרים מראש ומסודרים היטב, פונקציות או שגרות משנה בארכיטקטורה של תוכנית על ידי ציון כל הצעדים שעל המחשב לנקוט כדי להגיע למצב או תפוקה מבוקשים. השפה הפרוצדורלית מפרידה תוכנית בין משתנים, פונקציות, הצהרות ומפעילים מותנים. נהלים או פונקציות מיושמים על הנתונים והמשתנים לביצוע משימה. ניתן לכנות / להפעיל נהלים אלה בכל מקום בין היררכיית התוכנית, וכן על ידי נהלים אחרים. תוכנית הכתובה בשפה פרוצדורלית מכילה נוהל אחד או יותר. שפת תהליכים היא אחד הסוגים השכיחים ביותר של שפות תכנות בשימוש, עם שפות בולטות כמו C / C ++, Java, ColdFusion ו- PASCAL.

כעת, בואו נגדיר תכנות מונחה עצמים.

הגדרה - מה המשמעות של תכנות מונחה עצמים (OOP) - תכנות מונחה עצמים (OOP) היא מודל תכנות תוכנה הבנוי סביב אובייקטים. מודל זה ממחל נתונים לאובייקטים (שדות נתונים) ומתאר את תוכן האובייקט ואת התנהגותו באמצעות הצהרת מחלקות (שיטות). תכונות OOP כוללות את הדברים הבאים: אנקפסולציה: פעולה זו מקלה על ניהול תכנית האובייקטים מכיוון שהיישום והמצב של כל אובייקט מוסתרים מאחור גבולות מוגדרים היטב. פולימורפיזם: משמעות הדבר היא שישויות מופשטות מיושמות בדרכים מרובות. ירושה: הכוונה לסידור ההיררכי של שברי יישום. תכנות מונחה-תכלית מאפשרת תכנות מפושטת. היתרונות שלה כוללים שימוש חוזר, שיבוץ מחדש, הרחבה, תחזוקה ויעילות. טקופדיה מסביר את תכנות מונחה עצמים (OOP) OOP היה מודל התכנות שנבחר מבחינתו בעשור האחרון או יותר. התכנון המודולרי של OOP מאפשר למתכנתים לבנות תוכנה בגזירות הניתנות לניהול ולא בכמויות גדולות של קוד רצף. אחד היתרונות הגדולים של OOP הוא זה של מדרגיות, עם אובייקטים והגדרות ללא הגבלה סופית. כמו כן, הפרדת נתונים משיטה מונעת בעיה נפוצה שנמצאת בשפות תוכנה לינאריות ישנות. אם באג מופיע בקוד לינארי, ניתן לתרגם אותו באמצעות מערכת וליצור המוני שגיאות קשות להתחקות. לעומת זאת, תוכנית OOP, עם הפרדת השיטה והנתונים שלה, אינה חשופה לטעויות כה מורחבות. שפות OOP פופוליות כוללות Java, משפחת C של השפות, VB.NET Shop ו- Python. שנקרא שפות OOP טהורות. כוללים סקאלה, רובי, אייפל, JADE, סמלטלק ואמרלד.

מקור ההגדרות מקורו של מהי תכנות מונחה עצמים (OOP)? - הגדרה מ- Techopedia ומהי שפה פרוצדוראלית? - הגדרה מ- Techopedia

עכשיו. בואו נסתכל על ההבדל ביישום ההבדל.

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

החלטתי להשתמש במדריך האור הבהוב כבסיס מכיוון שהוא אחד היישומים הבסיסיים.

// פונקציית ההגדרה פועלת פעם אחת כאשר אתה לוחץ על איפוס או מפעיל את הגדרת הריק של לוח () {// אתחול פין דיגיטלי LED_BUILTIN כפלט. pinMode (LED_BUILTIN, OUTPUT); } // פונקציית הלולאה פועלת שוב ושוב לולאה בטלה לנצח () {digitalWrite (LED_BUILTIN, HIGH); // הפעל את הנורית (HIGH הוא רמת המתח) עיכוב (1000); // המתן ל- DigitalWrite שני (LED_BUILTIN, LOW); // כבה את הנורה על ידי ביצוע עיכוב נמוך במתח (1000); // חכה לרגע}

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

זמן לדוגמא C # ו- OOP.

באמצעות מערכת; באמצעות System.Collections.Generic; באמצעות System.Linq; באמצעות מערכת. טקסט; מרחב השמות אופס {לקוח בכיתה ציבורית {// משתני חבר ציבורי ב- CustID; מחרוזת ציבורית שם; מחרוזת ציבורית כתובת; // קונסטרוקטור לאתחול שדות לקוח () {CustID = 1101; שם = "טום"; כתובת = "ארה"ב"; } // שיטה להצגת רשומות לקוח (פונקציונליות) displayData לציבור ריק () {Console.WriteLine ("לקוח =" + CustID); Console.WriteLine ("שם =" + שם); Console.WriteLine ("כתובת =" + כתובת); } // קוד לנקודת כניסה}} תוכנית מחלקה {static void ראשי (מחרוזת [] args) {// objectiation client הלקוח obj = לקוח חדש (); // שיטה להתקשר obj.displayData (); // שדות המתקשרים ל- Console.WriteLine (obj.CustID); Console.WriteLine (obj.Name); Console.WriteLine (obj.Adress); }}}

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


תשובה 2:

OOPS קונספט בג'אווה

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


תשובה 3:

תכנות פרוצדורלית היא תכנות עם נהלים כמנגנון ההפשטה העיקרי. הא.

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

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

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

if (תנאי) {doThisThing ()} else {doThatThing ()}

ו

בזמן (תנאי) {keepOnDoingThisThing ()}

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

בחירת אלטרנטיבות

  • אם כן (שתי אפשרויות, מבוססות על בוליאני) מקרה או מתג (אפשרויות רבות, בהתבסס על כל קבוצה)

חזרה

עם גבולות ידועים:

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

עם גבולות אד-הוק:

  • בזמן לעשות (0 איטרציות או יותר) לעשות בזמן (1 איטרציות או יותר)

והלא פופולרי לצערנו:

  • לולאת יציאה

שמבצע את הקוד לפני היציאה לפחות פעם אחת, ואת הקוד אחרי היציאה אפס או יותר פעמים.

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

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

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

תכנות מונחה עצמים היא תכנות עם אובייקטים כמנגנון ההפשטה העיקרי. הא.

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

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

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

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

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

foreach (theThing in aollection) doThisaction on (theThing)

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

aCollection do: [aThing | פעולה מהירה].

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

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

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