Java: გამონაკლისი და მათი დამუშავება

ნებისმიერი პროგრამა იმუშავებს სტაბილურად მხოლოდ იმ შემთხვევაში, კოდის debugged და არ არსებობს პირობები, რომელიც შეიძლება გამოიწვიოს გაუთვალისწინებელი სიტუაციებისთვის. პროცესი catching შესაძლო წარუმატებლობის ხორციელდება პროგრამირების ეტაპზე. ამისათვის, დეველოპერი ითვალისწინებს ყველა მოსალოდნელ შედეგებზე და ცდილობს შეზღუდოს ეფექტი შეცდომა ისე, რომ ვერ უშლის ოპერაციის პროგრამა, ან გამოიწვიოს მისი დაშლის.

როდესაც თქვენ უნდა გამონაკლისი გატარება

ჯავაში, გამონაკლისი შეიძლება იყოს გამოწვეული არასწორი მომხმარებლის input, არ სჭირდება რესურსი ან მოულოდნელი ქსელის გათიშვა პროგრამა. კომფორტულად მიერ განაცხადის დეველოპერი, თქვენ უნდა აკონტროლოთ კლების საგანგებო სიტუაციებში. სამომხმარებლო უნდა არ უნდა ველოდოთ, რათა განაცხადი, დასაკარგი მონაცემების შედეგად შეუქცევადი გამონაკლისი, ან მხოლოდ ნაწილი გაგზავნა, როგორც ჩანს, სადაც ნათქვამია, რომ რაღაც გაფუჭდა.

ამოღებულია Java გამონაკლისი

რა უნდა გავითვალისწინოთ? ჯავის ენაზე აქვს საკუთარი ჩაშენებული გამონაკლისი გატარება ფუნქცია. რა თქმა უნდა, დიდი პროცენტული შეცდომა დააფიქსირა ერთი კრებული ეტაპზე, სისტემა ავტომატურად გაცნობებთ, რომ გამოიყენოს იგი აღარ არის შესაძლებელი. მაგრამ არსებობს ამ სახის გამონაკლისი, რომელიც ხდება runtime. დეველოპერი უნდა შეეძლოს, რომ მოსალოდნელია და შეიმუშავებს კოდი ისე, რომ არ გამოიწვიოს შეცდომა, და სიფრთხილით სპეციალური გზა და გადასცა კონტროლი სხვა ფილიალში.

ჯავაში, ეს დაკისრებული შემდგენელი დაჭერა გამონაკლისი, ასე რომ ტიპიური პრობლემები ცნობილია და აქვს სტანდარტული exercise ნიმუშები.

ტიპიური შეზღუდვა

მარტივი მაგალითი, რომელშიც თქვენ შეგიძლიათ მიიღოთ გამონაკლისი - ეს დაყოფა. მიუხედავად მისი სიმარტივის თვალსაზრისით, როგორც divider, შეიძლება ნულოვანი, რომელიც გამოიწვევს შეცდომა. ისე, თუ ეს შესაძლებელია პროგნოზირება გაჩენის წარსული და თავიდან აცილების მიზნით. თუმცა, ეს ვარიანტი ყოველთვის არ არის შესაძლებელი, ასე რომ ექმნება გამონაკლისი უნდა იყოს ორგანიზებული უშუალოდ იმ შემთხვევაში, "ნულზე გაყოფის".

ჯავის მექანიზმი ჩაჭრა დამუშავების შეცდომა ასე გამოიყურება:

• ბევრი გამონაკლისი ობიექტის შექმნა, ისევე როგორც ნებისმიერი სხვა;
• ბუნებრივი გადაცემის მსვლელობისას გაწყდება;
• გამორიცხვა მექანიზმი ცდილობს ალტერნატიული გზა გააგრძელოს კოდი;
• უსაფრთხო აღსრულების პროგრამა პროცესორი, სამუშაო და აღდგენილი, ან მოხდება რეალიზაციის გამონაკლისი სპეციალური გზა.

