שיטות ב-Java

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

метод main() {
// Описание действий шага вперед
подача напряжения в отдельные модули;
поднятие ноги;
перевод в другую точку;
поставить ногу;
перенести вес на другую ногу;
если (противникАтакует()) {
        	// Описание действий уклонения робота.
        	...
} еслиНет {
        	// Описание действий обманного атакующего удара.
        	...
}
// Описание действий шага назад
...
}

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

метод шагВперед() {
// Описание действий шага вперед
  	подача напряжения в отдельные модули;
  	поднятие ноги;
  	перевод в другую точку;
  	поставить ногу;
  	перенести вес на другую ногу;
}

метод уклонение() {
  	// Действия для уклонения
  	...
}

метод обманныйАтакующийУдар() {
  	// Действия для удара
  	...
}

метод шагНазад() {
  	// Действия для шага назад
  	...
}

метод противникАтакует() {
	// Робот проверяет атакует ли противник
}

метод main() {
	шагВперед();
	если (противникАтакует()) {
        	уклонение();
	} еслиНет {
  	  обманныйАтакующийУдар();
	}
	шагНазад();
}

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

public static void stepForward() {
  	    // Многострочный code, описывающий
  	    // действия робота для выполнения шага
  	    System.out.println("The robot takes a step forward");
}

public static void evasion() {
  	    // Действия для уклонения
  	    System.out.println("Robot shy of impact");
}

public static void deceptiveAttackBlow() {
  	    // Действия для удара
  	    System.out.println("The robot performs a deceptive strike");
}

public static void stepBack() {
  	    // Действия для шага назад
  	    System.out.println("The robot takes a step backwards");
}

public static void main(String[] args) {
    	stepForward();
    	if (isEnemyAttacked()) {
        		evasion();
    	} else {
  	    	deceptiveAttackBlow();
    	}
    	stepBack();
}

public static boolean isEnemyAttacked() {
    	// Метод проверяет, атакует ли враг. returns логическое meaning.
    	return true;
}

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

модификатор_доступа возвращаемое_meaning Name_метода(принимаемые_параметры) {
   	//Тело метода
}

משנה גישה

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

ערך החזרה

תסתכל על הדוגמה למעלה: כל השיטות מסומנות במילת המפתח void , פרט לאחד - isEnemyAttacked , שמחזיר ערך בוליאני . אם שיטה מסומנת כבטלה , ייתכן שהיא לא תחזיר דבר. השיטה הזו פשוט מבצעת סט של פעולות וזהו. עכשיו שימו לב לשיטה העיקרית . אותן שיטות שמחזירות בטל נקראות בדיוק כך, בגוף השיטה. אבל שיטת isEnemyAttacked נקראת בסוגריים של הצהרת if . בשל העובדה שהוא מחזיר ערך בוליאני, אנו מקבלים הזדמנות לא להשתמש במשתנה ביניים, אלא להכניס אותו ישירות. החזרת ערך מתרחשת באמצעות מילת המפתח החזרה . אם מתודה מחזירה את type int , נוכל לקרוא למתודה מכל ביטוי:

public static int getNumber() {
 	    return 5;
}

public static void main(String[] args) {
    	int result = 5 + 6 + getNumber();
    	System.out.println(result);
}

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

public static int findMaxNumber(int a, int b) {
 	if(a>b) {
 	    return a;
 	}
}

המהדר יגרוף בך שכאשר התנאי הראשון מתקיים, אתה מחזיר משהו, אבל כשהתנאי השני מתקיים, לא.

העברת פרמטרים

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

public static void main(String[] args) {
    	String[] ingredients;
    	// Инициализация массива ингредиентов
    	Soup soup = chef(ingredients);

}

public static Soup chef(String[] ingredients) {
    	Soup soup = new Soup();
    	// Процесс варки супа
    	return soup;
}

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

העברת פרמטרים לפי הפניה ולפי ערך

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

public static void main(String[] args) {
    	int x = 1;
    	System.out.println(x);
    	getNumber(x);
    	System.out.println(x);

	}

	public static void getNumber(int i) {
    	i = i + 100;
	}

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

public class Program
{
	public static void main(String[] args) {
    	WiseMan wiseMan = new WiseMan();
    	wiseMan.setIq(300);
    	System.out.println(wiseMan);
    	changeObject(wiseMan);
    	System.out.println(wiseMan);

	}

	public static void changeObject(WiseMan m) {
    	m.setIq(100);
	}
}

public class WiseMan {
	int iq;

	public void setIq(int iq) {
    	this.iq = iq;
	}

	public int getIq() {
    	return iq;
	}

	public String toString() {
    	return "Our wise man has an IQ "+iq;
	}
}

סיכום: יש לנו מחלקה של WiseMan שיש לה מאפיין iq . ושתי שיטות השולטות בערך השדה הזה. בשיטה הראשית אנו יוצרים אובייקט wiseMan , מגדירים את ערך iq ל 300 . ואז אנחנו מעבירים את החכם שלנו עם iq 300 לשיטת changeObject אבל בשיטה הזו הוא הופך לטיפש. הגדרנו את הערך של iq ל- 100. ואז בשיטה הראשית נדפיס את האובייקט. ניתן לראות שבשיטת changeObject אנו מבצעים מניפולציות של חכם אחר במשתנה m . עם זאת, אנו משנים את האובייקט המקורי שלנו. העובדה היא שהאובייקט wiseMan בשיטה הראשית והאובייקט m בשיטת changeObject הם אותו חכם, והפניה לאובייקט מועתקת למתודה כפרמטר. זכור זאת כאשר אתה עורך אובייקט בשיטות בודדות.

לסיום, כמה מילים על השינוי הסטטי

באופן כללי, כמה מילים לא יעזרו כאן, אבל אני אנסה. שיטות רגילות שאינן מסומנות בשינוי זה שייכות לאובייקט המחלקה. ושיטות סטטיות שייכות למחלקה עצמה. ניתן להשתמש בשיטות רגילות על אובייקטים בודדים. תסתכל על כיתת WiseMan מהדוגמה למעלה. לכל חכם יהיו שיטות getIq ו- setIq משלו, כי רמת ה-IQ של כל אחד שונה. אם נוסיף שיטה סטטית generateAWisePhrase למחלקה הזו , נוכל לקרוא למתודה כזו ללא אובייקט:

WiseMan.generateAWisePhrase();

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

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

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