วิธีการใน Java

มีหลักการที่น่าสนใจข้อหนึ่งที่หลายคนเคยได้ยินมา เรียกว่า "แบ่งแยกและพิชิต" หลักการนี้ถูกนำมาใช้ในชีวิตมนุษย์หลายด้าน เช่น ในทางการเมือง หมายถึงการแบ่งแยกส่วนต่าง ๆ จำนวนมากในรัฐ ยุยงและใช้ความเป็นปรปักษ์ระหว่างส่วนต่าง ๆ เหล่านี้ กล่าวอีกนัยหนึ่ง: สร้างความขัดแย้งระหว่างผู้ที่อาจเป็นภัยคุกคามต่ออำนาจ แต่เราเป็นโปรแกรมเมอร์ดังนั้นเราจึงสนใจเฉพาะการตีความทางเทคนิคของหลักการนี้เท่านั้น และดำเนินไปดังนี้ “หลักการแบ่งแยกและพิชิต” คือการแบ่งปัญหาใหญ่ให้เป็นปัญหาเล็กลงจนกลายเป็นปัญหาเบื้องต้น จากนั้นคุณจะต้องแก้ไขมันตามลำดับและรวมทุกอย่างไว้ในระบบเดียว โปรแกรมนี้ควรแก้ปัญหาที่กำหนด” นั่นคือคุณเพียงแค่แยกปัญหาใหญ่ออกเป็นปัญหาเล็ก ๆ ซึ่งไม่ใช่ปัญหาสำหรับคุณที่จะแก้ไข จากนั้นคุณก็จะรวบรวมวิธีแก้ปัญหาให้เป็นหนึ่งเดียว เพื่อให้เป็นไปตามหลักการที่เรียบง่ายและมีประโยชน์นี้ การเขียนโปรแกรม Java จึงใช้วิธีการ เช่น เรากำลังสร้างหุ่นยนต์นักมวย เป็นสิ่งสำคัญสำหรับเราที่เขาเคลื่อนที่ได้ดี โจมตีได้อย่างแม่นยำ และคอยเฝ้าดูศัตรูเพื่อค้นหาจุดอ่อน มันคงจะอึดอัดใจที่จะเขียนทั้งหมดนี้ด้วย วิธีการ หลัก เดียว ใช่ไหม? ถ้าเราอธิบายทุกอย่างด้วยวิธีการเดียว ก็จะเป็นดังนี้:

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

จะเกิดอะไรขึ้นถ้าเราจำเป็นต้องใช้ก้าวไปข้างหน้าหรือเตะไปที่อื่นในโปรแกรม? อธิบายการกระทำทั้งหมดอีกครั้ง? ไม่พอดี. มีบรรทัดซ้ำๆ มากเกินไปจนหลงทางได้ง่าย เราจำเป็นต้องวางคำอธิบายรายละเอียดของการดำเนินการในโมดูลแยกต่างหาก ซึ่งจะดำเนินการขั้นตอนหุ่นยนต์ และเราสามารถเรียกเมธอดได้ในบรรทัดเดียว บางสิ่งเช่นนี้:

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

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

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

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

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

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

ตอนนี้เราได้แยกการทำงานของโรบ็อต เช่นเดียวกับเมธอด main() ที่กระชับและชัดเจน วิธีการที่เหลือยังสามารถแบ่งออกเป็นฟังก์ชันต่างๆ ได้ เช่นdeceptiveAttackingStrikeสามารถแบ่งออกเป็นวิธีการdeceptiveMovement , การเคลื่อนไหวของขา , การโจมตี และในทางกลับกันพวกเขาก็ได้รับมอบหมายให้ทำงานที่ง่ายกว่าเพื่อให้ได้งานเบื้องต้นในที่สุด เอาล่ะ เรามาเขียนมันทั้งหมดให้สวยงามในรูปแบบที่ 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_метода(принимаемые_параметры) {
   	//Тело метода
}

ตัวแก้ไขการเข้าถึง

ตัวแก้ไขการเข้าถึงมีหลายคำสำคัญ: public , private , package คำเหล่านี้บ่งบอกถึงขอบเขตของวิธีการ ฉันจะอธิบายง่ายๆ: ด้วยคำนี้ ดูเหมือนว่าคุณกำลังแบ่งปันขนมอร่อยๆ กับผู้อื่น อร่อยเป็นวิธีการของคุณ หากเป็นแบบส่วนตัวคุณไม่ต้องแชร์วิธีการนี้กับคลาสอื่น หากpackageคุณจะแชร์กับคลาสภายในแพ็คเกจเท่านั้น (คลาสจะถูกรวบรวมเป็นแพ็คเกจเฉพาะ คุณจะได้เรียนรู้สิ่งนี้ในภายหลัง) การแสดง ต่อสาธารณะว่าคุณมีน้ำใจและแบ่งปันของอร่อย (วิธีการ) ให้กับทั้งโปรแกรม บางอย่างเช่นนี้ หลังจากผ่านไปไม่กี่ระดับ คุณจะเข้าใจบทบาทของคำเหล่านี้ดีขึ้นมาก

ส่งคืนค่า