უმარტივესი შექმნის შეცდომა შეიძლება ასე გამოიყურება:

თუ (ა == null)

იმისათვის, რომ ახალი NullPointerException ();

აქ, ცვლადი არის შემოწმდება ინიციალიზაციისას, ანუ, არის თუ არა მინიშნება null ობიექტი. თუ ეს სიტუაცია წარმოიშვა და უნდა სპეციალური დამუშავება, გამონაკლისი დააგდეს ჩააგდოს new NullPointerException ().

რამდენიმე დეტალი სიტყვა

როდესაც საქმე გამონაკლისი ხშირად აუცილებელია გამოიყენოთ სიტყვით Java ეხება კონკრეტული სამოქმედო. ეს ენა მათი ხუთ პროგრამირება:

• ცდილობენ. ამ სიტყვით არის უკვე შეხვდნენ, და ეს იმას ნიშნავს გარდამავალი მონაკვეთი კოდი, რომელიც შეიძლება ჩააგდოს გამონაკლისი. Block შეზღუდული braces {}.
• Catch. ეს აკეთებს სასურველი გამონაკლისი ტიპის და გაუმკლავდეს მას სათანადოდ.
• და ბოლოს. ამ სიტყვით ნებაყოფლობითია და გამოიყენება შეასრულოს გარკვეული ნაჭერი კოდი, რომელიც აუცილებელია, მიუხედავად იმისა რომ არ არის გამონაკლისი არ არის დაჭერილი. დაამატა პირდაპირ შემდეგ ლელო ბლოკი.
• განშლის - საშუალებას გაძლევთ შექმნათ Java გამონაკლისი ყველგან.
• დაყრის - სიტყვით, რომელიც მოთავსებულია მეთოდი ხელმოწერა. ეს ნიშნავს, რომ შემდეგი კოდი შეიძლება ჩააგდოს გამონაკლისი ამ ტიპის Java. ამ ნიშნის ემსახურება როგორც სიგნალი დეველოპერები, რომ უნდა წარმოქმნილი გათვალისწინებით - მეთოდი შეიძლება არ იმუშაოს მას.

გამოჭერის ლელო

გამოსვლის ჯავის გამონაკლისის გარდა, ბუნებრივია, ვარაუდობს, რომ ეს იქნება სიფრთხილით სპეციალურ გზა. ყველაზე მოსახერხებელი გზა ამის გაკეთება, თუ კოდი სექცია შემოღობილი ბლოკი. რომელიც შეიძლება შეიცავდეს გამონაკლისი. როდესაც თქვენ აწარმოებს ამ კოდი, ვირტუალური მანქანა ნახავთ მოულოდნელი სიტუაცია, მესმის, რომ არსებობს კრიტიკული ბლოკი და გადარიცხვების კონტროლს სადგური დამუშავება.

ჯავის კოდი გახვეული სპეციალური ბლოკი ლელო, რომლის ფარგლებშიც შეიძლება იყოს გამონაკლისი. ამგვარად, მან რამდენიმე გაუთვალისწინებელი სიტუაციების, რომელიც იქნება დაჭერილი იმავე ადგილას, არა raspolzayas კოდი.

ყველაზე ტიპიური კოდი დამუშავება ერთეული ასეთია:

სცადეთ {

// აქ არის რამდენიმე კოდი, რომელიც შეიძლება გენერირება გამონაკლისი

} Catch (Tip_isklyucheniya_1 identifikator_1) {

// აქ არის გამონაკლისი გატარება, მისი ტიპის და პირობები;

} Catch (Tip_isklyucheniya_2 identifikator_2) {

// აქ არის გამონაკლისი გატარება, მისი ტიპის და პირობები;

}

საკვანძო catch იუწყება, რომ კოდი და სკანირების ეს გამონაკლისი, განიხილება, როგორც აღწერილია ქვემოთ, იმ პირობით, რომ იგი აკმაყოფილებს მისი ტიპის. იდენტიფიკატორი შეიძლება გამოყენებულ იქნას დამუშავების კოდი ბლოკი არგუმენტები.

