מבוא לתכונות בגרובי

1. סקירה כללית

במדריך זה נחקור את מושג התכונות בגרובי. הם הוצגו במהדורה גרובי 2.3.

2. מהן תכונות?

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

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

3. שיטות

הכרזת שיטה בא תְכוּנָה דומה להכריז על כל שיטה רגילה בשיעור. עם זאת, איננו יכולים להכריז על שיטות מוגנות או חבילות פרטיות ב- תְכוּנָה.

בואו נראה כיצד מיישמים שיטות ציבוריות ופרטיות.

3.1. שיטות ציבוריות

כדי להתחיל, נבדוק כיצד פּוּמְבֵּי השיטות מיושמות ב תְכוּנָה.

בואו ניצור תְכוּנָה נקרא UserTrait ו פּוּמְבֵּיתגיד שלום שיטה:

תכונה UserTrait {String sayHello () {להחזיר "שלום!" }}

לאחר מכן, ניצור עוֹבֵד כיתה, אשר מיישמת UserTrait:

בכיתה מיישם עובדים UserTrait {}

עכשיו, בואו ניצור בדיקה כדי לוודא ש- עוֹבֵד מופע יכול לגשת האמרה שלום שיטת ה- UserTrait:

def 'צריך להחזיר מחרוזת msg בעת שימוש בשיטת Employee.sayHello המסופקת על ידי תכונת המשתמש' () {כאשר: def msg = עובד.sayHello () ואז: msg msg מופע מחרוזת טענה msg == "שלום!" }

3.2. שיטות פרטיות

אנחנו יכולים גם ליצור פְּרָטִי שיטה בא תְכוּנָה ולהתייחס אליו באחר פּוּמְבֵּי שיטה.

בואו נראה את יישום הקוד ב- UserTrait:

private String greetingMessage () {return 'שלום, משיטה פרטית!' } שלום מחרוזת () {def msg = greetingMessage () println msg return msg} 

שים לב שאם ניגש ל- פְּרָטִי השיטה בכיתת היישום, היא תזרוק א MissingMethodException:

def 'אמור להחזיר את MissingMethodException בעת שימוש בשיטת Employee.greetingMessage' () {when: def exception נסה {employee.greetingMessage ()} לתפוס (Exception e) {exception = e} ואז: exception exception exception of groovy.lang.MissingMethodException assert exception. הודעה == "אין חתימה על השיטה: com.baeldung.traits.Employee.greetingMessage ()" + "חל על סוגי ארגומנטים: () ערכים: []"}

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

3.3. שיטות מופשטות

א תְכוּנָה יכול להכיל גם תַקצִיר שיטות שניתן ליישם לאחר מכן בכיתה אחרת:

תכונה UserTrait {תקציר שם מחרוזת () מחרוזת showName () {להחזיר "שלום, $ {name ()}!" }}
מחלקה עובד מיישם את UserTrait {שם מחרוזת () {להחזיר 'בוב'}} 

3.4. עקיפת שיטות ברירת מחדל

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

תכונה SpeakingTrait {String speak () {חזרה "מדבר !!" }} 
בכיתה מיישמת כלבים SpeakingTrait {String speak () {להחזיר "Bow Bow !!" }} 

תכונות אינן תומכות מוּגָן ו פְּרָטִי טווחים.

4. זֶה מילת מפתח

ההתנהגות של זֶה מילת המפתח דומה לזו ב- Java. אנחנו יכולים לשקול את תְכוּנָה כ סוּפֶּר מעמד.

למשל, ניצור שיטה שתחזור זֶה ב תְכוּנָה:

תכונה UserTrait {def self () {להחזיר את זה}}

5. ממשקים

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

בואו ניצור מִמְשָׁק וליישם אותו בא תְכוּנָה:

ממשק אנושי {שם אחרון מחרוזת ()}
תכונה UserTrait מיישמת אנושיים {String showLastName () {return "שלום, $ {lastName ()}!" }}

עכשיו, בוא נבצע את תַקצִיר שיטת ה- מִמְשָׁק בשיעור היישום:

מחלקה עובד מיישם את UserTrait {String lastName () {להחזיר "מארלי"}}

6. נכסים

אנו יכולים להוסיף מאפיינים ל- a תְכוּנָה בדיוק כמו שהיינו עושים בכל שיעור רגיל:

תכונה UserTrait מיישמת אנושי {מחרוזת דוא"ל מחרוזת כתובת}

7. הארכת תכונות

דומה לגרובי רגיל מעמד, א תְכוּנָה עשוי להאריך אחר תְכוּנָה משתמש ב מרחיב מילת מפתח:

תכונה WheelTrait {int noOfWheels} תכונה VehicleTrait מרחיבה WheelTrait {String showWheels () {return "Num of Wheels $ noOfWheels"}} מחלקה לרכב מיישמת VehicleTrait {}

אנו יכולים גם להרחיב תכונות מרובות עם ה- מכשירים סָעִיף:

תכונה AddressTrait {String residentialAddress} תכונה EmailTrait {מחרוזת דוא"ל} תכונה האדם מיישם את AddressTrait, EmailTrait {}

8. סכסוכי ירושה מרובים

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

8.1. ברירת מחדל לפתרון סכסוכים

כברירת מחדל, השיטה מההצהרה האחרונה תְכוּנָה בתוך ה מכשירים סעיף יאסוף.

לכן, תכונות עוזרות לנו ליישם ירושות מרובות מבלי להיתקל בבעיית היהלום.

ראשית, בואו ניצור שתי תכונות בשיטה בעלת אותה חתימה:

תכונה WalkingTrait {String basicAbility () {להחזיר "הליכה !!" }} תכונה SpeakingTrait {String basicAbility () {החזר "מדבר !!" }} 

לאחר מכן, בוא נכתוב כיתה שמיישמת את שתי התכונות:

בכיתה מיישמת כלבים WalkingTrait, SpeakingTrait {} 

כי SpeakingTrait מוכרז אחרון, שלו יכולת בסיסית יישום השיטה ייאסף כברירת מחדל ב כֶּלֶב מעמד.

8.2. פתרון סכסוכים מפורש

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

לדוגמא, בואו נוסיף שיטה נוספת עם אותה חתימה לשתי התכונות שלנו:

מחרוזת speakAndWalk () {לחזור "לך ותדבר !!" }
מחרוזת speakAndWalk () {לחזור "דבר והלך !!" }

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

בכיתה מיישמת כלבים את WalkingTrait, SpeakingTrait {String speakAndWalk () {WalkingTrait.super.speakAndWalk ()}}

9. יישום תכונות בזמן ריצה

ליישום א תְכוּנָה באופן דינמי, אנחנו יכולים להשתמש ב כפי ש מילת מפתח לכפות אובייקט ל- a תְכוּנָה בזמן ריצה.

למשל, בואו ניצור AnimalTrait עם ה התנהגות בסיסית שיטה:

תכונה AnimalTrait {String basicBehavior () {return "Animalistic !!" }}

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

def dog = כלב חדש () def dogWithTrait = dog.withTraits SpeakingTrait, WalkingTrait, AnimalTrait

10. מסקנה

במאמר זה ראינו כיצד ליצור תכונות ב- Groovy וחקרנו כמה מהתכונות השימושיות שלהם.

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

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


$config[zx-auto] not found$config[zx-overlay] not found