គ្មានទីបញ្ចប់សម្រាប់ (ជ្វា) វដ្ត

នៅក្នុង Java, ដូចជានៅក្នុងស្ទើរតែភាសាសរសេរកម្មវិធីផ្សេងវាមានឧបករណ៍ដើម្បីផ្ដល់នូវការធ្វើឡើងវិញច្រើននៃផ្នែកណាមួយនៃកូដដែលមាន, ឬ, ដូចដែលពួកគេត្រូវបានគេហៅ, វដ្ត។ រង្វិលជុំនៅក្នុង Java ត្រូវបានតំណាងដោយប្រតិបត្តិករ, ដូចជាសម្រាប់និងខណៈពេលព្រមទាំងពូជរបស់ពួកគេ។ ជាធម្មតាវដ្តត្រូវបានប្រើសម្រាប់ការអនុម័តនៃអារេមួយវិមាត្រនិងពហុវិមាត្រនិងរចនាសម្ព័ន្ធទិន្នន័យសារឡើងវិញ (រួមទាំងការប្រមូល) ដើម្បីស្វែងរកធាតុជាក់លាក់និងប្រតិបត្ដិការបន្ថែមទៀតជាមួយពួកគេ។ ទោះជាយ៉ាងណានេះមិនមែនជាវិធីសាស្រ្តនៃការប្រើឧបករណ៍មួយចំនួនដូចជាវដ្តនៃការជ្វា។ ឧទាហរណ៍នៃការប្រើប្រាស់នឹងត្រូវបាន actuated ជាការពិចារណារបស់ពួកគេ។

រង្វិលជុំខណៈដែល ជ្វា: ការរៀបរាប់និងឧទាហរណ៍

ប្រតិបត្តិករវដ្តមូលដ្ឋាននៅក្នុងកោះជ្វាគឺខណៈពេលដែលការ។ សង្ខេបកូដរុំព័ទ្ធក្នុងរាងកាយរបស់គាត់នឹងត្រូវបានធ្វើម្តងទៀតដរាបណាកន្សោមលក្ខខណ្ឌដែលបានរុំព័ទ្ធដោយដង្កៀបបន្ទាប់ពីវានឹងបំពេញតម្លៃតក្កពិត។ ទម្រង់ទូទៅនៃសេចក្តីថ្លែងការណ៍ខណៈពេលដែលមួយគឺមានដូចខាងក្រោម:

ខណៈពេលដែល (លក្ខខណ្ឌ) {

// រាងកាយរង្វិលជុំ

}

នៅពេលដែលតម្លៃនៃលក្ខខណ្ឌឡូជីខដែលបានបញ្ឈប់ជាការពិត, អ្នកទោសនៅក្នុងកូដរាងកាយរង្វិលជុំនឹងបញ្ឈប់ការត្រូវបានអនុវត្តនិងត្រួតពិនិត្យនឹងត្រូវបានអនុម័តក្រោយពីឈានដល់បន្ទាត់ជាបន្ទាន់នោះ។ ប្រសិនបើមានរង្វិលជុំត្រូវបានរុំព័ទ្ធប្រតិបត្តិករតែមួយគត់, ដង្កៀបអាចត្រូវបានបោះបង់ចោលនោះទេប៉ុន្តែវាត្រូវបានចាត់ទុកថាជាទម្រង់ល្អប្រសិនបើពួកគេគឺមាននៅគ្រប់ពេលវេលា។ តួលេខបង្ហាញខាងលើលំហូរដ្យាក្រាមនៃប្រតិបត្តិការរបស់ប្រតិបត្តិករ។

ចំពោះភាពច្បាស់លាស់, សូមរកមើលនៅក្នុងឧទាហរណ៍ដែលបានបង្ហាញនៅក្នុងតួលេខខាងក្រោមនេះ:

