วิธีใช้การเรียกซ้ำใน Java

ในการเขียนโปรแกรม การเรียกซ้ำหมายถึงกระบวนการที่ฟังก์ชันเรียกตัวเองโดยตรงหรือโดยอ้อม การเรียกซ้ำใช้เพื่อแก้ปัญหาจำนวนหนึ่งในด้านวิทยาการคอมพิวเตอร์

ภาษาการเขียนโปรแกรม Java รองรับการสร้างเมธอดแบบเรียกซ้ำ ซึ่งเป็นเมธอดที่เรียกตัวเองว่า

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

วิธีการ Java

เมธอด ซึ่งบางครั้งเรียกว่าฟังก์ชัน เป็นบล็อกของโค้ดที่ทำงานเฉพาะ ตัวอย่างเช่น สามารถใช้วิธีการในการคำนวณผลรวมของอาร์เรย์ของค่าหรือพิมพ์เนื้อหาของอาร์เรย์ไปยังคอนโซล

นี่คือไวยากรณ์สำหรับวิธีการใน Java:

ตัวแก้ไขแบบคงที่ returnType methodName (Parameters) { // Method body}

ตัวอย่างเช่น สมมติว่าคุณต้องการสร้างวิธีการที่พิมพ์ประโยค “It's Wednesday! เราผ่านไปครึ่งสัปดาห์แล้ว!” ไปที่คอนโซล คุณสามารถทำได้โดยใช้รหัสนี้:

คลาสหลัก {public static void printItsWednesday() { System.out.println("It's Wednesday! We're half-way of the week!");}public static void main(String[] args) { printItsWednesday( );}}

เมื่อเราเรียกวิธีนี้โดยใช้ printItsWednesday() , ส่งคืนสิ่งต่อไปนี้:

วันพุธแล้ว! เราผ่านไปครึ่งสัปดาห์แล้ว!

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการต่างๆ ของ Java คุณสามารถอ่านคู่มือฉบับสมบูรณ์สำหรับวิธีการต่างๆ ใน ​​Java ได้ที่นี่

ในตัวอย่างข้างต้น เราเรียก prinItsWednesday() วิธีการในโปรแกรมหลัก แต่ถ้าเราจะเรียกวิธีการของเราในตัววิธีการเอง เราจะได้สร้างวิธีการแบบเรียกซ้ำ

การเรียกซ้ำ Java

เมธอดแบบเรียกซ้ำคือเมธอดที่ถูกเรียกภายในเมธอดหลักในตอนแรกแล้วเรียกภายในเมธอดเอง นี่คือไวยากรณ์สำหรับวิธีการแบบเรียกซ้ำ:

คงเป็นโมฆะ executeMethod() { // รหัสที่นี่ executeMethod(); // นี่คือการเรียกซ้ำของเรา // Code here}public static void main(String[] args) { executeMethod(); // นี่คือการเรียกเมธอดปกติ}

เมื่อเรารันโปรแกรม executeMethod() วิธีการถูกเรียกในโปรแกรมหลักของเรา ซึ่งทำให้รหัสใน executeMethod() เมธอดที่จะรัน ซึ่งในกรณีนี้รวมถึง executeMethod() กระบวนการ. ดังนั้นเมื่อโปรแกรมของเรารัน มันจะเข้าลูป

โปรแกรมจะดำเนินการ executeMethod() . ต่อไป จนกว่าจะตรงตามเงื่อนไขที่ป้องกันไม่ให้ดำเนินการต่อ หากไม่มีการระบุเงื่อนไขที่สามารถหยุดการเรียกซ้ำ โปรแกรมจะทำงานตลอดไป สิ่งนี้เรียกว่าการเรียกซ้ำที่ไม่สิ้นสุด

เหตุใดคุณจึงควรใช้การเรียกซ้ำ ประการแรก การเรียกซ้ำสามารถลดความซับซ้อนของเวลาของโปรแกรมได้ในบางกรณี ประการที่สอง การเรียกซ้ำสามารถช่วยให้คุณนำอัลกอริธึมบางตัวไปใช้ได้ง่ายขึ้นในลักษณะที่สามารถอ่านและบำรุงรักษาได้มากขึ้น

ต่อไปนี้คือตัวอย่างบางส่วนของโปรแกรมที่มักเขียนโดยใช้การเรียกซ้ำ:

• การคำนวณลำดับฟีโบนักชี
• การกลับสตริง
• การคำนวณแฟกทอเรียลของตัวเลข
• การคำนวณความสูงของต้นไม้ไบนารี

ที่กล่าวว่าการเรียกซ้ำอาจช้ากว่าการเขียนวิธีมาตรฐานเพื่อทำงาน เนื่องจากการเรียกซ้ำจะสร้างตำแหน่งการจัดเก็บใหม่สำหรับตัวแปรทุกครั้งที่ดำเนินการวิธีการแบบเรียกซ้ำ

ตัวอย่างการเรียกซ้ำของ Java

มาดูสองตัวอย่างเพื่อแสดงให้เห็นว่าการเรียกซ้ำทำงานอย่างไรใน Java

การย้อนกลับสตริงโดยใช้การเรียกซ้ำ

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

เราสามารถใช้รหัสต่อไปนี้เพื่อย้อนกลับสตริง:

รหัสของเราส่งคืน:

คะแนนของนักเรียนในปีนี้คือ ABAACABAABCBC

อย่างที่คุณเห็น โปรแกรมของเราได้ย้อนกลับเนื้อหาของสตริงของเรา ในโปรแกรมของเรา เราได้สร้างฟังก์ชันเรียกซ้ำที่เรียกว่า reverse() .

เมื่อ reverse() ฟังก์ชั่นถูกเรียกใช้งาน ก่อนอื่นให้ตรวจสอบว่าสตริงเกรดว่างหรือไม่ ถ้าใช่ เราจะคืนค่ารายการเกรดไปที่โปรแกรมหลัก สิ่งนี้จะหยุดการเรียกซ้ำเนื่องจาก reverse() การโทรเมื่อสิ้นสุดฟังก์ชันไม่ได้รับโอกาสในการเรียกใช้

หากสตริงเกรดไม่ว่างเปล่า โปรแกรมของเราจะดำเนินการ reverse() วิธีการอีกครั้งและเชื่อมผลลัพธ์ของฟังก์ชันกับอักขระตัวแรกของประโยค เราใช้ charAt() วิธีในตัวอย่างของเราเพื่อดึงอักขระตัวแรกในประโยค และเพิ่มทางด้านซ้ายของ reverse() กระบวนการ.

หลังจากที่เปลี่ยนสตริงของเราแล้ว ข้อความที่ระบุว่า This student’s grades for the year are: “ ตามด้วยผลการเรียนที่กลับด้านของนักเรียน จะถูกส่งกลับไปยังโปรแกรม

การคำนวณแฟกทอเรียลโดยใช้การเรียกซ้ำ

อีกตัวอย่างหนึ่งที่การเรียกซ้ำมีประโยชน์คือการคำนวณแฟกทอเรียลของตัวเลข

ในทางคณิตศาสตร์ แฟกทอเรียลเป็นผลคูณของจำนวนเต็มบวกทั้งหมดที่น้อยกว่าหรือเท่ากับจำนวนที่คูณเข้าด้วยกัน ตัวอย่างเช่น แฟกทอเรียลของ 5 เท่ากับ 5*4*3*2*1 ซึ่งเท่ากับ 120 เนื่องจากวิธีแฟกทอเรียลเกี่ยวข้องกับการคำนวณซ้ำๆ จึงเป็นตัวอย่างที่ดีในชีวิตจริงที่การเรียกซ้ำมีประโยชน์ในการแก้ปัญหา .

โปรแกรม Java ต่อไปนี้ช่วยให้เราสามารถคำนวณแฟกทอเรียลของจำนวน 7 ใน Java:

คลาสหลัก { คงที่ int CalculFactorial (จำนวน int) { ถ้า (หมายเลข !=0) ส่งคืนหมายเลข * คำนวณแฟกทอเรียล (หมายเลข-1); อื่น ๆ กลับ 1; } โมฆะคงที่สาธารณะ main (สตริง [] args) { int num =7; คำตอบ int =คำนวณแฟกทอเรียล (จำนวน); System.out.println("แฟกทอเรียลของ 7 คือ:" + คำตอบ); }}

รหัสของเราส่งคืน:

The factorial of 7 is: 5040


ในตัวอย่างนี้ เราสร้างวิธีการที่เรียกว่า calculateFactorial() ที่คูณตัวเลขที่เก็บไว้ในพารามิเตอร์ตัวเลขด้วยผลลัพธ์ของ calculateFactorial() ถัดไป กระบวนการ. กระบวนการนี้ดำเนินการจนกว่าพารามิเตอร์ตัวเลขจะเท่ากับ 0

เมื่อพารามิเตอร์ตัวเลขเท่ากับ 0 คำสั่ง if ในโค้ดของเราจะส่งกลับ 1 และผลลัพธ์ของ calculateFactorial() วิธีการถูกส่งกลับไปยังโปรแกรมหลัก

ดังนั้น calculateFactorial() วิธีดำเนินการ 7*6*5*4*3*2*1 จากนั้นส่งคืนคำตอบของโปรแกรมหลัก เมื่อคำนวณคำตอบแล้ว ข้อความ The factorial of 7 is: ตามด้วยคำตอบที่คำนวณโดยโปรแกรมของเรา ถูกพิมพ์ไปยังคอนโซล

บทสรุป

การเรียกซ้ำเป็นแนวคิดในการเขียนโปรแกรมที่ใช้อธิบายวิธีการที่เรียกตัวเอง วิธีการแบบเรียกซ้ำอาจมีประโยชน์ในกรณีที่คุณจำเป็นต้องทำซ้ำหลาย ๆ ครั้งและใช้ผลลัพธ์ของการวนซ้ำก่อนหน้าของงานนั้นในการวนซ้ำปัจจุบัน

บทช่วยสอนนี้อธิบายพื้นฐานของการเรียกซ้ำใน Java และวิธีสร้างวิธีการเรียกซ้ำ นอกจากนี้ บทช่วยสอนนี้ยังกล่าวถึงสองตัวอย่างของการดำเนินการเรียกซ้ำ โดยอ้างอิงการย้อนกลับสตริงและการคำนวณแฟกทอเรียล

ตอนนี้คุณพร้อมที่จะเริ่มทำงานด้วยวิธีเรียกซ้ำใน Java อย่างมืออาชีพแล้ว!