ดูตัวอย่างด้านบน: วิธีการทั้งหมดจะถูกทำเครื่องหมายด้วย คีย์เวิร์ดvoidยกเว้นหนึ่ง - isEnemyAttackedซึ่งส่งกลับ ค่าบู ลีน หากเมธอดถูกทำเครื่องหมายเป็นvoidจะไม่สามารถส่งคืนสิ่งใดได้ วิธีนี้เพียงแต่ดำเนินการตามชุดของการกระทำเท่านั้น ตอน นี้ให้ความสนใจกับ วิธีการ หลัก วิธีการเหล่านั้นที่ส่งคืนโมฆะจะถูกเรียกเช่นนั้นในเนื้อความของวิธีการ แต่ เมธอด isEnemyAttackedถูกเรียกภายในวงเล็บของ คำ สั่งif เนื่องจากว่ามันส่งกลับค่าบูลีน เราจึงมีโอกาสที่จะไม่ใช้ตัวแปรกลาง แต่สามารถแทรกโดยตรงได้ การ ส่งคืนค่าเกิดขึ้นโดยใช้ คีย์เวิร์ด return หากเมธอดส่งคืนชนิด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;
 	}
}

คอมไพลเลอร์จะดุคุณว่าเมื่อตรงตามเงื่อนไขแรก คุณจะส่งคืนบางสิ่ง แต่เมื่อตรงตามเงื่อนไขที่สอง คุณจะไม่ได้คืน

การส่งผ่านพารามิเตอร์

คุณสามารถส่งพารามิเตอร์ไปยังวิธีการที่ใช้ระหว่างการดำเนินการได้ ตัวอย่างดั้งเดิมที่สุดคือผลรวมของตัวเลขสองตัว แต่เราไม่ใช่คนดึกดำบรรพ์ใช่ไหม? ลองมาอีกตัวอย่างหนึ่งที่ค่อนข้างเหมารวม สมมติว่าเรามีวิธีการChef() - cook เราสามารถส่งส่วนผสมซุปไปยังวิธีนี้ในบล็อกพารามิเตอร์ และด้วยเหตุนี้ วิธีนี้จึงคืนซุปให้เรา แบบนี้:

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เรากำลังจัดการกับ Sage อื่นในตัวแปรm อย่างไรก็ตาม เรากำลังแก้ไขวัตถุดั้งเดิมของเรา ความจริงก็คือว่า อ็อบเจ็กต์ wiseManในเมธอด main และ อ็อบเจ็กต์ mใน เมธอด changeObjectนั้นเป็น wise man คนเดียวกัน และการอ้างอิงไปยังอ็อบเจ็กต์จะถูกคัดลอกลงในเมธอดเป็นพารามิเตอร์ โปรดคำนึงถึงสิ่งนี้เมื่อคุณแก้ไขออบเจ็กต์ในแต่ละวิธี

สุดท้ายนี้ ขอกล่าวถึงตัวแก้ไขแบบคงที่

โดยทั่วไปคำไม่กี่คำจะไม่ทำที่นี่ แต่ฉันจะพยายาม วิธีการปกติที่ไม่ได้ทำเครื่องหมายด้วยตัวแก้ไขนี้เป็นของอ็อบเจ็กต์คลาส และ วิธี การคงที่เป็นของคลาสนั้นเอง วิธีการปกติสามารถใช้กับแต่ละอ็อบเจ็กต์ได้ ดู คลาส WiseManจากตัวอย่างด้านบน ปราชญ์แต่ละคนจะมี วิธีgetIqและsetIqเป็นของตัวเอง เนื่องจากระดับ IQ ของทุกคนแตกต่างกัน หากเราเพิ่มเมธอดแบบคงที่GenerateAWisePhrase ให้กับคลาสนี้ เราก็จะสามารถเรียกเมธอดดังกล่าวได้โดยไม่ต้องใช้ออบเจ็กต์:

WiseMan.generateAWisePhrase();

โดยทั่วไป ข้อมูลนี้เพียงพอแล้วในตอนนี้ เนื่องจากสามารถเขียนบรรยายเกี่ยวกับstatic ได้ หลายรายการ ปฏิบัติตามกฎบางประการเมื่อเขียนวิธีการเพื่อรักษาลำดับในโค้ดของคุณ:

• ตั้งชื่อวิธีการของคุณที่มีความหมายเพื่อให้ชัดเจนว่าวิธีการเหล่านั้นทำอะไร
• พยายามอย่าเขียนวิธีการยาวมาก ความยาวที่เหมาะสมคือ 8-15 บรรทัด
• จำนวนพารามิเตอร์วิธีการไม่ควรเกิน 4-5
• หากคุณมีฟังก์ชันที่คล้ายกันสองครั้งในโค้ดของคุณ ลองคิดว่า: บางทีมันอาจจะคุ้มค่าที่จะสรุปมันและแยกมันออกเป็นวิธีอื่น

เทคนิคเหล่านี้จะช่วยคุณปรับปรุงประสิทธิภาพของโปรแกรม และที่สำคัญที่สุดคือทำให้โค้ดของคุณอ่านง่ายขึ้น