បានប្រកាសការរាប់អថេរត្រូវបានកំណត់ទៅ 1 បន្ទាប់ពីដំបូងយើងឃើញកន្សោមឡូជីខលដែលបានរុំព័ទ្ធក្នុងវង់ក្រចកបន្ទាប់ពីឈ្មោះរបស់ប្រតិបត្តិករនេះ។ វាគឺជាការពិត, នោះគឺ, ត្រឡប់តម្លៃពិត, ដរាបណាតម្លៃនៃការរាប់អថេរនេះគឺតិចជាងឬស្មើនឹង 10 រង្វិលជុំជាមួយនឹងដំណាក់គ្នា (និយាយឡើងវិញ) តម្លៃអថេរត្រូវបានបង្កើនដោយ 1 និងបង្ហាញនៅលើអេក្រង់កុងសូលនេះ។ ចំណាំថានៅពេលដែលតម្លៃនៃអថេរដែលបានឈានដល់ 11, វដ្តឈប់ដំណើរការ។

បើតម្លៃនៃការរាប់ដំបូងស្មើ 11 ស្ថានភាពនៃវដ្តនេះនឹងមានមិនពិត, ហើយកម្មវិធីនេះថែមទាំងមិនបានទៅចូលទៅក្នុងរាងកាយរបស់គាត់។

វាគឺមានតំលៃកត់សម្គាល់ថាវាក្យសម្ព័ន្ធជ្វាអនុញ្ញាតឱ្យប្រើប្រាស់នៃសេចក្តីថ្លែងការណ៍ខណៈពេលដោយគ្មានរាងកាយមួយ។ ខាងក្រោមនេះគឺជាឧទាហរណ៍មួយ។ សូមឱ្យយើងបាននិយាយថាយើងមានអថេរពីរ = 100 ហើយខ្ញុំ j = 200, យើងកំពុងប្រឈមមុខនឹងភារកិច្ចនៃកម្មវិធីនេះដើម្បីគណនាមធ្យមរបស់ពួកគេ - អ្នកអាចប្រើ "ប្រហោង»ខណៈដែល:

ខណៈពេល (++ ខ្ញុំ <- j);

ជាលទ្ធផលតម្លៃនៃការណាមួយនៃអថេរពីរនេះនឹងត្រូវបានស្មើទៅនឹងមធ្យមនៃតម្លៃដំបូងរបស់ពួកគេ។ ដូចដែលអ្នកអាចឃើញវដ្តនេះបានធ្វើការយ៉ាងល្អឥតខ្ចោះដោយមិនរាងកាយនិងអនុវត្តសកម្មភាពដែលចាំបាច់ទាំងអស់ក្នុងការបញ្ចេញមតិលក្ខខណ្ឌ។

វដ្តនៃការធ្វើខណៈពេលដែល

នៅក្នុងឧទាហរណ៍មុន, ប្រសិនបើកន្សោមលក្ខខណ្ឌដំបូងបានត្រឡប់មិនពិតត្រូវ, បន្ទាប់មកកម្មវិធីនេះនឹងត្រូវបានមិនអើពើរាងកាយនៃរង្វិលជុំនិងបានទៅលើ។ ទោះជាយ៉ាងណា, ជាញឹកញាប់មានស្ថានភាពដែលប្រតិបត្តិនៃកូដដែលមាននៅក្នុងរាងកាយរបស់រង្វិលជុំនេះត្រូវប្រាកដថាយ៉ាងហោចណាស់ម្ដងដោយមិនគិតពីការពិតនៃការបញ្ចេញមតិលក្ខខណ្ឌនេះ។ នៅក្នុងពាក្យផ្សេងទៀត, វាកើតឡើងដែលថាពិនិត្យមើលសុពលភាពនៃការបញ្ចេញមតិលក្ខខណ្ឌនេះមិនត្រូវបានទាមទារនៅដើមនិងនៅចុងបញ្ចប់នៃវដ្តនេះ។ មុខងារនេះអាចផ្តល់នូវប្រភេទនៃរង្វិលជុំខណៈពេលដែលគេហៅថាធ្វើខណៈពេលដែលមួយ។ វាមានទម្រង់ដូចខាងក្រោម:

