កោះជ្វា: ករណីលើកលែងនិងការគ្រប់គ្រងរបស់ខ្លួន

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

នៅពេលដែលអ្នកអាចត្រូវការការដោះស្រាយករណីលើកលែង

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

ការដោះស្រាយករណីលើកលែងជ្វា

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

នៅក្នុង Java, នេះគឺត្រូវបានកំណត់ដោយចងក្រងដើម្បីចាប់ករណីលើកលែងមួយ, ដូច្នេះបញ្ហាធម្មតាត្រូវបានគេស្គាល់និងមានស្តង់ដាលំនាំការធ្វើលំហាត់ប្រាណ។

ការលើកលែងធម្មតា

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

យន្តការ Java ទៅស្ទាក់កំហុសដំណើរការមើលទៅដូចនេះ:

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

ឧទាហរណ៍សាមញ្ញបំផុតនៃការបង្កើតកំហុសមួយអាចនឹងមើលទៅដូចនេះ:

ប្រសិនបើការ (ទទេ == មួយ)

បោះ NullPointerException ថ្មី ();

នៅទីនេះអថេរមួយនេះត្រូវបានធីកនៅការចាប់ផ្ដើមពោលគឺ គឺមិនមែនថាតើសេចក្ដីយោងទៅវត្ថុទទេមួយ។ ប្រសិនបើស្ថានភាពនេះបានលេចឡើងនិងត្រូវការការដោះស្រាយពិសេសករណីលើកលែងមួយត្រូវបានបដិសេធចោលដោយបោះមួយ NullPointerException ថ្មី () ។

សេចក្ដីលម្អិតមួយចំនួនអំពីពាក្យគន្លឹះ

ពេលដែលការដោះស្រាយជាមួយនឹងករណីលើកលែងជាញឹកញាប់ជាការចាំបាច់ដើម្បីប្រើ Java ពាក្យគន្លឹះដើម្បីយោងទៅនឹងសកម្មភាពជាក់លាក់មួយ។ ភាសានេះនៃកម្មវិធីទាំងប្រាំរបស់ពួកគេ:

• សូមសាកល្បង។ ពាក្យគន្លឹះនេះត្រូវបាន ជួបប្រជុំគ្នារួចហើយនិងការផ្លាស់ប្តូរទៅជាវាមានន័យនៃកូដមួយផ្នែកដែលអាចបោះករណីលើកលែងមួយ។ ប្លុកដង្កៀបដែលមានកំណត់ {} ។
• ចាប់។ វាចាប់ប្រភេទករណីលើកលែងដែលចង់បាននិងការគ្រប់គ្រងវាបានត្រឹមត្រូវ។
• ជាចុងក្រោយ។ ពាក្យគន្លឹះនេះគឺជាជម្រើសនិងត្រូវបានប្រើដើម្បីអនុវត្តមួយដុំមួយចំនួននៃកូដដែលត្រូវបានទាមទារទោះយ៉ាងណាបើទោះបីជាករណីលើកលែងនោះទេគឺមិនត្រូវបានគេចាប់បាន។ បានបន្ថែមដោយផ្ទាល់បន្ទាប់ពីប្លុកព្យាយាម។
• បោះ - អនុញ្ញាតឱ្យអ្នកបង្កើតករណីលើកលែង Java ដែលបានពីគ្រប់ទីកន្លែង។
• បោះ - ពាក្យគន្លឹះដែលត្រូវបានដាក់នៅក្នុងការចុះហត្ថលេខាវិធីសាស្រ្តនេះ។ វាមានន័យថាកូដខាងក្រោមអាចបោះករណីលើកលែងមួយនៃប្រភេទនេះជ្វាមួយ។ សញ្ញានេះបានបម្រើការជាសញ្ញាទៅអ្នកអភិវឌ្ឍន៍ដែលត្រូវការត្រូវបានដោយសារក្នុងចិត្តមួយ - វិធីសាស្រ្តនេះមិនអាចធ្វើការបានដូចការរំពឹងទុករបស់គាត់។

ចាប់សាកល្បងជាមួយ

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

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

កូដធម្មតាបំផុតដើម្បីឯកតាដំណើរការគឺមានដូចខាងក្រោម:

ព្យាយាម {

// ខាងក្រោមនេះគឺជាកូដមួយចំនួនដែលអាចបង្កើតករណីលើកលែងមួយ

} ចាប់ (identifikator_1 Tip_isklyucheniya_1) {

// នៅទីនេះគឺមានការដោះស្រាយករណីលើកលែង, តាមប្រភេទនិងលក្ខខណ្ឌរបស់ខ្លួន;

} ចាប់ (identifikator_2 Tip_isklyucheniya_2) {

// នៅទីនេះគឺមានការដោះស្រាយករណីលើកលែង, តាមប្រភេទនិងលក្ខខណ្ឌរបស់ខ្លួន;

}

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

