streamalism.org

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

ב- refactoring.com אנו קוראים כי "refactoring היא טכניקה ממושמעת לבנייה מחדש של גוף קוד קיים, ולשנות את המבנה הפנימי שלו מבלי לשנות את התנהגותו החיצונית."

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

במדריך זה נתמקד בשחזור ב- Eclipse, Java IDE פופולרי בחינם.

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

2. שינוי שם

2.1. שינוי שם של משתנים ושיטות

אנחנו יכולים שנה שם של משתנים ושיטות על ידי ביצוע השלבים הפשוטים הבאים:

• • בחר באלמנט
  • לחץ לחיצה ימנית על האלמנט
  • לחץ על רפקטור> שנה שם אוֹפְּצִיָה

• הקלד את השם החדש
• ללחוץ להיכנס

אנחנו יכולים גם לבצע את הצעד השני והשלישי עד באמצעות מקש הקיצור, Alt + Shift + R..

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

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

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

2.2. שינוי שם חבילות

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

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

2.3. שינוי שם של כיתות וממשקים

אנו יכולים לשנות שם של מחלקה או ממשק באמצעות אותן פעולות או פשוט על ידי לחיצה F2 מ- Project Explorer. פעולה זו תפתח חלון קופץ עם אפשרויות לעדכון הפניות, יחד עם כמה אפשרויות מתקדמות:

3. חילוץ

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

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

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

3.1. כיתת תמצית

נניח שיש לנו את הדברים הבאים אוטו בכיתה בבסיס הקוד שלנו:

