3 פרדיגמות התכנות העיקריות שכדאי להכיר

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

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

1. תכנות חובה

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

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

אחת השפות הפופולריות ביותר המשתמשות בפרדיגמת הציווי היא C. שפת תכנות זו תומכת רק בהליכי פונקציה.

דוגמה לתוכנית ציווית

#לִכלוֹל 
#לִכלוֹל 
struct לקוח
{
 int CustomerId;
 char OrderNumber[20];
 שם char[30];
 לצוף OrderTotal;
};
void main ()
{
 struct Customer John = {4000, "HK1001", "John Doe", 200.00};
 struct Customer Jane = {4001, "HK1002", "Jane Doe", 600.00};
memcpy (ג'יין. שם, "ג'יין ג'ונס", 10);





instagram viewer
printf ("העלות הכוללת עבור מספר הזמנה %s %s היא: $%.2f",Jane. שם, ג'יין. מספר הזמנה, ג'יין. סך כל ההזמנה);
}

תוכנית C לעיל יוצרת א צרכן מִבְנֶה. ה מבנה סוג הוא דוגמה מצוינת להפשטת נתונים ב-C.

התוכנית מדגימה כיצד פקודות יכולות ליצור, לעדכן ולהציג מצב - באמצעות ה ג'יין משתנה מבנה. כל הפקודות הללו נמצאות ב-a רָאשִׁי() function, שבסך הכל הוא נוהל הקובע כמה כסף לקוח צריך לשלם עבור הזמנה.

הפעלת התוכנית לעיל תפיק את הפלט הבא במסוף שלך:

העלות הכוללת עבור מספר הזמנה של ג'יין ג'ונס HK1002 היא: $600.00

2. תכנות מונחה עצמים

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

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

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

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

שלוש משפות התכנות הפופולריות יותר המשתמשות בפרדיגמה מונחה עצמים הן Java, C++ ו-Python.

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

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

הקובץ Discountable.java

פּוּמְבֵּימִמְשָׁק בהנחה {
פּוּמְבֵּיבָּטֵל grandTotal (מחרוזת orderNumber, לְהַכפִּיל סך הכל);
}

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

הקובץ Customer.java

פּוּמְבֵּימעמד צרכן מיישם בהנחה {
מוּגָןint מספר לקוח;
מוּגָן מחרוזת customerName;
מוּגָן מחרוזת customerCode;
פּוּמְבֵּי צרכן() {
זֶה.customerId = 0;
זֶה.customerName = "";
זֶה.customerCode = "";
 }
פּוּמְבֵּי צרכן(int customerId, String customerName, String customerCode) {
זֶה.customerId = מזהה לקוחות;
זֶה.customerName = שם הלקוח;
זֶה.customerCode = customerCode;
 }
פּוּמְבֵּיint getCustomerId() {
לַחֲזוֹר מספר לקוח;
 }
פּוּמְבֵּיבָּטֵל setCustomerId(int מספר לקוח) {
זֶה.customerId = מזהה לקוחות;
 }
פּוּמְבֵּי מחרוזת getCustomerName() {
לַחֲזוֹר שם לקוח;
 }
פּוּמְבֵּיבָּטֵל setCustomerName (String customerName) {
זֶה.customerName = שם הלקוח;
 }
פּוּמְבֵּי מחרוזת getCustomerCode() {
לַחֲזוֹר קוד לקוח;
 }
פּוּמְבֵּיבָּטֵל setCustomerCode (מחרוזת customerCode) {
זֶה.customerCode = customerCode;
 }
פּוּמְבֵּילְהַכפִּיל customerType (מחרוזת customerCode) {
לְהַכפִּיל הנחה = 0;
אם (customerCode.toLowerCase().equals("pre")) {
 הנחה = 0.10;
 } אַחֵראם (customerCode.toLowerCase().equals("gen")) {
 הנחה = 0.02;
 } אַחֵראם (customerCode.toLowerCase().equals("new")) {
 הנחה = 0.05; 
 }
לַחֲזוֹר הנחה; 
 }
@עקוף
פּוּמְבֵּיבָּטֵל grandTotal (מחרוזת orderNumber, לְהַכפִּיל סך הכל) {
לְהַכפִּיל discount = customerType (customerCode);
לְהַכפִּיל discountPercentage = סה"כ * הנחה;
לְהַכפִּיל finalTotal = total - discountPercentage;
מערכת.הַחוּצָה.println("עבור "+ getCustomerName() + " מספר סדר " + orderNumber + " הסכום הכולל הוא: $" + finalTotal);
 }
}

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

הקובץ NewCustomer.java

פּוּמְבֵּימעמד לקוח חדש משתרע צרכן {
פּוּמְבֵּי לקוח חדש() {
סוּפֶּר();
 }
פּוּמְבֵּי לקוח חדש(int customerId, String customerName, String customerCode) {
סוּפֶּר(CustomerId, customerName, customerCode);
 }
}

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

הקובץ App.java

פּוּמְבֵּימעמד אפליקציה {
פּוּמְבֵּיסטָטִיבָּטֵל main (String[] args) { 
 הלקוח ג'יין = חָדָשׁ NewCustomer (4001, "ג'יין ג'ונס", "חדש");
 Jane.grandTotal("HK1002", 600); 
 }
}

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

עבור מספר הזמנה של ג'יין ג'ונס HK1002 הסכום הכולל הוא: $570.0

3. תכנות פונקציונלי

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

JavaScript היא אחת משפות התכנות הפונקציונליות הפופולריות ביותר.

דוגמה לתוכנית פונקציונלית

const לקוח = {
 מספר זיהוי: 1002,
 שם: 'ג'יין ג'ונס',
 קוד לקוח: 'חדש'
}
const main = (לקוח, func, value) => {
 var total = func.apply (null, [ לקוח. CustomerCode, value ]);
 console.log(`${customer. Name} סך הכל הוא: ${total}`);
}
const grandTotal = (CustomerCode, total) => {
 if (CustomerCode == "חדש") {
 הנחה = סה"כ * 0.05;
 mainTotal = סה"כ - הנחה;
 החזר mainTotal;
 } else if (CustomerCode == "pre") {
 הנחה = סה"כ * 0.10;
 mainTotal = סה"כ - הנחה;
 החזר mainTotal;
 }
}
ראשי (לקוח, grandTotal, 600);

לתוכנית JavaScript למעלה יש אובייקט מילולי ושתי פונקציות. הוא מצהיר על כל אחת מהפונקציות כביטוי באמצעות ה פונקציית חץ JavaScript. ה רָאשִׁי() פונקציה היא פונקציה מסדר גבוה יותר. זה לוקח את סכום סופי פונקציה כאחד הארגומנטים שלה, ואז קורא לפונקציה הזו. זו גם דוגמה לפולימורפיזם פרמטרי.

ה סכום סופי() הפונקציה מכילה מספר ביטויים, וה- צרכןלְהִתְנַגֵד הוא דוגמה להפשטת נתונים. התוכנית למעלה מייצרת את הפלט הבא במסוף:

סך הכל של ג'יין ג'ונס הוא: $570

המורכבות של שפות תכנות

שפת תכנות עשויה לגלם את המושגים של פרדיגמת תכנות אחת, אבל זה לא אומר שהיא מוגבלת לפרדיגמה אחת. רבות משפות התכנות הפופולריות (כגון Python, Java, JavaScript ו-C++) הן שפות מרובות פרדיגמות.

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

תכנות מונחה עצמים לעומת תכנות פרוצדורלי: מה מייחד אותם?

קרא הבא

על הסופר