ბოლოს

როგორც ცნობილი გახდა, წინა თავი, catch ბლოკის დაჭერა გამონაკლისი და გადაამუშავებს მათ. მაგრამ ძალიან ხშირად სიტუაცია ჩნდება, სადაც უნდა აწარმოებს რამდენიმე კოდი, მიუხედავად იმისა, ისინი დაიჭირეს შეცდომები. ამისათვის არსებობს სიტყვით საბოლოოდ. იგი გამოიყენება გაზრდის ღირებულებები სხვადასხვა მრიცხველები, დახურვის ფაილი ან ქსელის კავშირები.

ეს ნაკვეთი არის რამდენიმე catch ბლოკის გამოიგონა მეთოდები დაჭერა გამონაკლისი. მაგალითად, კოდი შეიცავს ლელო წარმოშობს მოულოდნელი სიტუაცია, როგორიცაა ცივი. ამის შემდეგ, console იქნება ნაჩვენები expression «დაიჭირეს ცივი!» და «არის, რომ რაღაც გულშემატკივრობენ შესახებ?». რომ არის, საბოლოოდ ბლოკი ამუშავდა ნებისმიერ შემთხვევაში.

ფაქტობრივად, ისე, რომ თავიდან ავიცილოთ გამოიწვია საბოლოოდ იქ. ეს დაკავშირებულია დასრულების ვირტუალური მანქანა. მოძებნა, თუ როგორ უნდა განახორციელოს იგი, შესაძლებელია ინტერნეტში ღია სივრცეებს.

განშლის სიტყვით

განშლის ქმნის გამონაკლისი. მისი სინტაქსი ასეთია:

იმისათვის, რომ ახალი NewException ();

იქმნება ახალი გამონაკლისი ტიპის NewException (). როგორც სახის შეიძლება გამოყენებულ იქნას უკვე შედის სტანდარტული Java ბიბლიოთეკა კლასების და წინასწარ განსაზღვრული დეველოპერი საკუთარი წარმოების.

ეს დიზაინი არის ნაწილი აღწერა ნებისმიერი მეთოდი, რომელიც ზარის შემდეგ უნდა მოხდეს ლელო ბლოკი, რათა შეძლებთ ჩაჭრა იგი.

საკვანძო აგდებს

რა მოხდება, თუ ამ პროცესში განვითარების სიტუაცია, სადაც მეთოდი შეიძლება ჩააგდოს გამონაკლისი, მაგრამ არ შეუძლია გაუმკლავდეს სწორად. ამ მიზნით, ამ მეთოდის ხელმოწერა განსაზღვრავს სიტყვა ისვრის და ტიპის გამონაკლისი.

ეს იარლიყი არის ერთგვარი მაჩვენებელი კლიენტს დეველოპერები, რომ საშუალებას არ შეუძლია გაუმკლავდეს მათ იგივე გამონაკლისი. გარდა ამისა, თუ შეცდომა ტიპის შეამოწმა, მაშინ კომპილატორი აიძულებს პირდაპირ ითხოვენ.

სცადეთ რესურსები

ჯავის ვერსია 7 დეველოპერები არ შედის ძირითადი ინოვაცია, როგორც მკურნალობის ლელო ბლოკი რესურსები.

ბევრი ობიექტი იქმნება Java, გამოყენების შემდეგ უნდა დახურეს შენარჩუნებას რესურსები. მანამდე მას ჰქონდა გაითვალისწინოს და შეწყვიტოს ამ შემთხვევაში ხელით. ახლა, თუმცა, ისინი გამოჩნდნენ AutoClosable ინტერფეისი. იგი ეხმარება ავტომატურად დაიხურება უკვე გამოიყენება ობიექტების განთავსებული ლელო ბლოკი. ამ მიდგომის გახდა უფრო მოსახერხებელი დაწერა კოდი თავის readability მნიშვნელოვნად გაიზარდა.

საკუთარი კლასები Java გამონაკლისი

