การเรียกซ้ำเป็นคุณลักษณะในตัวของมันเองหรือไม่?

... หรือเป็นเพียงการปฏิบัติธรรม?

ฉันถามเรื่องนี้เนื่องจากมีข้อโต้แย้งกับศาสตราจารย์ของฉัน: ฉันสูญเสียเครดิตในการเรียกใช้ฟังก์ชันซ้ำบนพื้นฐานที่เราไม่ครอบคลุมการเรียกซ้ำในชั้นเรียนและข้อโต้แย้งของฉันคือเราเรียนรู้โดยปริยายจากการเรียนรู้returnและวิธีการ

ฉันถามที่นี่เพราะฉันสงสัยว่ามีใครบางคนมีคำตอบที่ชัดเจน

ตัวอย่างเช่นความแตกต่างระหว่างสองวิธีต่อไปนี้คืออะไร:

public static void a() {
    return a();
    }

public static void b() {
    return a();
    }

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

ท้ายที่สุดมันขึ้นอยู่กับว่าโดยการเรียนรู้return a()จากbสิ่งนั้นเราเรียนรู้return a()จากสิ่งaนั้นด้วยหรือไม่ เรา?

เพื่อตอบคำถามเฉพาะของคุณ: ไม่จากมุมมองของการเรียนรู้ภาษาการเรียกซ้ำไม่ใช่คุณลักษณะ ถ้าอาจารย์ของคุณเทียบเคียงคุณทำเครื่องหมายว่าใช้ "คุณลักษณะ" ที่เขายังไม่เคยสอนนั่นเป็นสิ่งที่ผิด

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

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

กองซ้อนล้น

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

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

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

การอ่าน

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

private int getInput() {
    int input;
    do {
        input = promptForInput();
    } while (!inputIsValid(input))
    return input;
}

กับ

private int getInput() {
    int input = promptForInput();
    if(inputIsValid(input)) {
        return input;
    }
    return getInput();
}

ใช่ทั้งสองอย่างนี้ใช้งานได้และใช่ทั้งคู่เข้าใจง่าย แต่วิธีการทั้งสองจะอธิบายเป็นภาษาอังกฤษอย่างไร? ฉันคิดว่ามันจะเป็นดังนี้:

ฉันจะแจ้งให้ป้อนข้อมูลจนกว่าอินพุตจะถูกต้องแล้วจึงส่งคืน

กับ

ฉันจะแจ้งให้ป้อนข้อมูลจากนั้นหากอินพุตถูกต้องฉันจะส่งคืนมิฉะนั้นฉันจะได้รับอินพุตและส่งคืนผลลัพธ์ของสิ่งนั้นแทน

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

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

เพื่อตอบคำถามตามตัวอักษรแทนที่จะเป็นคำถามเชิงอภิมาน: การเรียกซ้ำเป็นคุณลักษณะในแง่ที่ไม่ใช่คอมไพเลอร์และ / หรือภาษาทั้งหมดที่จำเป็นต้องอนุญาต ในทางปฏิบัติคาดว่าจะมีคอมไพเลอร์สมัยใหม่ (ธรรมดา) ทั้งหมด - และแน่นอนว่าคอมไพเลอร์ Java ทั้งหมด! - แต่มันไม่เป็นความจริงในระดับสากล

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

สำหรับคอมไพเลอร์ดังกล่าวเมื่อคุณเรียกใช้ฟังก์ชันเช่นนี้

a();

จะดำเนินการเป็น

move the address of label 1 to variable return_from_a
jump to label function_a
label 1

และคำจำกัดความของ a ()

function a()
{
   var1 = 5;
   return;
}

ดำเนินการเป็น

label function_a
move 5 to variable var1
jump to the address stored in variable return_from_a

หวังว่าปัญหาเมื่อคุณพยายามโทรa()ซ้ำในคอมไพเลอร์ดังกล่าวจะชัดเจน คอมไพลเลอร์ไม่ทราบวิธีการส่งคืนจากการเรียกภายนอกอีกต่อไปเนื่องจากที่อยู่สำหรับส่งคืนถูกเขียนทับ