ជាចុងក្រោយ

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

ផែនការនេះបង្ហាញពីការចាប់ប្លុកជាច្រើនបានបង្កើតវិធីសាស្រ្តចាប់ករណីលើកលែង។ ឧទាហរណ៍កូដដែលមាននៅក្នុងការព្យាយាមបង្កើតស្ថានភាពដែលមិនរំពឹងទុកមួយដូចជាត្រជាក់។ បន្ទាប់មកកុងសូលនឹងត្រូវបានបង្ហាញបញ្ចេញមតិ«ចាប់ត្រជាក់! »ហើយ«តើនោះជាអ្វីមួយដើម្បីលើកទឹកចិត្តអំពីអ្វី? »។ នោះគឺជា, ប្លុកទីបំផុតត្រូវបានប្រតិបត្តិក្នុងករណីណាមួយ។

នៅក្នុងការពិតវិធីមួយដើម្បីចៀសវាងការបង្កឱ្យមានទីបំផុតនៅទីនោះ។ វាត្រូវបានភ្ជាប់ជាមួយនឹងការបញ្ចប់នៃម៉ាស៊ីននិម្មិត។ រកឃើញរបៀបដើម្បីអនុវត្តវា, វាគឺអាចធ្វើបាននៅលើចន្លោះអ៊ីនធឺណិតបើកទូលាយ។

ពាក្យគន្លឹះបោះ

បាល់បោះបង្កើតករណីលើកលែងមួយ។ វាក្យសម្ព័ន្ធរបស់ខ្លួនគឺមានដូចខាងក្រោម:

បោះ NewException ថ្មី ();

មានត្រូវបានបង្កើតឡើងជាករណីលើកលែងថ្មីទៅប្រភេទ NewException នេះ () ។ ជាប្រភេទអាចត្រូវបានប្រើជាត្រូវបានរួមបញ្ចូលរួចហើយនៅក្នុងថ្នាក់បណ្ណាល័យជ្វាស្តង់ដារនិងបានកំណត់ពីមុនដោយអ្នកអភិវឌ្ឍន៍នៃការផលិតរបស់ខ្លួន។

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

ពាក្យគន្លឹះបោះ

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

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

សូមព្យាយាមដើម្បីធនធាន

កម្មវិធី Java កំណែ 7 អ្នកអភិវឌ្ឍន៍បានរួមបញ្ចូលជាមួយការច្នៃប្រឌិតធំជាប្លុកការព្យាបាលសាកល្បងជាមួយនឹងធនធាន។

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

ថ្នាក់ផ្ទាល់ខ្លួនករណីលើកលែងជ្វា

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

វិធីសាមញ្ញបំផុតដើម្បីបង្កើត - ដើម្បីឱ្យបានទទួលពីសមស្របបំផុតទៅនឹងបរិបទរបស់វត្ថុ។

មានកើតឡើងទៅទទួលមរតកពីករណីលើកលែង, ថ្នាក់ដែលត្រូវបានប្រើដើម្បីកំណត់ករណីលើកលែងផ្ទាល់ខ្លួនរបស់អ្នក។ ក្នុង MyException មានផលិតពីរ - លំនាំដើម, ទីពីរ - មានប្រភេទសារខ្សែអក្សរអាគុយម៉ង់។

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

វិធីសាស្ត្រទីពីរគឺខុសគ្នាបន្តិចពីមួយទៅមួយដំបូងដែលអ្នកបង្កើតករណីលើកលែងពេលមួយនោះវាត្រូវបានអនុម័តប៉ារ៉ាម៉ែត្រខ្សែអក្សរមួយដែលនឹងត្រូវបានឆ្លុះបញ្ចាំងនៅក្នុងកុងសូលនៅចាប់។ នៅក្នុងមេវាច្បាស់ណាស់ថាច () និងក្រាម () ត្រូវបានដាក់ក្នុងការត្រួតពិនិត្យសាកល្បងនិងផលនេសាទពាក្យគន្លឹះដែលបានកំណត់រចនាសម្ព័ន្ធក្នុងការចាប់យក MyException ។ លទ្ធផលនៃដំណើរការនេះគឺដើម្បីបង្ហាញសារកំហុសទៅកុងសូល:

ដូច្នេះវាបានចូលមកដើម្បីបន្ថែមករណីលើកលែងកោះជ្វា, ដោយដៃរបស់គាត់ផ្ទាល់។