შემქმნელები აღწერილი პროგრამირების ენის გაითვალისწინა მრავალი ასპექტი დიზაინი საგანგებო სიტუაციები. თუმცა, ყველა ვარიანტი, რომ თავიდან ავიცილოთ შედეგს მოვლენების არ იმუშავებს, ასე Java განხორციელებული უნარი განსაზღვროს საკუთარი გამონაკლისის გარდა, ეს არის მიზანშეწონილი საჭიროებებს კონკრეტული კოდი.

უმარტივესი გზა შექმნა - მემკვიდრეობით ყველაზე შესაბამისი ობიექტი კონტექსტში.

იქ მოხდა მემკვიდრეობით გამონაკლისი, კლასი, რომელიც გამოიყენება განსაზღვროს საკუთარი გამონაკლისი. In MyException აქვს ორი მშენებლები - რა, მეორე - არგუმენტი msg ტიპის სიმებიანი.

ამის შემდეგ, საჯარო კლასის FullConstructors განხორციელებული მეთოდი f, რომელიც შეიცავს ხელმოწერა აგდებს MyException. ამ სიტყვით ნიშნავს, რომ f შეიძლება ჩააგდოს მოსწონს Java MyException გამონაკლისი. ამასთან, ამ მეთოდით სხეულის წარმოებული ტექსტური ინფორმაციის output კონსოლისთვის თავად და ფაქტობრივი თაობის MyException მიერ ჩააგდოს.

მეორე მეთოდი არის ოდნავ განსხვავებული, პირველი, რომ, როდესაც თქვენ გამონაკლისი, იგი გავიდა სიმებიანი პარამეტრი, რომელიც უნდა აისახოს console გამოჭერის. ძირითად ნათელია, რომ f () და g () თავსდება სცადეთ შემოწმების და სიტყვით catch კონფიგურაცია ხელში MyException. შედეგი დამუშავება არაა შეცდომა კონსოლი:

ისე მოხდა, რომ დაამატოთ Java გამონაკლისის გარდა, საკუთარი ხელით.

არქიტექტურა გამონაკლისი

როგორც ყველა ობიექტების Java, გამონაკლისი ასევე მემკვიდრეობით და იერარქიული სტრუქტურა. ძირეული ელემენტი ყველა შეცდომები დააგდეს ამ პროგრამირების ენა არის კლასის java.lang.Throwable. მემკვიდრეობით მას ორი სახის - შეცდომა და გამონაკლისი.

შეცდომა - გვიჩვენებს კრიტიკული შეცდომა და გადაუმოწმებელი Java გამონაკლისი. ხელში ჩაგდება და დამუშავება, როგორიცაა მონაცემთა უმეტეს შემთხვევაში ხდება დაპროექტების ეტაპზე და არ სჭირდება შემოღების საბოლოო განცხადების კოდი.

ყველაზე ხშირად გამოყენებული კლასის შექმნა და ანალიზის გამონაკლისია გამონაკლისი. რაც, თავის მხრივ, იყოფა რამდენიმე ფილიალი, მათ შორის RuntimeException. By RuntimeException არიან runtime გამონაკლისის გარდა, რომ არის, ხდება დროს პროგრამა. ყველა კლასების მისგან არიან unverifiable.

ხშირად არსებობს გამონაკლისი

ჯავის გამონაკლისის გარდა, სიაში, რომელიც წარმოდგენილია ქვემოთ, რომლებიც ყველაზე ხშირად გამოყენებული, ასე რომ თქვენ უნდა აღწერს თითოეული მათგანი დეტალურად:

