1. โครงสร้างวงกลม
คำสั่งลูปสามารถเรียกใช้รหัสบางส่วนซ้ำ ๆ ได้เมื่อตรงตามเงื่อนไขการวนซ้ำ รหัสซ้ำนี้เรียกว่าคำสั่ง Loop Body เมื่อร่างกายลูปนี้ถูกดำเนินการซ้ำ ๆ เงื่อนไขการตัดสินลูปจะต้องแก้ไขให้เป็นเท็จในเวลาที่เหมาะสมเพื่อสิ้นสุดลูปมิฉะนั้นลูปจะดำเนินการต่อไป
องค์ประกอบของคำสั่งลูป:
คำสั่งการเริ่มต้น: หนึ่งหรือมากกว่าข้อความงบเหล่านี้เสร็จสิ้นการดำเนินการเริ่มต้นบางอย่าง
คำแถลงการตัดสินใจ: นี่คือการแสดงออกของบูลีนซึ่งสามารถกำหนดได้ว่าจะดำเนินการลูปร่างกายหรือไม่
คำสั่งวนลูป: ส่วนนี้เป็นคำสั่งวนวนซึ่งเป็นสิ่งที่เราต้องทำหลายครั้ง
คำชี้แจงเงื่อนไขการควบคุม: ส่วนนี้จะดำเนินการก่อนที่เงื่อนไขการตัดสินรอบถัดไปจะถูกดำเนินการหลังจากสิ้นสุดของวงจร โดยการควบคุมตัวแปรในสภาพลูปลูปจะสิ้นสุดในเวลาที่เหมาะสม
เช่น: เมื่อ "HelloWorld" เป็นเอาต์พุต 10 ครั้งบนคอนโซล
คำสั่งเริ่มต้น: กำหนดค่าเริ่มต้นเป็นครั้งแรก
คำสั่งการตัดสิน: จำนวนครั้งไม่เกิน 10 ครั้ง
คำสั่ง Loop Body: แสดงคำสั่ง "HelloWorld"
คำสั่งควบคุมเงื่อนไข: จำนวนครั้งที่เปลี่ยนไปในครั้งต่อไป
2. โครงสร้างลูป (สำหรับคำสั่งลูป)
สำหรับรูปแบบคำสั่งลูป:
สำหรับ (คำแถลงการเริ่มต้น; คำสั่งตามเงื่อนไขการตัดสินคำสั่งควบคุมตามเงื่อนไข) {
คำสั่งร่างกายวน
-
กระบวนการดำเนินการ:
ตอบ: ดำเนินการคำสั่งการเริ่มต้น
B: ดำเนินการตามเงื่อนไขการตัดสินเพื่อดูว่าผลลัพธ์นั้นเป็นจริงหรือเท็จ: หากเป็นเท็จลูปจะสิ้นสุดลง; หากเป็นจริงให้ดำเนินการต่อ
C: ดำเนินการตามคำชี้แจงร่างกายลูป
D: ดำเนินการคำสั่งเงื่อนไขการควบคุม
E: กลับไปที่ B และดำเนินการต่อ
แผนภูมิการไหล:
หมายเหตุ:
(1) ผลลัพธ์ของคำแถลงเงื่อนไขการตัดสินคือประเภทบูลีน
(2) หากคำสั่ง LOOP เป็นคำสั่งเดียวคุณสามารถใช้งานจัดฟันได้ หากเป็นหลายข้อความจะไม่สามารถละเว้นการจัดฟันได้ ขอแนะนำไม่ให้ละเว้น
(3) การพูดโดยทั่วไป: หากมีรั้งซ้ายจะไม่มีเครื่องหมายอัฒภาคถ้ามีเครื่องหมายอัฒภาคไม่มีรั้งซ้าย
รหัสตัวอย่าง:
1. ค้นหาผลรวมของตัวเลขคู่ระหว่าง 1-100:
/* ข้อกำหนด: A: ค้นหาผลรวม 1-100 B: ค้นหาผลรวมของตัวเลขคู่ระหว่าง 1-100*/คลาส Fortest1 {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// ค้นหาผลรวมของ 1-100 int sum1 = 0; สำหรับ (int x = 1; x <= 100; x ++) {sum1+= x; } system.out.println ("1-100 คือ:"+sum1); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - // วิธีการ 2 int sum3 = 0;2. ค้นหาแฟคทอเรียล 5:
/* ข้อกำหนด: ค้นหาแฟคทอเรียลของ 5. แฟคทอเรียลคืออะไร? n = n*(n-1)! กฎ n! = n*(n-1)*(n-2)*...*3*2*1 อุดมการณ์รวม ค้นหาความคิดแบบแฟคทอเรียล */คลาส fortest2 {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// กำหนดตัวแปรผลลัพธ์สุดท้าย int jc = 1; // x ที่นี่สามารถเริ่มต้นโดยตรงจาก 2 // สำหรับ (int x = 1; x <= 5; x ++) สำหรับ (int x = 2; x <= 5; x ++) {jc *= x; } system.out.println ("1-5 แฟคทอเรียลคือ:"+jc); -3. เอาท์พุททั้งหมด "Narcissus Number" ในคอนโซล:
/* ข้อกำหนด: ส่งออก "Narcissus Numbers" ทั้งหมดในการวิเคราะห์คอนโซล: เราไม่รู้ว่า "Narcissus Numbers" คืออะไรคุณขอให้ฉันทำอะไร? หมายเลข Narcissus ที่เรียกว่าหมายถึงหมายเลขสามหลักและผลรวมลูกบาศก์ของตัวเลขของพวกเขาเท่ากับจำนวนของตัวเอง ตัวอย่างเช่น: 153 เป็นดอกแดฟโฟดิล 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 A: ตัวเลขสามหลักจริงบอกเราถึงช่วง B: ผ่านการวนรอบสำหรับการวนรอบเราสามารถรับแต่ละตัวเลขสามหลัก แต่ปัญหาคือวิธีการรับข้อมูลของตัวเลขสามหลักนี้สิบและหลายร้อย เราจะได้รับข้อมูลของข้อมูลสิบและหลายร้อย? สมมติว่ามีข้อมูล: 153 GE: 153%10 = 3 Shi: 153/10%10 = 5 BAI: 153/10/10%10 = 1 QIAN: X/10/10/10%10 WAN: X/10/10/10/10%10 ... */คลาส fortest3 {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// สามหลักสามหลักบอกเราถึงช่วง สำหรับ (int x = 100; x <1000; x ++) {int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; // ให้ ge*ge*ge+shi*shi*shi+bai*bai*bai เปรียบเทียบกับข้อมูลถ้า (x == (ge*ge*ge+shi*shi*shi+bai*bai)) {// ถ้าเหมือนกันเอาท์พุทข้อมูลบนคอนโซล System.out.println (x); -3. โครงสร้างลูป (ในขณะที่คำสั่งลูป)
ในขณะที่รูปแบบคำสั่งลูป:
ในขณะที่ (คำสั่งตามเงื่อนไขการตัดสิน) {
คำสั่งร่างกายวน
-
// คำสั่งการเริ่มต้นรูปแบบขยาย;
ในขณะที่ (คำสั่งตามเงื่อนไขการตัดสิน) {
คำสั่งร่างกายวน
คำสั่งควบคุมเงื่อนไข;
-
แผนภูมิการไหล:
ความแตกต่างระหว่าง A for for และ a ในขณะวน:
สำหรับคำสั่งลูปและในขณะที่คำสั่งลูปสามารถแปลงได้อย่างเท่าเทียมกัน แต่ก็ยังมีความแตกต่างเล็กน้อย
(1) ความแตกต่างในการใช้งาน:
ตัวแปรที่ควบคุมโดยคำสั่งควบคุมแบบมีเงื่อนไขไม่สามารถเข้าถึงได้หลังจากสิ้นสุดการวนรอบสำหรับการวนรอบและสามารถใช้งานต่อไปได้หลังจากที่ลูปสิ้นสุดลง หากคุณต้องการใช้งานต่อไปให้ใช้ในขณะที่ไม่เช่นนั้นจะแนะนำให้ใช้ เหตุผลก็คือว่า การวนรอบสำหรับการวนรอบและตัวแปรจะหายไปจากหน่วยความจำซึ่งสามารถปรับปรุงประสิทธิภาพของการใช้หน่วยความจำ
(2) ความแตกต่างของฉาก:
สำหรับลูปเหมาะสำหรับการดำเนินการสำหรับการตัดสินช่วงในขณะที่ลูปเหมาะสำหรับการดำเนินการสำหรับจำนวนการตัดสินที่ไม่ชัดเจน
รหัสตัวอย่าง:
ภูเขาที่สูงที่สุดในประเทศของเราคือ Mount Everest: 8848m ตอนนี้ฉันมีกระดาษขนาดใหญ่พอที่มีความหนา: 0.01m ฉันขอถามได้กี่ครั้งที่ฉันพับเพื่อให้แน่ใจว่าความหนาไม่ต่ำกว่าความสูงของ Mount Everest?
/* ภูเขาที่สูงที่สุดในประเทศของเราคือ Mount Everest: 8848m ตอนนี้ฉันมีกระดาษขนาดใหญ่พอที่มีความหนา: 0.01m ฉันขอถามได้กี่ครั้งที่ฉันพับฉันสามารถมั่นใจได้ว่าความหนาไม่ต่ำกว่าความสูงของ Mount Everest? การวิเคราะห์: A: กำหนดตัวแปรทางสถิติค่าเริ่มต้นคือ 0 B: ยอดสูงสุดคือ Mount Everest: 8848M นี่คือความหนาสุดท้าย ตอนนี้ฉันมีแผ่นกระดาษขนาดใหญ่พอที่มีความหนา: 0.01m นี่คือความหนาเริ่มต้น C: กี่ครั้งที่ฉันพับฉันสามารถมั่นใจได้ว่าความหนาไม่ต่ำกว่าความสูงของ Mount Everest? การเปลี่ยนแปลงจะเกิดอะไรขึ้นถ้าฉันพับหนึ่งครั้ง? นั่นคือความหนามีความหนาเป็นสองเท่าเหมือนเมื่อก่อน D: ตราบใดที่ความหนาของการเปลี่ยนแปลงแต่ละครั้งไม่เกินความสูงของ Mount Everest มันจะถูกพับตัวแปรทางสถิติ ++ E: ตัวแปรทางสถิติเอาท์พุท */คลาส whileTest01 {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// กำหนดตัวแปรทางสถิติค่าเริ่มต้นคือ 0 int count = 0; // ยอดเขาสูงสุดคือ Mount Everest: 8848m นี่คือความหนาสุดท้าย // ตอนนี้ฉันมีกระดาษที่มีขนาดใหญ่พอที่มีความหนา: 0.01m นี่คือความหนาเริ่มต้น // สำหรับความเรียบง่ายฉันเปลี่ยน 0.01 เป็น 1 และในลักษณะเดียวกัน 8848 กลายเป็น 884800 int start = 1; ในขณะที่ (start <end) {// ตราบใดที่ความหนาของการเปลี่ยนแปลงแต่ละครั้งไม่เกินความสูงของ Mount Everest พับและตัวแปรทางสถิติ ++ Count ++; // การเปลี่ยนแปลงจะเกิดอะไรขึ้นถ้ามันถูกพับหนึ่งครั้ง? มันคือความหนาเป็นสองเท่าของอันก่อนหน้า เริ่ม *= 2; System.out.println ("th"+count+"ความหนาคือ"+เริ่มต้น); } // ตัวแปรทางสถิติเอาต์พุต System.out.println ("จะซ้อนกัน"+นับ+"เวลา"); -4. โครงสร้างลูป (ทำ…ในขณะที่ลูปคำสั่ง)
รูปแบบพื้นฐาน:
ทำ {
คำสั่งร่างกายวน
} ในขณะที่ ((คำสั่งตามเงื่อนไขการตัดสิน); [/รหัส]
รูปแบบขยาย:
คำสั่งเริ่มต้น;
ทำ {
คำสั่งร่างกายวน
คำสั่งควบคุมเงื่อนไข;
} ในขณะที่ ((คำสั่งตามเงื่อนไขการตัดสิน); [/รหัส]
แผนภูมิการไหล:
5. ความแตกต่างและข้อควรระวังสำหรับโครงสร้างวงจร:
คำสั่งลูปทั้งสามสามารถทำหน้าที่เดียวกันได้จริงซึ่งหมายความว่าพวกเขาสามารถแปลงเท่ากันได้ แต่ยังมีความแตกต่างเล็กน้อย:
DO …ในขณะที่ Loop จะดำเนินการลูปร่างกายอย่างน้อยหนึ่งครั้ง สำหรับลูปและในขณะที่ลูปจะดำเนินการกับลูปของร่างกายเมื่อเงื่อนไขเป็นจริง
1. หมายเหตุ:
เมื่อเขียนโปรแกรมคุณควรให้ความสำคัญกับการวนรอบสำหรับลูปจากนั้นพิจารณาในขณะที่ลูปและในที่สุดก็พิจารณา DO ... ในขณะที่ลูป
รหัสต่อไปนี้เป็นวนซ้ำที่ตายแล้ว:
ในขณะที่ (จริง) {}
สำหรับ(;;){}
2. การใช้ลูปซ้อนกัน: ร่างกายลูปของคำสั่งลูปเองเป็นคำสั่งวนลูป
(1) คำถามที่ 1: โปรดส่งออกรูปแบบดาว (*) ด้วย 4 แถวและ 5 คอลัมน์:
เคล็ดลับ: จำนวนแถวที่ควบคุมโดยวงรอบนอกและจำนวนคอลัมน์ที่ควบคุมโดยลูปด้านใน
/*ข้อกำหนด: โปรดส่งออกรูปร่างต่อไปนี้*** *** **** **** ***** ***** เคล็ดลับ: วงรอบด้านนอกควบคุมจำนวนแถววงในควบคุมจำนวนคอลัมน์*/คลาส forfortest01 {โมฆะคงที่สาธารณะ 5 คอลัมน์สำหรับ (int x = 0; x <5; x ++) {สำหรับ (int y = 0; y <5; y ++) {system.out.print ("*"); } system.out.println (); } system.out.println ("-------------------------------------------------); // เราได้ใช้รูปร่างของ 5 แถวและ 5 คอลัมน์ // แต่นี่ไม่ใช่สิ่งที่เราต้องการ // สิ่งที่เราต้องการคือการเปลี่ยนแปลงจำนวนคอลัมน์ // // // y = 0, y <= 1, y ++ // แถวที่สาม: 3 คอลัมน์ y = 0, y <= 2, y ++ // แถวที่สี่: 4 คอลัมน์ y = 0, y <= 3, y ++ // แถวที่ห้า: 5 คอลัมน์ y = 0, y <= 4, y ++ // สำหรับ (int x = 0; x <5; x ++) {สำหรับ (int y = 0; y <= x; y ++) {system.out.print ("*");(2) คำถามที่ 2: เอาต์พุตตารางการคูณเก้าเก้าบนคอนโซล:
/* ข้อกำหนด: เอาต์พุตตารางการคูณเก้าเก้าในคอนโซล ครั้งแรกที่เราเขียนตารางการคูณเก้าเก้าครั้ง: 1*1 = 1 1*2 = 2 2 2*2 = 4 1*3 = 3 2*3 = 6 3*3 = 9 1*4 = 4 2*4 = 8 3*4 = 12 4*4 = 16 ... 1*9 = 9 2*9 = 18 3*9 = 27 ... ********* ********* หมายเหตุ: '/x' x หมายถึงวิธีนี้วิธีนี้เรียกว่าอักขระการถ่ายโอน '/t' ตำแหน่งของอักขระแท็บ (คีย์ tabtab) '/r' Enter '/n' การแบ่งบรรทัด */คลาส forfortest02 {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {สำหรับ (int x = 0; x <9; x ++) {สำหรับ (int y = 0; y <= x; y ++) } system.out.println (); } system.out.println ("---------------------"); // ในการใช้ข้อมูลเราเริ่มจาก 1 สำหรับ (int x = 1; x <= 9; x ++) {สำหรับ (int y = 1; y <= x; y ++) {system.out.print (y+"*"+x+"="+y*x+"/t"); } system.out.println (); -เอฟเฟกต์การทำงาน:
6. คำสั่งการควบคุมกระโดด:
ดังที่เราได้กล่าวไปแล้วก่อนหน้านี้ Goto ใน Java เป็นคำที่สงวนไว้และไม่สามารถใช้งานได้ในปัจจุบัน แม้ว่าจะไม่มีคำแถลง Goto เพื่อปรับปรุงความปลอดภัยของโปรแกรม แต่ก็นำความไม่สะดวกมากมาย ตัวอย่างเช่นฉันต้องการสิ้นสุดเมื่อลูปบางอย่างรู้ถึงขั้นตอนหนึ่งและฉันไม่สามารถทำสิ่งนี้ได้ในตอนนี้ เพื่อที่จะชดเชยข้อบกพร่องนี้ Java ให้การหยุดพักดำเนินการต่อและกลับไปที่การควบคุมการกระโดดและการขัดจังหวะของข้อความ
ทำลายการขัดจังหวะ
ดำเนินการต่อ
กลับ
1. คำสั่งควบคุมกระโดด (break):
ใช้สถานการณ์เพื่อหยุดพัก:
~ ในคำสั่งสวิตช์สำหรับการเลือกโครงสร้าง
~ ในคำสั่งลูป (หากมีการเพิ่มคำพิพากษาลงในคำสั่งลูป)
หมายเหตุ: ไม่มีความหมายที่จะออกจากสถานการณ์การใช้งาน
ฟังก์ชั่นของการหยุดพัก:
ตอบ: แยกออกจากวงชั้นเดียว
B: แยกออกจากวงดนตรีหลายชั้น
เพื่อให้บรรลุผลกระทบนี้คุณต้องรู้อะไรบางอย่าง คำสั่งที่มีฉลาก ชื่อแท็กต้องปฏิบัติตามกฎการตั้งชื่อ Java
รูปแบบ:
ชื่อแท็ก: คำสั่ง
รหัสตัวอย่าง:
/* คำสั่งการกระโดดควบคุม: BREAK: Interrupt Contine: ดำเนินการต่อ: Return: Return Break: Interrupt หมายถึงสถานการณ์การใช้งาน: A: คำสั่งสวิตช์ B: คำสั่งวนลูป (หากมีการเพิ่มคำพิพากษาลงในคำสั่งลูป) หมายเหตุ: มันไม่มีความหมายที่จะออกจากสองฉากข้างต้น ใช้อย่างไร? ตอบ: แยกออกจากลูปชั้นเดียว B: แยกออกจากห่วงหลายชั้นเพื่อให้ได้เอฟเฟกต์นี้คุณต้องรู้อะไรบางอย่าง คำสั่งที่มีฉลาก รูปแบบ: ชื่อแท็ก: คำสั่ง */คลาส breakdemo {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// ออฟเซ็ตนอกสวิตช์หรือลูป // break; // ออฟเซ็ตลูปชั้นเดียวสำหรับ (int x = 0; x <10; x ++) {ถ้า (x == 3) {break; } system.out.println ("HelloWorld"); } system.out.println ("over"); System.out.println ("---------------"); // ชดเชยการวนซ้ำหลายชั้น wc: สำหรับ (int x = 0; x <3; x ++) {nc: สำหรับ (int y = 0; y <4; y ++) {ถ้า (y == 2) {// break nc; BREAK WC; } system.out.print ("*"); } system.out.println (); -ในบรรทัดที่ 38 เราเพิ่มแท็กลงในวงรอบนอกที่เรียกว่า WC จากนั้นกระโดดออกจากแท็กนี้ในบรรทัด 42
เอฟเฟกต์การทำงาน:
หมายเหตุ: ในการพัฒนาจริงฟังก์ชั่นของการกระโดดแบบหลายชั้นการกระโดดเกือบจะเป็นไปไม่ได้ที่จะใช้
2. คำสั่งการควบคุมกระโดด (ดำเนินการต่อ):
ใช้สถานการณ์เพื่อดำเนินการต่อ:
ไม่มีประเด็นใดที่จะออกจากสถานการณ์การใช้งานในคำสั่งวนลูป
ความแตกต่างระหว่างการดำเนินการต่อกับการหยุด:
แบ่งออกจากวงเลเยอร์เดี่ยวจะแยกออกจากวงและเข้าสู่การดำเนินการครั้งต่อไป
ผลกระทบมีดังนี้:
คำถามสัมภาษณ์:
สำหรับ (int x = 1; x <= 10; x ++) {ถ้า (x%3 == 0) {// กรอกรหัสที่นี่} system.out.println ("Java Learning"); -กรอกข้อมูลในบรรทัด 4 ของรหัสข้างต้นเพื่อตอบสนองเงื่อนไขต่อไปนี้:
ฉันต้องการส่งออก 2 ครั้งในคอนโซล: "Java Learn Learn" Break;
ฉันต้องการส่งออก 7 ครั้งในคอนโซล: "Java Learning" ดำเนินการต่อ;
ฉันต้องการส่งออก 13 ครั้งในคอนโซล: "Java Learning" System.out.println ("Java Learning");
3. คำสั่งการควบคุมกระโดด (กลับ)
คำหลักที่ส่งคืนไม่ได้เป็นการกระโดดออกจากร่างกายลูป ฟังก์ชั่นที่ใช้กันทั่วไปคือการจบวิธีการออกจากวิธีการและข้ามไปยังวิธีที่เรียกว่าในชั้นบน
เพื่อให้มันตรงไปตรงมา: ฟังก์ชั่นของการส่งคืนไม่ได้จบการวนรอบ แต่เพื่อจบวิธีการ
ผลกระทบมีดังนี้:
แบบฝึกหัดของคำสั่งลูปรวมกับการหยุด:
คำถามสัมภาษณ์: แม่ของ Xiaofang ให้เวลา 2.5 หยวนต่อวันและเธอจะช่วยมันได้ อย่างไรก็ตามเมื่อใดก็ตามที่วันนี้เป็นวันที่ 5 ของการออมหรือหลายครั้งจาก 5 เธอจะใช้จ่าย 6 หยวน Xiaofang สามารถประหยัดได้กี่วันเป็น 100 หยวน
การใช้รหัส:
/* ข้อกำหนด: แม่ของ Xiaofang ให้เวลา 2.5 หยวนต่อวันและเธอจะช่วยมันได้ อย่างไรก็ตามเมื่อใดก็ตามที่วันนี้เป็นวันที่ 5 ของการออมหรือหลายครั้งจาก 5 เธอจะใช้จ่าย 6 หยวน Xiaofang สามารถประหยัดได้กี่วันเป็น 100 หยวน การวิเคราะห์: A: แม่ของ Xiaofang ให้ 2.5 หยวนต่อวัน, Double Daymoney = 2.5; B: เธอจะบันทึก double daysum = 0; C: ร้านค้า int daycount = 1 จากวันแรก; D: Xiaofang จะประหยัด 100 วันได้กี่วัน ผลลัพธ์สองเท่า = 100; E: ถ้าวันนี้เป็นวันที่ 5 ของการออมหรือหลายครั้งจาก 5 เธอจะใช้จ่าย 6 หยวนซึ่งบ่งบอกว่าเธอต้องการตัดสินคุณค่าของวัน หาก 5 ถูกแบ่งออก 6 หยวนจะถูกลบออก Daysum -= 6; สิ่งนี้แสดงถึงปัญหานั่นคือถ้าไม่ใช่หลายวัน 5 วันเงินจะต้องสะสม Daysum += Daymoney; F: เพราะฉันไม่รู้ว่ามันเป็นกี่วันฉันจึงใช้วนซ้ำที่ตายแล้ว เมื่อเกิน 100 หยวนฉันจะออกจากวง */คลาส whiledemo {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// เงินที่จะเก็บไว้ทุกวันคือ 2.5 หยวนสองวัน Daymoney = 2.5; // ค่าเริ่มต้นของการบันทึกคือ 0 double daymum = 0; // การจัดเก็บข้อมูล daycount = 1 จากวันแรก; // ที่เก็บข้อมูลสุดท้ายไม่น้อยกว่า 100 และผลลัพธ์ int = 100; // เพราะฉันไม่ทราบว่ามันเป็นกี่วันฉันใช้วนซ้ำที่ตายแล้วในขณะที่ (จริง) {// สะสมเงิน Daysum += Daymoney; // เมื่อเกิน 100 หยวนฉันออกจากวง if (daysum> = ผลลัพธ์) {system.out.println ("ใช้จ่ายทั้งหมด 100 หยวนในการจัดเก็บทั้งหมด"); หยุดพัก; } if (dayCount%5 == 0) {// ใช้จ่าย 6 หยวน Daysum -= 6; System.out.println ("Things"+DayCount+"ใช้จ่ายทั้งหมด 6 หยวน"); } // จำนวนวันเปลี่ยน DayCount ++; -ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น