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

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

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

אנקפסולציה בחלודה

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

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

שימוש במודולים כדי לכלול נתונים ופונקציות

אתה יכול להגדיר מודול באמצעות mod מילת מפתח ואחריה שם:

mod my_module {
// פריטי מודול עוברים לכאן
}

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

mod parent_module {
mod my_module {
// פריטי מודול עוברים לכאן
 }
}

לאחר מכן תוכל להתייחס למודולים מקוננים עם ההיררכיה המלאה, להפריד כל מודול עם נקודתיים כפולה, למשל, parent_module:: my_module.

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

mod my_module {
פָּאבּfnשלי_פונקציה() {
// גוף הפונקציה נכנס לכאן
 }
}

לאחר מכן תוכל לגשת שלי_פונקציה מחלקים אחרים של התוכנית שלך.

שימוש בתכונות להגדרת התנהגויות

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

פָּאבּתְכוּנָהניתן להדפסה {
fnהדפס(&עצמי);
}
פָּאבּstructMyType {
// שדות struct כאן
}
impl ניתן להדפסה ל MyType {
fnהדפס(&עצמי) {
// יישום כאן
 }
}

ה ניתן להדפסה לתכונה יש א הדפס השיטה, ואת MyType struct מיישם את ניתן להדפסה תכונה על ידי יישום ה הדפס שיטה.

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

ירושה בחלודה

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

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

יצירת סוגים חדשים על ידי שילוב סוגים קיימים

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

אתה יכול ליצור סוג מנה לסוגים שונים של בעלי חיים.

enumבעל חיים {
 חתול,
 כֶּלֶב,
 ציפור,
// ...
}

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

structבעל חיים {
 שֵׁם: חוּט,
 גיל: u8,
 animal_type: AnimalType,
}
enumAnimalType {
 חתול,
 כֶּלֶב,
 ציפור,
// ...
}

ה בעל חיים struct מחזיק ערכים של AnimalType סוג ספירה.

אתה יכול להשתמש בתכונות כדי ליישם ירושה ולהוסיף התנהגות לסוג מבלי ליצור אחד חדש.

תְכוּנָהלטוס, זבוב {
fnלטוס, זבוב(&עצמי);
}

הנה איך אתה יכול ליישם את לטוס, זבוב תכונה למספר סוגים.

structציפור {
 שֵׁם: חוּט,
 מוּטַת כְּנָפַים: f32,
}
impl לטוס, זבוב ל ציפור {
fnלטוס, זבוב(&עצמי) {
println!("{} עף!", עצמי.שֵׁם);
 }
}
structמָטוֹס {
 דֶגֶם: חוּט,
 מהירות מקסימלית: u32,
}
impl לטוס, זבוב ל מטוס {
fnלטוס, זבוב(&עצמי) {
println!("{} עף!", עצמי.דֶגֶם);
 }
}

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

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

fnרָאשִׁי() {
לתת ציפור = ציפור {
 שֵׁם: חוּט::מ("נשר"),
 מוּטַת כְּנָפַים: 2.0,
 };
לתת מטוס = מטוס {
 דֶגֶם: חוּט::מ("בואינג 747"),
 מהירות מקסימלית: 900,
 };
לתת חפצים_מעופפים: Vecdyn לעוף> = vec![&ציפור, &מטוס];
ל לְהִתְנַגֵד ב flying_objects {
 object.fly();
 }
}

ה רָאשִׁי הפונקציה מדגימה את מָטוֹס ו ציפור סוגים. ה חפצים_מעופפים וקטור הוא וקטור של מופעי האובייקט, וה- ל לולאה חוצה את הווקטור וקוראת ל- לטוס, זבוב שיטה על המקרים.

יישום פולימורפיזם בחלודה

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

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

תְכוּנָהניתן לציור {
fnלצייר(&עצמי);
}

סוגים שמיישמים את התכונה Drawable יכולים לגשת ל- לצייר פוּנקצִיָה.

structמַלבֵּן {
 רוֹחַב: u32,
 גוֹבַה: u32,
}
impl ניתן לציור ל מלבן {
fnלצייר(&עצמי) {
// עיבוד המלבן על המסך
 }
}

אתה יכול לכתוב קוד גנרי שמצייר אובייקטים שמיישמים את ניתן לציור תְכוּנָה.

fndraw_object(אובייקט: &T) {
 object.draw();
}

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

יישום הפשטה בחלודה

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

להלן תכונה לדוגמה עבור נגן מדיה:

תְכוּנָהכְּלֵי תִקְשׁוֹרֶת {
fnלְשַׂחֵק(&עצמי);
}

מבנים ומונים המיישמים את כְּלֵי תִקְשׁוֹרֶת תכונה חייבת לספק יישום עבור לְשַׂחֵק שיטה.

structשִׁיר {
 כותרת: חוּט,
 אמן: חוּט,
}
impl כְּלֵי תִקְשׁוֹרֶת ל שיר {
fnלְשַׂחֵק(&עצמי) {
println!("מנגן שיר: {} מאת {}", עצמי.כותרת, עצמי.אמן);
 }
}

ה שִׁיר struct מיישם את כְּלֵי תִקְשׁוֹרֶת תכונה על ידי מתן יישום עבור לְשַׂחֵק שיטה שמדפיסה הודעה עם השדות של שִׁיר מבנים לקונסולה.

fnרָאשִׁי() {
// צור מופע של מבנה השיר
לתת שיר = שיר {
 כותרת: חוּט::מ("רפסודיה בוהמית"),
 אמן: חוּט::מ("מַלכָּה"),
 };
// קרא לשיטת ההפעלה במופע השיר
 song.play();
}

ה שִׁיר משתנה הוא מופע של ה שִׁיר struct, והמשתנה יכול לגשת ולקרוא ל- לְשַׂחֵק שיטה.

ארגון קוד חלודה קל

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