שיטות ב-Java

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

public String constructHelloSentence(String name) {
  String resultSentence = "Hello world! My name is " + name;
  System.out.println(resultSentence);
  return resultSentence;
}

אין כאן שום דבר מסובך: שיטת Java שהמשימה שלה היא ליצור מחרוזת ברכה עם השם שאנו מעבירים אליה. כמו למשל – Hello world! My name is Bobby בואו נבין בניית שיטה בצורה נכונה על ידי הסתכלות על כל מילת מפתח בהצהרת השיטה (משמאל לימין). מילת המפתח הראשונה שלנו היא public, והיא מציינת משנה גישה:

משנה גישה

הם מציינים את היקף הנראות המותר לחברי הכיתה, כלומר, הגבלת המקומות שבהם מותר להשתמש במשתנה או בשיטה. ב-Java נעשה שימוש בתקני הגישה הבאים:

• ציבורי : ציבורי. שיטות או שדות עם משנה זה הם ציבוריים, גלויים למחלקות אחרות (או ליתר דיוק, השיטות והשדות שלהן) מהחבילה הנוכחית ומחבילות חיצוניות. זוהי רמת הגישה הרחבה ביותר הידועה;

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

  protected String constructHelloSentence(String name) {...}

• משנה ברירת מחדל. אם לשדה או לשיטה של ​​מחלקה אין משנה, מוחל משנה ברירת המחדל. במקרה זה, השדות או המתודות גלויים לכל המחלקות בחבילה הנוכחית (כמו protected , אך ללא חשיפה בעת בירושה).

  String constructHelloSentence(String name) {...}

• פרטי : ההפך מהשינוי הציבורי . שיטה או משתנה עם משתנה כזה זמינים רק במחלקה שבה הוא מוצהר.

  private String constructHelloSentence(String name) {...}

בהמשך יש לנו Stringבחתימת השיטה (השורה הראשונה של השיטה המתארת ​​את תכונותיה).

ערך החזרה

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

שיטות החזר ערך

ערך זה יכול להיות כל סוג של נתונים: משתנה מסוג פשוט או סוג הפניה. בדוגמה זו אנו מציינים שהמתודה חייבת להחזיר אובייקט מסוג String, שכזכור הוא מחלקה שמתארת ​​מחרוזת. הנקודה השנייה כאן היא המילה return. יש לו קשר ישיר לערך ההחזרה: הערך שאחריו יישלח בחזרה למקום שבו נקראה השיטה, ואז השיטה עצמה תיסגר return. מילה זו מופיעה בדרך כלל בשורה האחרונה של השיטה (למעט שיטות עם ענפים שונים כמו if, else...). אם תכתוב את הקוד בשורה הבאה אחרי return:

private String constructHelloSentence(String name) {
  String resultSentence = "Hello world! My name is " + name;
  return resultSentence;
  System.out.println(resultSentence);
}

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

בָּטֵל

למה זה משמש voidבג'אווה? לא לכל השיטות יש ערך החזרה. לחלק אין כלום או שלא צריך להחזיר כלום. מה לעשות אז? ואז בחתימת השיטה אנו כותבים void. איך תיראה השיטה שלנו ללא ערך החזרה?

protected void constructHelloSentence(String name) {
  String resultSentence = "Hello world! My name is " + name;
  System.out.println(resultSentence);
}

בטח שמתם לב שיחד עם ערך ההחזרה, המילה returnSo it is נעלמה, כי השיטה שלנו לא אמורה להחזיר כלום. עם זאת, זה יכול להיות ממוקם כאן, אבל בלי שום משמעות, רק return; בשורה האחרונה. זה בדרך כלל חסר תועלת, אז voidזה אופציונלי בשיטות עם. עם זאת, ניתן להשתמש בו בצורה שימושית voidבשיטות, כגון ענפים או לולאות, שבהן ברצונך לצאת מהשיטה באופן מיידי. הבא בהצהרת השיטה שהייתה לנו constructHelloSentence.

שמות שיטות

constructHelloSentence - שם השיטה, תכונה ייחודית שבאמצעותה נוכל להבחין בשיטה כזו או אחרת. ובהתאם, קוראים לשיטה כזו או אחרת. שמות השיטה חייבים להתחיל באות קטנה, אך להשתמש גם במקרה של גמל (CamelCase, case camel): כלומר. כל מילה הבאה בשם צמודה לקודמת ונכתבת באות גדולה. שמות השיטה צריכים לתאר את השיטה (ההערה הטובה ביותר היא מתן שמות). לשם כך, השתמש בפעלים או בצירופים עם פעלים: getCat, delete, createCar, וכן הלאה. בתוך מחלקה אחת, שמות השיטה חייבים להיות ייחודיים (לא לספור עומס יתר של שיטות, עליו נדבר מעט מאוחר יותר). בואו נסתכל עוד על השיטה שאנו מנתחים ונראה ( String name)

פרמטרים של שיטה

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

public void constructHelloSentence(String...name) {
 ...
}

הפנייה לכל אלמנט תהיה כזו: name[0] האם זה מזכיר לך משהו? נכון, מערך! שום דבר לא ישתנה אם נכתוב:

protected void constructHelloSentence(String[] name) {
 ...
}

גם הגישה לאלמנטים תהיה בצורה: name[1] ועוד דבר. ארגומנטים של שיטה יכולים להיות סופיים :

public String constructHelloSentence(final String name) {
  ...
}

משמעות הדבר היא שהפניית השם קשורה לאובייקט ספציפי Stringולא ניתן לעקוף אותה. finalאתה יכול לקרוא על עבודה עם משתני התייחסות והאינטראקציה שלהם עם מילים שמורות בחומר " סוגי נתוני התייחסות ב-Java ".

שיטות התקשרות

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

public class StringConstructor {
  public String constructHelloSentence(String name) {
     String resultSentence = "Hello world! My name is " + name;
     System.out.println(resultSentence);
     return resultSentence;
  }
}

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

class Application{
  public static void main(String[] args) {
     StringConstructor stringConstructor = new StringConstructor();
     stringConstructor.constructHelloSentence("Den");
  }
}

בטיעונים של השיטה שלנו, העברנו את המחרוזת (שם) שאנו רוצים לראות במחרוזת המתקבלת המוצגת על המסך:

Hello world! My name is Den

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

זֶה

לעתים קרובות אתה יכול לראות את מילת המפתח בקוד this, כמו בהגדרות:

public void setValue(Long value) {
   this.value = value;
}

ומה זה אומר? thisב-Java, זוהי הפניה לאובייקט הנוכחי של מחלקה זו. לדוגמה, אם יצרנו אובייקט:

StringConstructor stringConstructor = new StringConstructor();

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

public class StringConstructor {

  public String constructHelloSentence(String name) {
     String resultSentence = this.getSentence()  + name;
     System.out.println(resultSentence);
     return resultSentence;
  }

  private String getSentence() {
     return "Hello world! My name is ";
  }
}

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

עומס יתר של שיטה

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

public class Constructor {

  public String constructHelloSentence(String name) {
     String resultSentence = "Hello world! My name is " + name;
     System.out.println(resultSentence);
     return resultSentence;
  }

  protected String constructHelloSentence(String firstName, String secondName) {
     String resultSentence = "Hello " + firstName + "! My name is " + secondName;
     System.out.println(resultSentence);
     return resultSentence;
  }
}

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