สำหรับคอมไพเลอร์ที่ฉันใช้จริง (ฉันคิดว่าในช่วงปลายยุค 70 หรือต้นทศวรรษที่ 80) โดยไม่มีการสนับสนุนการเรียกซ้ำปัญหานั้นละเอียดอ่อนกว่านั้นเล็กน้อย: ที่อยู่ที่ส่งคืนจะถูกเก็บไว้ในสแต็กเช่นเดียวกับในคอมไพเลอร์สมัยใหม่ แต่ตัวแปรในพื้นที่ไม่ทำงาน 'T (ในทางทฤษฎีนี่ควรหมายความว่าการเรียกซ้ำเป็นไปได้สำหรับฟังก์ชันที่ไม่มีตัวแปรโลคัลที่ไม่คงที่ แต่ฉันจำไม่ได้ว่าคอมไพลเลอร์สนับสนุนสิ่งนั้นอย่างชัดเจนหรือไม่อาจต้องการตัวแปรโลคัลโดยนัยด้วยเหตุผลบางประการ)

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

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

การหักคะแนนเพราะ "เราไม่ครอบคลุมการเรียกซ้ำในชั้นเรียน" นั้นแย่มาก หากคุณได้เรียนรู้วิธีการเรียกฟังก์ชัน A ซึ่งเรียกฟังก์ชัน B ซึ่งเรียกฟังก์ชัน C ซึ่งจะส่งกลับไปที่ B ซึ่งจะส่งกลับไปยัง A ซึ่งส่งกลับไปยังผู้เรียกและครูไม่ได้บอกคุณอย่างชัดเจนว่าสิ่งเหล่านี้จะต้องเป็นฟังก์ชันที่แตกต่างกัน (ซึ่ง จะเป็นเช่นนั้นใน FORTRAN เวอร์ชันเก่าเป็นต้น) ไม่มีเหตุผลที่ A, B และ C ไม่สามารถเป็นฟังก์ชันเดียวกันได้ทั้งหมด

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

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

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

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

ฉันเชื่อว่าศาสตราจารย์หักคะแนนเนื่องจากการเรียกซ้ำถือเป็นเรื่องของตัวเองและไม่น่าเป็นไปได้ที่คนที่ไม่มีประสบการณ์การเขียนโปรแกรมจะคิดว่าการเรียกซ้ำ (แน่นอนว่าไม่ได้หมายความว่าจะไม่ทำ แต่ก็ไม่น่าเป็นไปได้)

IMHO ฉันคิดว่าศาสตราจารย์พูดถูกโดยหักคะแนนคุณ คุณสามารถนำส่วนการตรวจสอบความถูกต้องไปใช้วิธีอื่นได้อย่างง่ายดายและใช้วิธีนี้:

public bool foo() 
{
  validInput = GetInput();
  while(!validInput)
  {
    MessageBox.Show("Wrong Input, please try again!");
    validInput = GetInput();
  }
  return hasWon(x, y, piece);
}

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

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

ข้อได้เปรียบหลักของการเรียกซ้ำคืออัลกอริทึมแบบเรียกซ้ำมักจะเขียนได้ง่ายและรวดเร็วกว่ามาก

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

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

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

