שיטות Java

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

מהן שיטות ב-Java?

שיטות מגדירות את ההתנהגות של אובייקטים והן רצף של פקודות המאפשר לבצע פעולה כלשהי בתוכנית. בשפות תכנות אחרות, שיטות מכונה לעתים קרובות "פונקציות", ובצדק. למעשה, שיטה היא פונקציה במובן המתמטי. בדרך כלל מסופק משהו לקלט של השיטה (חלק מהמשתנים), משתנים אלו מעובדים על ידי רצף של פקודות, ואז השיטה מייצרת תוצאה. רוב הסיכויים שכבר נתקלת בשיטות, לפחות עם public static void main(String[] args) . שיטה זו מתחילה בדרך כלל את ההפעלה של תוכנית Java.

כיצד להכריז על שיטות ב-Java?

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

accessSpecifier ReturnType name (parameter list) {
//method body
}

לדוגמה:

public int addTwoNumbers (int a, int b){

//method body
return…
}

כאשר public הוא מפרט גישה, int הוא סוג של משתנה שהשיטה מחזירה, addTwoNumbers הוא שם השיטה, a ו- b הם הפרמטרים של השיטה. בואו נסתכל קצת יותר בפירוט. מפרט הגישה משמש להגדרת סוג הגישה של השיטה. הם יכולים להיות כדלקמן:

• public : גישה לשיטה זמינה מכל מחלקה.

• פרטי : גישה זמינה בתוך המחלקה שבה היא הוגדרה.

• מוגן : הגישה זמינה רק בתוך החבילה או תת-מחלקות אחרות בחבילה אחרת.

• ברירת מחדל : גישה זמינה מהחבילה שבה היא מוצהרת. במקרה זה, המילה "ברירת מחדל" אינה כתובה.

סוג החזרה מגדיר את הסוג ששיטה זו מחזירה. בדוגמה שלמעלה, int הוא סוג ההחזרה. אם שיטה לא מחזירה כלום, סוג ההחזרה בטל:

public void printSomething (String myString) {}

שם השיטה הוא שם ייחודי של השיטה שלך. אנחנו הולכים להסביר כמה כללי שמות של Java קצת מאוחר יותר במאמר זה. בשיטות שלמעלה השמות הם addTwoNumbers ו- printSomething . רשימת הפרמטרים היא רשימת הארגומנטים (סוג הנתונים ושם המשתנה) שהמתודה לוקחת. בדוגמה הראשונה למעלה, "int a, int b" הם פרמטרים, בשנייה, String myString הוא ארגומנט. אתה יכול גם להשאיר שדה זה ריק אם אינך רוצה להשתמש בפרמטרים כלשהם בשיטה.

דוגמה לפרמטרים של שיטה

public void printSomething (String myParameter1, int myParameter2) {}

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

public int findBiggest(int[] numbers) {
   int max;
   max = numbers[0];
   for (int i = 1; i < numbers.length; i++) {
       if (max < numbers[i]) {
           max = numbers[i];
       }
   }
   return max;
}

איך לתת שם לשיטה?

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

int addTwoNumbers (int a, int b)
void run()

איך לקרוא לשיטה

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

public static void main(String[] args) {
  int[] array = new int[] {5, 7, -2, 6, 7, 1};
  int max = findBiggest(array);
   System.out.println("the biggest number in array is: " + max);
  }

הפלט של תוכנית זו הוא:

סוגים שונים של שיטות ב-Java

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

שיטות מוגדרות מראש

שיטות ספרייה מוגדרות מראש או סטנדרטיות מובנות ב-Java. כמובן, כל מתכנת יכול להשתמש בהם או אפילו לשנות אותם באופן מקומי עבור התוכניות שלו. ספריית מחלקות Java ממוקמת בקובץ ארכיון Java (לדוגמה, *jar) עם מכונה וירטואלית של Java (JVM) וסביבת זמן ריצה של Java. אלה יכולות להיות, למשל, שיטות של המחלקה Math כמו min() , max() או abs() . או שיטות מניפולציה של מחרוזות כמו concat() . בואו ניצור מחלקה עם שיטה ראשית ונקרא לכמה שיטות ספרייה סטנדרטיות.

import static java.lang.Math.max;

public class Test {

    public static void main(String[] args) {
       int a = 5;
       int b = 7;
       int max = max(a,b);
       System.out.println(max);
       String str1 = "I am ";
       String str2 = "here ";
       String str3 = str1.concat(str2);
       System.out.println(str3);


   }

}

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

int max = Math.max(a,b);

שיטות מוגדרות על ידי משתמש

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

import java.util.Scanner;

public class Test {

   public void repeater() {
       Scanner scanner = new Scanner(System.in);
       System.out.println("WHat should I repeat after you?...");
       String s =  scanner.nextLine();
       System.out.println(s);
   }
}

יצירת שיטות סטטיות ב-Java

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

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;


public class Numbers {


   public static int findMax(int left, int right) {
       return (left < right) ? right : left;

   }


   public static boolean isNegative(int number) {
       return number < 0;
   }

   public static long power(long number, int deg) {

       if (deg == 0) {
           number = 1;
           return number;
       } else {
           number = power(number, deg - 1) * number;
           return number;
       }
   }

   public static long abs(long number) {
       return number > 0 ? number : -number;
     }


    public static void main(String[] args) {

       int a = 5;
       int b = 7;
       long c = -7;
       long abs = abs(c);
       System.out.println(abs);
       System.out.println(findMax(a,b));

   }

}

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

החלת שיטות מופע בקוד Java

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

public class Cat implements Voice{
   String name;
   String breed;
   int year;


   public void talk() {
       System.out.println("meow meow");
   }
}

כדי לקרוא לשיטת talk() עליך ליצור מופע של המחלקה Cat :

public class Demo {
   public static void main(String[] args) {
       Cat cat = new Cat ();
       cat.talk();

   }
}

פלט התוכנית הזה נמצא כאן:

שיטות מופשטות ב-Java

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

abstract class DemoAbs {
   abstract void myMethodAdd();
}

עכשיו בואו ניצור כיתת Child של הכיתה המופשטת הזו, DemoAbs . כאן עלינו ליישם בהכרח את שיטת myMethodAdd() .

public class myClass extends DemoAbs {

   void myMethodAdd() {
       System.out.println("hello");
   }

   public static void main(String[] args) {
       DemoAbs demoAbs = new myClass();
       demoAbs.myMethodAdd();
   }
}

הקצאת זיכרון עבור קריאות שיטה

זהו נושא מורכב למדי הדורש ניתוח זהיר יותר. כאן אנו הולכים להזכיר רק את הבסיסי ביותר להיכרות שטחית עם הנושא. זיכרון JVM מורכב מאזורי ערימה וערימה. הערימה היא אזור זיכרון המאחסן אובייקטי Java. זיכרון מחסנית הוא אזור זמני של זיכרון המאחסן משתנים פרימיטיביים והפניות לאובייקטים של מתודה. זיכרון המחסנית מכיל ערכים קצרי מועד התלויים בשיטה. סוג זה של זיכרון מבוסס על עקרון ה-Last In First Out (LIFO). זיכרון המחסנית יוצר בלוק חדש כאשר אנו קוראים למתודה. הוא מכיל ערכים פרימיטיביים מקומיים. כאשר אנו מפסיקים שיטה, הבלוק שנוצר בזיכרון המחסנית הופך חופשי.

סיכום

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