• ArithmeticException. ესენია შეცდომები დაკავშირებული არითმეტიკული ოპერაციების. ყველაზე ნათელი მაგალითია - სამმართველოს მიერ ნულოვანი.
• ArrayIndexOutOfBoundsException - მიმართვა მასივი ელემენტს ნომერი, რომელიც აღემატება მისი სიგრძე.
• ArrayStoreException - მცდელობა მივანიჭოთ შეუთავსებელი ელემენტს ტიპის მასივი.
• ClassCastException - მცდელობა არასწორი ერთი ტიპის სხვა.
• IllegalArgumentException - გამოყენებით არასწორი არგუმენტი მეთოდი ზარი.
• NegativeArraySizeException - გამონაკლისი, როდესაც თქვენ შექმნათ მასივი უარყოფითი ზომა.
• NullPointerException - გამოყენებული მითითება null.
• NumberFormatException - ხდება, როდესაც არასწორი string კონვერტაციის რიცხვი.
• UnsupportedOperationException - ოპერაცია არ არის მხარდაჭერილი.

ეს მაგალითები წარმოადგენს სახის გადაუმოწმებელი Java გამონაკლისი. მაგრამ ასე გამოიყურება შემოწმება:

• ClassNotFoundException - კლასი არ არის ნაპოვნი.
• IllegalAcccessException - შეზღუდოს ხელმისაწვდომობა კლასში.
• InterruptedException - შეწყდეს ნაკადი.
• NoSuchFieldException - არ არსებობს აუცილებელი ველი.

ინტერპრეტაცია გამონაკლისი

საუბრისას ხშირად გვხვდება გამონაკლისი უნდა აღინიშნოს, რომ მათი ინტერპრეტაცია დიზაინი, შეიძლება აღქმულ იქნეს არასწორად. შემდეგი არის მოკლე ჩამონათვალი, თუ რატომ უფრო დეტალურად, სადაც არ შეიძლება იყოს მოულოდნელი სიტუაცია.

NullPointerException. ძალიან პირველი შემთხვევა, როდესაც არსებობს გამონაკლისი, არის მიმართოს მინიშნება ობიექტი, რომელიც უდრის null. იგი ასევე ვრცელდება ნულოვანი კლასის მაგალითად მეთოდები. NullPointerException შეიძლება დააგდეს შემთხვევაში მოპოვების თანაბარი სიგრძის null მასივი. თავიდან აცილების მიზნით, ასეთ სიტუაციაში პერიოდულად შეამოწმეთ საიტები null.

ArrayIndexOutOfBoundsException. ნებისმიერი პროგრამის გარეშე ვერ იარსებებს გამოყენების მასივები. შესაბამისად, ხშირად შეიკრიბონ ეს შეიძლება და შეცდომა. გამონაკლისი ხდება, როდესაც დეველოპერი ცდილობს, რათა შეამოწმონ მასივი ელემენტს, რომელიც არ არის ინდექსი სიაში. მაგალითად, მოთხოვნილი მნიშვნელობა ზემოთ ან ქვემოთ ნულოვანი სიგრძე. ძალიან ხშირად არის შედეგი იმისა, რომ მასივი იწყება ანგარიში ნულოვანი.

შედეგები

ამოღებულია Java გამონაკლისი - ძლიერი ინსტრუმენტი გარემო, რომელიც მნიშვნელოვნად ამარტივებს მუშაობის პროგრამისტი და საშუალებას აძლევს მას შექმნას სუფთა და მოკლებულია კოდი შეცდომები. თუ როგორ გლუვი და სტაბილური ფუნქციონირების პროგრამა დამოკიდებულია სტატუსი და რეპუტაცია დეველოპერი.

რა თქმა უნდა, მეტ-ნაკლებად მარტივი პროგრამების კვალი პათოლოგიური სიტუაციებში ბევრად უფრო ადვილია. მაგრამ დიდი ავტომატური კომპლექსების რამდენიმე ასეული ათასი ხაზები ეს შესაძლებელია მხოლოდ შედეგად გრძელვადიანი ტესტირების და გამართვის.

ჯავის გამონაკლისი შეცდომა, რომელიც წარმოიქმნება ზოგიერთი პროგრამები, ზოგიერთი კომპანიების გთავაზობთ ჯილდო, როდესაც ისინი ენთუზიასტებს. განსაკუთრებით დასაფასებელია ის, რომ გამოიწვიოს დარღვევა უსაფრთხოების პოლიტიკის პროგრამული უზრუნველყოფა.