ធ្វើ {
// រាងកាយរង្វិលជុំ

} ខណៈពេលដែល (លក្ខខណ្ឌ);

ដូចដែលយើងអាចមើលឃើញជាលើកដំបូងសម្រាប់ការវដ្តការប្រតិបត្តិនេះគឺរូបកាយនេះហើយបានតែបន្ទាប់មកបានពិនិត្យលក្ខខណ្ឌពិត - ហើយដូច្នេះការនិយាយឡើងវិញជារៀងរាល់។

លេខកូដខាងលើបំពេញប្រមាណជាដូចគ្នានៅក្នុងករណីមួយដែលមានខណៈពេលធម្មតានោះទេ។ ទោះជាយ៉ាងណា, ប្រសិនបើយើងបានផ្ដល់តម្លៃនៃការរាប់ 11 រូបកាយរង្វិលជុំនៅតែជួបគ្នាម្តង, មុនពេលដែលប្រតិបត្តិករអាចផ្ទៀងផ្ទាត់ការពិតនៃការបញ្ចេញមតិនេះ។

សង្ខេបនិងឧទាហរណ៍សម្រាប់ - វដ្តជ្វា

ចំពោះវដ្ត គឺជាទម្រង់ភាសាល្អផងនិងមានប្រសិទ្ធិភាពក្នុងការកោះជ្វា។ រហូតដល់កំណែទីប្រាំនៃកោះ Java SDK គឺមានតែមួយគត់ប្រពៃណីនៃសម្រាប់សេចក្តីថ្លែងការណ៍ហើយបន្ទាប់ពីថ្មីមួយ - សម្រាប់គ្នា។ ក្នុងផ្នែកនេះយើងនឹងស្វែងយល់ពីទម្រង់បែបបទប្រពៃណីប្រតិបត្តិករ។ សម្រាប់ Java រង្វិលជុំគឺមានដូចខាងក្រោម:

មុនពេលកូដបញ្ជានឹងត្រូវបានផ្ទេរនៅក្នុងរង្វិលជុំជាលើកដំបូង initializes ដែលខ្ញុំអថេរបម្រើជាការប្រឆាំងនេះ។ លើសពីនេះទៀតកន្សោមលក្ខខណ្ឌត្រូវបានធីក, ម្ល៉ោះការប្រឆាំងនេះត្រូវបានប្រៀបធៀបជាមួយនឹងតម្លៃជាក់លាក់មួយហើយប្រសិនបើវាត្រឡប់ជាការពិតរាងកាយត្រូវបានប្រតិបត្តិ។ បន្ទាប់មកតម្លៃរាប់ត្រូវបានផ្លាស់ប្ដូរដោយជំហានកំណត់ទុកជាមុនមួយ, និងជាថ្មីម្តងទៀតបានគូសធីកការបញ្ចេញមតិលក្ខខណ្ឌនិងនៅលើដូច្នេះរហូតដល់លក្ខខណ្ឌមិនពិត។ ខាងក្រោមនេះបង្ហាញពីប្លុកដ្យាក្រាមដំណាក់កាលនៃវដ្តទាំងអស់នេះ។

ចំពោះការយល់ដឹងប្រសើរជាងមុនយើងបានផ្តល់ឱ្យឧទាហរណ៍អំពីរបៀបវដ្តសម្រាប់ Java មួយ:

យើងមើលឃើញថានៅក្នុងអថេរ loopVal បានប្រើជាការប្រឆាំងមួយ។ បន្ទាប់ពីការនិយាយឡើងវិញគ្នា, តម្លៃរបស់វានឹងកើនឡើង 1, ហើយវានឹងកើតឡើងរហូតដល់ពេលនោះមករហូតដល់វាឈានដល់ 11 ចំណាំថាអថេរវត្ថុបញ្ជាអាចត្រូវបានប្រកាសនៅខាងក្រៅសម្រាប់សេចក្តីថ្លែងការណ៍នោះទេប៉ុន្តែប្រសិនបើអ្នកមិនចង់ប្រើអថេរនេះនៅគ្រប់ទីកន្លែងលើកលែងតែ នៅក្នុងវដ្តនេះវាគឺជាទីប្រឹក្សាដើម្បីប្រកាសវាដោយផ្ទាល់នៅក្នុងសេចក្តីថ្លែងការណ៍នេះ។ រក្សាទុកក្នុងចិត្តថាអថេរបានប្រកាសនៅក្នុងសេចក្តីថ្លែងការណ៍នេះមានវិសាលភាពនៅក្នុងវដ្តនៃការដូចគ្នានេះ។