• การสนับสนุนฟังก์ชันชั้นหนึ่งทำให้การเรียกซ้ำเป็นไปได้ภายใต้สมมติฐานที่น้อยมาก ดูตัวอย่างการเขียนลูปใน Unlambdaหรือนิพจน์ Python ที่ป้านนี้ไม่มีการอ้างอิงตนเองลูปหรือการกำหนด:

  >>> map((lambda x: lambda f: x(lambda g: f(lambda v: g(g)(v))))(
  ...   lambda c: c(c))(lambda R: lambda n: 1 if n < 2 else n * R(n - 1)),
  ...   xrange(10))
  [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
  

• ภาษา / คอมไพเลอร์ที่ใช้การโยงล่าช้าหรือที่กำหนดการประกาศไปข้างหน้าทำให้การเรียกซ้ำทำได้ ตัวอย่างเช่นในขณะหลามช่วยให้ด้านล่างรหัสที่เป็นทางเลือกการออกแบบ (ผูกพันดึก) ไม่จำเป็นสำหรับการเป็นทัวริงสมบูรณ์ของระบบ ฟังก์ชันเรียกซ้ำร่วมกันมักขึ้นอยู่กับการสนับสนุนสำหรับการประกาศไปข้างหน้า

  factorial = lambda n: 1 if n < 2 else n * factorial(n-1)
  

• ภาษาที่พิมพ์แบบคงที่ซึ่งอนุญาตให้มีการกำหนดประเภทซ้ำมีส่วนช่วยในการเปิดใช้งานการเรียกซ้ำ ดูนี้การดำเนินงานของ Y Combinator ใน Go หากไม่มีประเภทที่กำหนดแบบวนซ้ำก็ยังสามารถใช้การเรียกซ้ำใน Go ได้ แต่ฉันเชื่อว่า Y combinator โดยเฉพาะจะเป็นไปไม่ได้

จากสิ่งที่ฉันสามารถสรุปได้จากคำถามของคุณการใช้ฟังก์ชันเรียกซ้ำเพื่อขอข้อมูลในกรณีที่การป้อนข้อมูลล้มเหลวไม่ใช่แนวทางปฏิบัติที่ดี ทำไม?

เนื่องจากการเรียกใช้ฟังก์ชันแบบเรียกซ้ำทุกครั้งจะถูกผลักไปที่สแตก เนื่องจากการเรียกซ้ำนี้ขับเคลื่อนโดยการป้อนข้อมูลของผู้ใช้จึงเป็นไปได้ที่จะมีฟังก์ชั่นการเรียกซ้ำแบบไม่สิ้นสุดและส่งผลให้เกิดStackOverflow :-p

การมีลูปแบบไม่วนซ้ำเพื่อทำสิ่งนี้คือวิธีที่จะไป

recursionคือการเขียนโปรแกรมแนวคิดเป็นคุณลักษณะ (ชอบซ้ำ) และการปฏิบัติการปฏิบัติดังที่คุณเห็นจากลิงก์นี้มีงานวิจัยมากมายสำหรับหัวข้อนี้โดยเฉพาะ บางทีเราไม่จำเป็นต้องลงลึกในหัวข้อเพื่อทำความเข้าใจประเด็นเหล่านี้

การเรียกซ้ำเป็นคุณลักษณะ

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

ไม่มีการเรียกซ้ำ?

สำหรับภาษาที่ไม่รองรับความเป็นไปได้ในการเรียกซ้ำมักจะมีวิธีแก้ปัญหาอื่นในรูปแบบของตัวรวมจุดคงที่ แต่ก็ยังต้องใช้ภาษาเพื่อรองรับฟังก์ชันที่เรียกว่าออบเจ็กต์ชั้นหนึ่ง (เช่นอ็อบเจ็กต์ซึ่งอาจเป็น จัดการภายในภาษาเอง)

การเรียกซ้ำเป็นการฝึก

การมีคุณลักษณะนั้นในภาษาไม่จำเป็นหมายความว่าเป็นสำนวน ใน Java 8 มีการรวมนิพจน์แลมบ์ดาไว้ด้วยดังนั้นจึงอาจกลายเป็นเรื่องง่ายกว่าที่จะใช้แนวทางการทำงานในการเขียนโปรแกรม อย่างไรก็ตามมีข้อควรพิจารณาในทางปฏิบัติ:

• ไวยากรณ์ยังไม่เป็นมิตรกับการเรียกซ้ำมากนัก
• คอมไพเลอร์อาจไม่สามารถตรวจพบการปฏิบัตินั้นและปรับให้เหมาะสมได้

บรรทัดล่างสุด

โชคดี (หรือถูกต้องมากขึ้นเพื่อความสะดวกในการใช้งาน) Java ปล่อยให้เมธอดตระหนักถึงตัวเองโดยค่าเริ่มต้นและรองรับการเรียกซ้ำดังนั้นนี่ไม่ใช่ปัญหาในทางปฏิบัติ แต่ก็ยังคงเป็นปัญหาทางทฤษฎีและฉันคิดว่า ครูของคุณต้องการพูดถึงเรื่องนี้โดยเฉพาะ นอกจากนี้ในแง่ของวิวัฒนาการล่าสุดของภาษาภาษาอาจกลายเป็นสิ่งที่สำคัญในอนาคต