רכב ברמה ציבורית {רישיון מחרוזת פרטי Plate; פרטי מחרוזת driverName; נהג מחרוזת פרטי רישיון; מחרוזת ציבורית getDetails () {return "Car [licensPlate =" + licensPlate + ", driverName =" + driverName + ", driverLicense =" + driverLicense + "]"; } // גטרים וקובעים}

עכשיו, נניח שאנחנו רוצים לחלץ את פרטי הנהג למחלקה אחרת. אנחנו יכולים לעשות זאת על ידי לחיצה ימנית בכל מקום בכיתה ובחירת ה- רפקטור> מחלקת תמציות אוֹפְּצִיָה:

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

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

רכב בכיתה ציבורית {רישיון מחרוזת פרטי Plate; נהג נהג פרטי = נהג חדש (); מחרוזת ציבורית getDetails () {return "Car [licensPlate =" + licensePlate + ", driverName =" + driver.getDriverName () + ", driverLicense =" + driver.getDriverLicense () + "]"; } // גטרים וקובעים}

3.2. ממשק חילוץ

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

מעמד ציבורי EmployeeService {public void save (עובד שכיר) {} מחיקה של חלל ציבורי (עובד עובד) {} public ריק ריק sendEmail (מזהי רשימה, הודעת מחרוזת) {}}

אנחנו יכולים לחלץ ממשק על ידי לחיצה ימנית בכל מקום בכיתה ובחירת ה- Refactor> חילוץ ממשק אוֹפְּצִיָה, או שאנחנו יכולים להשתמש ב- Alt + Shift + T פקודת מקש קיצור כדי להעלות את התפריט ישירות:

זה יפתח חלון קופץ שבו נוכל להזין את שם הממשק ולהחליט אילו חברים להכריז בממשק:

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

מחלקה ציבורית EmployeeService מיישמת את IEmpService {@Override public void save (Employee Emp) {} @Override public void delete (Employe emp) {} public void sendEmail (List IDs, String message) {}}

3.3. חלץ Superclass

נניח שיש לנו עוֹבֵד מחלקה המכילה מספר נכסים שאינם בהכרח עוסקים בעבודתו של האדם:

שכבה ציבורית עובד {שם מחרוזת פרטי; גיל פרטי פרטי; חוויית אינטראקציה פרטיתInMonths; ציבורי מחרוזת getName () {השבת שם; } int getAge public () {גיל להחזיר; } public int getExperienceInMonths () {return experienceInMonths; }}

אולי נרצה לחלץ את הנכסים שאינם קשורים לתעסוקה ל- a אדם מעמד-על. כדי לחלץ פריטים למעמד-על, אנחנו יכולים לחץ באמצעות לחצן העכבר הימני בכל מקום בכיתה ובחר באפשרות רפקטור> חילוץ סופר קלאס אפשרות, או השתמש Alt + Shift + T להעלות את התפריט ישירות:

זה ייצור חדש אדם בכיתה עם המשתנים והשיטה שבחרנו, וה- עוֹבֵד הכיתה תשוב ל:

מעמד ציבורי עובד מרחיב את האדם {experience int intimeInMonths; public int getExperienceInMonths () {return experienceInMonths; }}

3.4. שיטת חלץ

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

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

מבחן מחלקה ציבורית {main public static void main (String [] args) {for (int i = 0; i <args.length; i ++) {System.out.println (args [i]); }}}

להפעיל את שיטת חלץ אשף, עלינו לבצע את השלבים הבאים:

• בחר את שורות הקוד שאנו רוצים לחלץ
• לחץ לחיצה ימנית על האזור שנבחר
• לחץ על רפקטור> שיטת חילוץ אוֹפְּצִיָה

ניתן להשיג את שני השלבים האחרונים גם באמצעות קיצור מקשים Alt + Shift + M. בוא נראה את שיטת חלץ שיח:

זה ישקף את הקוד שלנו ל:

מבחן בכיתה ציבורית {public static void main (String [] args) {printArgs (args); } printArgs סטטי פרטי ריק (מחרוזת [] args) {עבור (int i = 0; i <args.length; i ++) {System.out.println (args [i]); }}}

3.5. חלץ משתנים מקומיים

אנו יכולים לחלץ פריטים מסוימים כמשתנים מקומיים כדי להפוך את הקוד שלנו לקריא יותר.

זה שימושי כשיש לנו חוּט מילולי:

מבחן מחלקה ציבורית {public static void main (String [] args) {System.out.println ("מספר הארגומנטים שהועברו" src = "// www.baeldung.com/wp-content/uploads/2019/06/Eclipse- refactor-21.png ">
ניתן להשיג את הצעד האחרון באמצעות קיצור המקשים Alt + Shift + L.. כעת אנו יכולים לחלץ את המשתנה המקומי שלנו:
והנה התוצאה של רפקטורציה זו:
מבחן בכיתה ציבורית {ציבורי ריק סטטי ראשי (מחרוזת [] טענות) {קידומת מחרוזת סופית = "מספר הארגומנטים שעברו קבצי חילוץ"> 3.6. חלץ קבוע
לחלופין, אנו יכולים לחלץ ביטויים וערכים מילוליים ל גמר סטטי תכונות כיתתיות.
נוכל לחלץ את 3.14 ערך למשתנה מקומי, כפי שראינו זה עתה:
מעמד ציבורי MathUtil {היקף כפול ציבורי (רדיוס כפול) {החזר 2 * 3.14 * רדיוס; }}
אבל, אולי עדיף לחלץ אותו כקבוע, שעליו אנו צריכים:
בחר את הפריט
לחץ לחיצה ימנית ובחר רפקטור> חילוץ קבוע
זה יפתח דו-שיח שבו נוכל לתת שם לקבוע ולהגדיר את נראותו, יחד עם כמה אפשרויות אחרות:
כעת, הקוד שלנו נראה קצת יותר קריא:
כיתה ציבורית MathUtil {גמר סטטי פרטי כפול PI = 3.14; היקף כפול ציבורי (רדיוס כפול) {החזר רדיוס 2 * PI *; }}
4. שיבוץ
אנחנו יכולים גם ללכת בדרך אחרת ולקוד קוד מוטבע.
שקול א Util מחלקה הכוללת משתנה מקומי המשמש רק פעם אחת:
מחלקה ציבורית עד {חלל ציבורי isNumberPrime (int num) {תוצאה בוליאנית = isPrime (num); אם (תוצאה) {System.out.println ("המספר הוא ראשוני"); } אחר {System.out.println ("המספר אינו ראשוני"); }} // שיטת isPrime} 
אנחנו רוצים להסיר את תוֹצָאָה משתנה מקומי ומובנה isPrime שיחת שיטה. לשם כך, אנו מבצעים את השלבים הבאים:
בחר את הפריט שברצוננו להטמיע
לחץ לחיצה ימנית ו בחר את רפקטור> מוטבע אוֹפְּצִיָה
ניתן להשיג את הצעד האחרון באמצעות קיצור מקשים Alt + Shift + I:
לאחר מכן, יש לנו משתנה אחד פחות לעקוב אחרי:
class public Util {public void isNumberPrime (int num) {if (isPrime (num)) {System.out.println ("המספר הוא ראשוני"); } אחר {System.out.println ("המספר אינו ראשוני"); }} // שיטת isPrime}
5. לחץ כלפי מטה ומשוך למעלה
אם יש לנו יחסי הורים וילדים (כמו הקודמים שלנו עוֹבֵד ו אדם לדוגמא) בין הכיתות שלנו, ואנחנו רוצים להעביר שיטות מסוימות או משתנים ביניהן, אנו יכולים להשתמש באפשרויות הדחיפה / משיכה המסופקות על ידי Eclipse.
כפי שהשם מרמז, לדחוף למטה אפשרות מעבירה שיטות ושדות מכיתת הורים לכל כיתות הילדים, תוך כדי לַעֲקוֹר מעביר שיטות ושדות מכיתת ילדים מסוימת להורה, ובכך מעמיד שיטה זו לרשות כל כיתות הילדים.
בשביל להעביר שיטות לשיעורי ילדים, אנחנו צריכים לחץ לחיצה ימנית בכל מקום בכיתה ובחר את רפקטור> לדחוף מטה אוֹפְּצִיָה:
פעולה זו תפתח אשף שבו נוכל לבחור פריטים לדחיפה כלפי מטה:
באופן דומה, כדי להעביר שיטות מכיתת ילדים לכיתת הורים, עלינו לעשות זאת לחץ לחיצה ימנית בכל מקום בכיתה ובחר רפקטור> משוך למעלה:
פעולה זו תפתח אשף דומה בו נוכל לבחור פריטים להשלים:
6. שינוי חתימת שיטה
כדי לשנות את חתימת השיטה של ​​שיטה קיימת, נוכל לבצע כמה צעדים פשוטים:
בחר את השיטה או הצב את הסמן איפשהו בפנים
לחץ לחיצה ימנית ובחר רפקטור> שינוי חתימת שיטה
את השלב האחרון ניתן להשיג גם באמצעות קיצור מקשים Alt + Shift + C.
פעולה זו תפתח חלון קופץ שבו תוכל לשנות את חתימת השיטה בהתאם:
7. עוברים דירה
לפעמים, אנחנו פשוט רוצים העבר שיטות למחלקה קיימת אחרת כדי להפוך את הקוד שלנו לממוקד אובייקטים יותר.
שקול את התרחיש שבו יש לנו סרט מעמד:
סרט בכיתה ציבורית {כותרת מחרוזת פרטית; מחיר כפול פרטי; סוג MovieType פרטי; // שיטות אחרות}
וגם סוג הסרט הוא enum פשוט:
סרט enum ציבורי {NEW, REGULAR}
נניח גם שיש לנו דרישה שאם א צרכן שוכר סרט שהוא חָדָשׁ, זה יחויב בשני דולרים נוספים, וזה שלנו צרכן בכיתה יש את ההיגיון הבא כדי לחשב את עלות כוללת():
לקוח ממעמד ציבורי {שם מחרוזת פרטי; כתובת מחרוזת פרטית; סרטי רשימה פרטיים; total doubleCost פומבית () {תוצאה כפולה = 0; עבור (סרט סרט: סרטים) {תוצאה + = movieCost (סרט); } להחזיר תוצאה; } סרט כפול פרטי (סרט סרט) {if (movie.getType () .equals (MovieType.NEW)) {return 2 + movie.getPrice (); } להחזיר movie.getPrice (); } // שיטות אחרות}
ברור שחישוב עלות הסרט מבוסס על סוג הסרט יהיה ממוקם בצורה נכונה יותר ב סרט כיתה ולא צרכן מעמד. אנו יכולים להזיז את לוגיקת החישוב הזו בקלות בליקוי החמה:
בחר את השורות שברצונך להעביר
לחץ לחיצה ימנית ובחר את רפקטור> זז אוֹפְּצִיָה
ניתן להשיג את הצעד האחרון באמצעות קיצור מקשים Alt + Shift + V.:
הליקוי חכם מספיק בכדי להבין שההיגיון הזה צריך להיות שלנו סרט מעמד. אנו יכולים לשנות את שם השיטה אם נרצה, יחד עם אפשרויות מתקדמות אחרות.
הגמר צרכן קוד הכיתה ישוחזר ל:
לקוח ממעמד ציבורי {שם מחרוזת פרטי; כתובת מחרוזת פרטית; סרטי רשימה פרטיים; total doubleCost פומבית () {תוצאה כפולה = 0; עבור (סרט סרט: סרטים) {result + = movie.movieCost (); } להחזיר תוצאה; } // שיטות אחרות}
כפי שאנו רואים, movieCost השיטה הועברה שלנו סרט בשיעור ומשתמשים בו מחדש צרכן מעמד.
8. מסקנה
במדריך זה בדקנו כמה מהטכניקות העיקריות לשחזור של Eclipse. התחלנו עם כמה שיפורים בסיסיים כמו שינוי שם וחילוץ. בהמשך ראינו שיטות הובלה ושדות סביב כיתות שונות.
למידע נוסף, אנו תמיד יכולים להתייחס לתיעוד הרשמי של Eclipse בנושא refactoring.