មានពេលដែលអ្នកចង់បានដើម្បីត្រួតពិនិត្យការរង្វិលជុំប្រកាសអថេរច្រើនមាន។ សម្រាប់រង្វិលជុំកោះជ្វាអនុញ្ញាតឱ្យអ្នកបញ្ជាក់អថេរពីរឬច្រើនដែលបំបែកដោយសញ្ញាក្បៀសនិងដើម្បីធ្វើដូច្នេះបានទាំងនៅក្នុងការចាប់ផ្ដើមរបស់ពួកគេនិងក្នុងអំឡុងពេលការនិយាយឡើងវិញ។ បែបនេះប្រតិបត្តិករនឹងក្លាយដូចខាងក្រោម:

សម្រាប់ (int i = 1, J int = 10; ខ្ញុំ

នៅក្នុងការនិយាយឡើងវិញគ្នា, តម្លៃនៃអថេរខ្ញុំត្រូវបានបង្កើនដោយ 1 និងតម្លៃនៃ J អថេរត្រូវបាន decremented ដោយ 1. អន្តរកម្មនេះនឹងត្រូវបានប្រតិបត្តិដែលវែងដូចដែលខ្ញុំមានឋានៈធំជាងឬស្មើទៅនឹងញ។

លក្ខណៈពិសេសនៃកម្មវិធីសម្រាប់សេចក្តីថ្លែងការណ៍នេះ

សម្រាប់រង្វិលជុំគឺជាការរចនាដែលអាចបត់បែនបានដែលទាក់ទង, ចាប់តាំងពីមានបីផ្នែកទាំងអស់ (ចាប់ផ្ដើមលក្ខខណ្ឌនិងបង្កើន / បន្ថយ) អាចត្រូវបានប្រើសម្រាប់គោលបំណងមិនមែនរបស់ខ្លួន។ ឧទាហរណ៍ជំនួសកន្សោមលក្ខខណ្ឌជាមួយអថេរបញ្ជាអាចជំនួសអថេរប៊ូលីនណាមួយ។

ការចាកចេញប៊ូលីន = មិនពិត!

សម្រាប់ (int ខ្ញុំ = 0 ;! ការចាកចេញ; ++ ខ្ញុំ) {

ការចាកចេញ = ពិត;

}

នៅក្នុងឧទាហរណ៍ខាងលើយើងអាចមើលឃើញពីរបៀបដែលវដ្តការងារនេះគឺឯករាជ្យទាំងស្រុងពីអថេរវត្ថុបញ្ជាខ្ញុំនិងចំនួននៃការនិយាយឡើងវិញគឺអាស្រ័យទាំងស្រុងទៅលើអ្វីដែលពេលវេលានៃអថេរការចាកចេញនឹងត្រូវបានកំណត់ទៅជាការពិត។ លើសពីនេះទៅទៀតអថេរវត្ថុបញ្ជាអាចត្រូវបានយកចេញពីវដ្តនេះទាំងអស់គ្នាហើយវានឹងមិនប៉ះពាល់ដល់ការងាររបស់គាត់: សម្រាប់ (; ការចាកចេញ ;!) {} ។ ទោះបីជាវាមិនមែនជាវិធីល្អបំផុតក្នុងការសរសេរកម្មវិធី, វាពេលខ្លះអាចមានប្រយោជន៍។ អ្វីដែលមេ - ដើម្បីផ្តល់នូវស្ថានភាពដែលក្នុងអថេរនឹងទទួលបានសិទ្ធិក្នុងការចាកចេញពីតម្លៃវដ្តនេះ, ដូច្នេះជាការមិនឱ្យបើកវាចូលទៅក្នុងគ្មានទីបញ្ចប់មួយ។

ចំពោះវដ្តនៃកោះជ្វាអាចត្រូវបានប្រកាសនិងវិធីនេះ: សម្រាប់ (;;) {} ។ នេះគឺជាឧទាហរណ៍ធម្មតានៃរង្វិលជុំមិនកំណត់ជាមួយលក្ខខណ្ឌពិសេសនៃការរំខាន។ អំពីថាតើប្រភេទនៃវដ្តផ្អាកនេះយើងនឹងពិភាក្សាតិចតួចមួយនៅពេលក្រោយ។

វដ្តនៅក្នុងរចនាប័ទ្មសម្រាប់គ្នា

វដ្ត Foreach ជ្វាតែងតែត្រូវបានប្រើសម្រាប់តម្រៀបគ្នានៃអារេនៃធាតុឬណាមួយដែល រចនាសម្ព័ន្ធទិន្នន័យ និងការសម្តែងនៅលើពួកគេប្រតិបត្តិការច្រំដែលមួយចំនួន។ ឧទាហរណ៍ដែលបានផ្ដល់ឱ្យសម្រាប់សំណុំបែបបទត្រូវបានបង្ហាញដូចខាងក្រោមប្រតិបត្តិករ:

ជាឈ្មោះបានប្រកាសការនិយាយឡើងវិញអថេរអារេមួយជួរដេកឈ្មោះប្រតិបត្តិករកាលពីមុនដំណើរការប្រកាសលើកទីពីរអាគុយម៉ង់។ ឈ្មោះអថេរនឹងជម្មើសជំនួសយកតម្លៃនៃធាតុគ្នានៃអារេរហូតដល់ធាតុទាំងអស់របស់ខ្លួនត្រូវបានគេស្រង់ចេញ។ វាគួរតែត្រូវបានកត់សម្គាល់ថាប្រភេទអថេរត្រូវតែឆបគ្នាជាមួយនឹងប្រភេទនៃធាតុអារេត្រូវបានរក្សាទុកក្នុងនោះ។ ដូចគ្នានេះផងដែរ, ឈ្មោះអថេរអាចប្រើបានសម្រាប់តែការអាននិងការប៉ុនប៉ងដើម្បីផ្លាស់ប្តូរវានឹងមិននាំឱ្យមានការផ្លាស់ប្តូរនៃធាតុអារេមួយនៅ។

វដ្តប្រតិបត្តិកររំខាន

មានវដ្តប្រតិបត្តិករបីផ្អាក: សម្រាក, ត្រឡប់មកវិញនិងការបន្ត។ នេះជាលើកទីពីរគឺអាចរំខានទាំងស្រុងវដ្តការងារនិងបន្តធ្វើការតែផ្អាកការនិយាយឡើងវិញនាពេលបច្ចុប្បន្ននេះ។ ប្រសិនបើអ្នកកំពុងប្រើនៅក្នុងរបស់អ្នកគ្មានទីបញ្ចប់វដ្តចេតនាកូដចាវ៉ា, ទាំងនេះប្រតិបត្តិករត្រូវតែមានវត្តមាននៅក្នុងវា។ សូមពិចារណាឧទាហរណ៍ធម្មតានៃការប្រើសម្រាក:

ទោះបីជាសេចក្តីថ្លែងការណ៍នេះត្រូវបានផ្តល់ជូនសម្រាប់ 11 អន្តរកម្មប្រហារជីវិតតែ 8 ទេព្រោះនៅពេលដែលខ្ញុំរាប់គឺស្មើនឹង 7, លក្ខខណ្ឌការងារនៅក្នុងការដែលរាងកាយមានសេចក្តីថ្លែងការសម្រាកមួយ។

ប្រតិបត្តិករត្រឡប់មកវិញប្រតិបត្តិការនៅក្នុងវិធីដែលស្រដៀងគ្នាមួយដែលមានភាពខុសគ្នាថាវាមិនត្រឹមតែផ្ដល់នូវវដ្តនៃកោះជ្វាទិន្នផលទេថែមពីវិធីសាស្រ្តដែលត្រូវបានដាក់ក្នុងវដ្តនេះ។

ការប្រើការសម្រាកដូចជាការចូលទៅកាន់គេហទំព័ររបស់

វាគួរតែត្រូវបានដោយសារក្នុងចិត្តថាគ្រាន់តែជាវដ្តនៃការសម្រាកការផ្អាកថារាងកាយដែលលោកដោយផ្ទាល់, ឧ, ប្រសិនបើអ្នកប្រើវានៅក្នុងរង្វិលជុំសំណាញ់, រង្វិលជុំខាងក្រៅនឹងមិនបញ្ឈប់ការងាររបស់ខ្លួន។ ដើម្បីធ្វើដូចនេះសេចក្តីថ្លែងការណ៍សម្រាកអាចត្រូវបានប្រើជាទម្រង់ស៊ីវិល័យនៃ Goto ។

នៅក្នុងការនិមិត្តនេះប្រតិបត្តិករនេះត្រូវបានប្រើនៅក្នុងការភ្ជាប់ជាមួយស្លាកមួយដែលអនុញ្ញាតឱ្យរៀបចំមិនត្រឹមតែជាលទ្ធផលនៃវដ្តនេះ, ប៉ុន្តែពីប្លុកលេខកូដណាមួយ។ ស្លាកនេះត្រូវបានដាក់ឈ្មោះបានត្រឹមត្រូវកំណត់អត្តសញ្ញាណជាមួយពោះវៀនធំបន្ទាប់ពីវា។ ស្លាកនេះត្រូវបានប្រកាសនៅដើមនៃប្លុកកូដដែលត្រូវបានសម្គាល់។ ដើម្បីបង្អាក់ប្រតិបត្តិនៃប្លុកដែលមានស្លាកមួយ, នៅក្នុងកន្លែងខាងស្តាំអ្នកមានដើម្បីប្រកាស: imya_metki សម្រាក។ សូមពិចារណាអំពីឧទាហរណ៍ដូចខាងក្រោមនេះ:

ក្នុងកូដនោះបានប្រកាសឈ្មោះនៃប្លុកទាំងបីជាមួយនឹងស្លាកមួយពីរនិងបីរៀងនេះ។ សេចក្តីថ្លែងការណ៍មួយជាមួយនឹងស្លាកសម្រាកពីរដែលបានបង្កប់នៅក្នុងប្លុកទាំងបីនោះទេតែវាបានបង្កឱ្យមានកម្មវិធីមួយចេញពីប្លុកទាំងបីនាក់និងពីរនាក់ហើយនឹងបន្តអនុវត្តនៅក្នុងអង្គភាពមួយ។ ឧ នៅក្នុងកុងសូលយើងនឹងបានឃើញសារពីរ: បីនិងមួយ។

សេចក្តីសន្និដ្ឋាន

យើងមានទំនាក់ទំនងជាមួយសញ្ញាណនៃវដ្តនៅក្នុង Java ខណៈពេលនិងសម្រាប់ប្រតិបត្តិករធំព្រមទាំងទម្រង់របស់ពួកគេនៃការធ្វើខណៈពេលនិងសម្រាប់គ្នា, រៀងគ្នា។ ចំពោះការយល់ដឹងប្រសើរជាងមុនយើងសូមផ្តល់អនុសាសន៍ដើម្បីធ្វើលំហាត់ប្រាណនឹងការប្រើប្រាស់ប្រតិបត្តិករទាំងនេះនៅក្នុងសំណុំបែបបទផ្សេងគ្នាដូចជាវិធីផ្សេងគ្នាដើម្បីបង្អាក់ពួកគេនិងផ្លាស់ប្តូរពីប្លុកមួយទៅមួយទៀតបាន។