ករណីលើកលែងស្ថាបត្យកម្ម

ដូចជាជាមួយនឹងវត្ថុទាំងអស់នៅក្នុងកោះជ្វា, ករណីលើកលែងត្រូវបានទទួលឥទ្ធិពលនិងមានរចនាសម្ព័នឋានានុក្រម។ ធាតុ root នៃកំហុសទាំងអស់បានបដិសេធចោលក្នុងភាសាសរសេរកម្មវិធីនេះគឺថ្នាក់ java.lang.Throwable ។ បានទទួលឥទ្ធិពលពីលោកពីរប្រភេទ - កំហុសនិងករណីលើកលែង។

កំហុស - សញ្ញាកំហុសធ្ងន់ធ្ងរនិងជាករណីលើកលែង Java ដែលបានធីក។ ស្កាត់និងដំណើរការទិន្នន័យបែបនេះក្នុងករណីជាច្រើនបានកើតឡើងនៅក្នុងដំណាក់កាលរចនានិងមិននៅក្នុងតម្រូវការនៃការណែនាំនៅក្នុងកូដកម្មវិធីចុងក្រោយ។

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

ជាញឹកញាប់មានករណីលើកលែង

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

• ArithmeticException ។ ទាំងនេះរួមបញ្ចូលទាំងកំហុសបានផ្សារភ្ជាប់ជាមួយនឹងការប្រតិបត្ដិនព្វន្ធ។ ឧទាហរណ៍មើលឃើញបំផុត - ផលចែកនឹងសូន្យនោះ។
• ArrayIndexOutOfBoundsException - បណ្តឹងឧទ្ធរណ៍ទៅចំនួនធាតុអារេដែលលើសពីចំនួនសរុបនៃប្រវែងរបស់ខ្លួនមួយ។
• ArrayStoreException - ការប៉ុនប៉ងដើម្បីកំណត់ប្រភេទធាតុមិនឆបគ្នានៃអារេនេះ។
• ClassCastException - ការប៉ុនប៉ងដើម្បីនាំយកមកនូវការខុសប្រភេទមួយទៅមួយទៀតបាន។
• IllegalArgumentException - ការប្រើអាគុយម៉ង់ខុសក្នុងការហៅវិធីសាស្រ្តនេះ។
• NegativeArraySizeException - ករណីលើកលែងនៅពេលដែលអ្នកបង្កើតអារេនៃទំហំអវិជ្ជមានមួយ។
• NullPointerException - ការប្រើប្រាស់ឯកសារយោងទទេ។
• NumberFormatException - កើតឡើងនៅពេលការបម្លែងខ្សែអក្សរមួយដែលខុសទៅនឹង integer ។
• UnsupportedOperationException - ប្រតិបត្តិការមិនត្រូវបានគាំទ្រ។

ឧទាហរណ៍ទាំងនេះតំណាងឱ្យប្រភេទនៃការលើកលែងជ្វាដែលមិនបានធីក។ ប៉ុន្ដែមើលទៅបានគូសធីក:

• រកមិនឃើញថ្នាក់ - ClassNotFoundException ។
• IllegalAcccessException - ដាក់កម្រិតការចូលដំណើរការទៅកាន់ថ្នាក់។
• InterruptedException - ការរំខាននៃលំហូរនេះ។
• NoSuchFieldException - មិនមានវាលដែលត្រូវការ។

ការបកស្រាយករណីលើកលែងនេះ

និយាយពីករណីលើកលែងជួបប្រទះជាញឹកញាប់គួរតែត្រូវបានកត់សម្គាល់ឃើញថាការបកស្រាយរបស់ខ្លួននៅក្នុងការរចនា, អាចត្រូវបានដឹងថាមិនត្រឹមត្រូវ។ បន្ទាប់គឺជាបញ្ជីខ្លីពន្យល់លម្អិតបន្ថែមទៀត, ដែលជាកន្លែងដែលវាអាចជាស្ថានភាពដែលមិនរំពឹងទុក។

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

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

ការរកឃើញ

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

ជាការពិតណាស់នៅក្នុងកម្មវិធីសាមញ្ញច្រើនឬតិចក្នុងការតាមដានស្ថានភាពមិនប្រក្រតីកាន់តែងាយស្រួល។ ប៉ុន្តែនៅក្នុងអគារស្វ័យប្រវត្តិធំសម្រាប់ពីរបីរយពាន់បន្ទាត់វាគឺអាចធ្វើបានតែប៉ុណ្ណោះដែលជាលទ្ធផលនៃការធ្វើតេស្តរយៈពេលវែងនិងបំបាត់កំហុសមួយ។

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