Java- ի բացառություններ և ինչպես վարվել դրանց հետ

Որպես Java մշակող, դուք պետք է լավ տիրապետեք Java- ի բացառություններին և բացառությունների մշակմանը:

Այս ձեռնարկը տալիս է հիմնական գիտելիքները, որոնք յուրաքանչյուր ծրագրավորող պետք է ունենա Java ծրագրերի հետ աշխատելիս: Սկսելու համար եկեք սկսենք հասկանալ, թե կոնկրետ ինչ են Java- ի բացառությունները:



Որոնք են Java բացառությունները

Java ծրագիրը կարող է բախվել այնպիսի խնդիրների, որոնք հանգեցնում են նրան, որ դրա կատարման ընթացքում ծրագիրը կտրուկ դադարեցվում է: Այս խնդիրները կոչվում են բացառություններ:


Լավ ծրագրավորողը պետք է կարողանա ճանաչել կատարման ընթացքում առաջացող սխալները և այդպիսի բացառության դեպքում ծրագրի այլընտրանքային երթուղիներ տրամադրել: Այս պրակտիկան կոչվում է բացառությունների վարում:

Այժմ դուք կարող եք մտածել, թե ինչու մեզ ընդհանրապես բացառությունների մշակման կարիք կա: Ինչու՞ չգրվել այնպիսի ծրագրեր, որոնք բացառություններ չեն գցի:




Ինչու է մեզ անհրաժեշտ բացառությունների մշակումը

Ինչպես պարզվեց, բացառություններ չթողնող ծրագրեր գրելը այնքան էլ հեշտ չէ, որքան թվում է: Unամանակի մեծ մասում այս անխուսափելի սխալները դուրս են գալիս ծրագրավորողի վերահսկողությունից:

Userրագրերը, որոնք ընդունում են օգտագործողի մուտքագրումը, հակված են բացառությունների հանդիպելուն ՝ օգտագործողի կողմից տրամադրվող անվավեր մուտքի պատճառով: Արտաքին ֆայլեր կարդալը նույնպես հաշվի առնելով այն հնարավորությունը, որ դրանք տեղափոխվել են, վերանվանվել կամ ջնջվել են արտաքին աղբյուրի կողմից ՝ առանց ծրագրավորողի գիտության:

Նման դեպքերում ծրագիրը պետք է կարողանա նրբագեղորեն կարգավորել բացառությունը ՝ առանց կատարումը դադարեցնելու:



Java բացառությունների հիերարխիա

Java- ի բոլոր բացառությունները պետք է լինեն Exception - ի զավակ դաս, որն ինքնին Throwable | -ի զավակ է դասարան


Exception Երկու հիմնական ենթադաս դաս են RuntimeException եւ IOException.



Բացառություն ընդդեմ սխալի

Throwable Մանկական մեկ այլ դաս դասը Error դասարան Այնուամենայնիվ, սխալները տարբերվում են բացառություններից:

Սխալները ցույց են տալիս այն խնդիրները, որոնք JVM- ն կարող է բախվել կատարման ընթացքում: Սովորաբար այս խնդիրները կրիտիկական են և անուղղելի: Հիշողության արտահոսքը և գրադարանի անհամատեղելիության խնդիրները ծրագրերում սխալների ընդհանուր պատճառներն են:

StackOverflowError եւ OutOfMemoryError Java սխալների երկու օրինակ են:




Ստուգված և չստուգված բացառություններ

Մենք կարող ենք բաժանել Java բացառությունները երկու հիմնական կատեգորիաների. ստուգվում և չստուգված բացառություններ:

Ստուգված բացառությունները բացառություններ են, որոնք պետք է մշակվեն ծրագրում նախքան կազմելը: Եթե ​​այս բացառությունները չեն մշակվում, ապա ծրագիրը չի կազմվի Java կազմողի կողմից: Հետեւաբար, դրանք կոչվում են նաև կազմման ժամանակի բացառություններ: IOExceptions ստուգված բացառությունների լավ օրինակներ են:

Չստուգված բացառությունները բացառություններ են, որոնք կազմողը անտեսում է ծրագիրը կազմելիս: Whetherրագրում մենք գործածել ենք այս բացառությունները, թե ոչ, նշանակություն չունի, երբ կազմվում է ծրագիրը: Քանի որ բացառությունների մշակումը չի կիրառվում այդ բացառությունների վրա, մեր ծրագիրը կարող է բախվել RuntimeExceptions որոնք հանգեցնում են ծրագրի դադարեցմանը:

Բոլոր դասերը, որոնք տարածում են RuntimeException դասը չստուգված բացառություններ են: Նման դասերի երկու օրինակ են NullPointerException եւ ArrayIndexOutOfBoundsException.




Բացառության դասում սովորաբար օգտագործվող մեթոդներ

Մենք կանցնենք Java- ի Exception սովորաբար օգտագործվող մի քանի մեթոդների դասարան:

  1. getMessage. վերադարձնում է հաղորդագրություն, որը պարունակում է մանրամասներ տեղի ունեցած բացառության մասին:
  2. printStackTrace. վերադարձնում է տեղի ունեցած բացառության կույտի հետքը:
  3. toString. վերադարձնում է դասի անունը և հաղորդագրությունը, որը վերադարձվում է getMessage - ով մեթոդ


Ինչպես կարգավորել բացառությունները

Եկեք տեսնենք, թե ինչպես կարող ենք գործածել բացառությունները Java- ում.

փորձել-բռնել

Մենք կարող ենք բացառություններ գտնել և պատշաճ կերպով կարգավորել դրանք ՝ օգտագործելով a փորձել-բռնել բլոկ Java- ում:

Այս շարահյուսության մեջ ծածկագրի այն մասը, որը հակված է բացառություն նետելուն, տեղադրվում է փորձի բլոկի ներսում, և բռնում բլոկը / բլոկները բռնում են նետված բացառությունը / բացառությունները և կարգավորում դրանք ըստ մեր տրամադրած տրամաբանության:


Փորձ-բռնելու բլոկի հիմնական շարահյուսությունը հետևյալն է.

try {
//exception-prone code } catch(Exception e) {
//error handling logic }

Այս մոտեցմամբ, ծրագիրը չի դադարում կատարումը, երբ բացառությունը գցում է ծրագիրը, փոխարենը այն նրբորեն վարվում է:

Մենք կտեսնենք, թե ինչպես կարգավորել IOExceptions նետված է FileReader դաս Java ծրագրում:

Օրինակ:

import java.io.FileReader; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();
}
catch(Exception e) {

e.printStackTrace();
}
} }

Այստեղ մենք օգտագործել ենք մեկ որսման բլոկ `FileNotFoundException - ի կարգավորման համար նետված, երբ FileReader | դասի եւ IOException նետված է read() | _ | _ | | մեթոդը դասարան

Այս երկու բացառություններն էլ FileReader - ի երեխաներ են դասարան

Կարող ենք նաև օգտագործել բռնելու բազմաթիվ հայտարարություններ `մեկ այլ փորձի հայտարարության մեջ ծածկված կոդի կողմից նետված տարբեր տեսակի սխալների հայտնաբերման համար: Նախորդ օրինակի համար մենք կարող ենք օգտագործել մեկ բռնող բլոկ `Exception - ը բռնելու համար և մեկ այլ բռնելու բլոկ `FileNotFoundException -ի համար ինչպես ցույց է տալիս կոդի հետևյալ հատվածը.

IOException

Եթե ​​նետված բացառությունը համընկնում է առաջին բռնելու հայտարարության հետ վարվող բացառության, ապա այն վարվում է առաջին բռնելու հայտարարության տրամաբանության միջոցով:

Եթե ​​բացառությունները չեն համընկնում, ապա այն փոխանցվում է երկրորդ բռնելու հայտարարությանը: Եթե ​​կան ավելի քան երկու բռնում հայտարարություններ, այս գործընթացը շարունակվում է այնքան ժամանակ, մինչև բացառությունը հասնի որևէ նշանի, որը որակում է իր տեսակը:

Քանի որ import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();

file.close();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
} }
FileNotFoundException ենթատիպն է `օգտագործելով 2-րդ բռնելու հայտարարությունը` IOException բռնելու համար չի աշխատի Այն մշակվելու է բռնելու առաջին հայտարարության միջոցով և երբեք չի հասնի 2-րդ հայտարարությանը:

Նշում:Պարտադիր է առնվազն մեկ բռնել հայտարարություն փորձել հայտարարությամբ:

վերջապես

Երբ մենք օգտագործում ենք ա փորձել-բռնել մեր ծրագրում բացառություններ բռնելու համար արգելափակում կա, կան դեպքեր, երբ մենք ուզում ենք ինչ-որ տրամաբանություն իրականացնել `չնայած բացառությանը բռնվեց, թե ոչ: Նման դեպքերում մենք կարող ենք օգտագործել ա փորձել-բռնել-վերջապես արգելափակել պարզապես a- ի փոխարեն փորձել-բռնել արգելափակել

Հետո, ծածկագիրը FileNotFoundException - ի ներսում հայտարարությունն իրականացվում է անկախ նրանից, թե բացառություն է տեղի ունենում: finally հայտարարությունը միշտ պետք է գա try-catch-վերջապես բլոկի վերջում:

Օրինակ, երբ մենք օգտագործում ենք finally ֆայլ կարդալու դասի համար անհրաժեշտ է փակել բացված ֆայլը վերամշակման ավարտին `բացառություն է տեղի ունենում, թե ոչ: Դա ապահովելու համար մենք կարող ենք ծածկագիրը տեղադրել ֆայլը փակելու համար FileReader | հայտարարություն

finally

Այնուամենայնիվ, եթե փորձեք կազմել վերոնշյալ կոդը, կոդը չի կազմվի չկարգավորված import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;
try {

file = new FileReader('source.txt');

file.read();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
finally {

file.close();
}
} }
. Դա պայմանավորված է նրանով, որ IOException | _ | _ | | մեթոդը դասը կարող է նետել նաեւ close(). Այսպիսով, մենք պետք է այս մասը տեղադրենք մեկ այլ նման բլոկի ներսում ՝

FileReader

նետում է

Գործածել սխալները ՝ օգտագործելով IOExceptions Java- ի հիմնաբառը պարզ է: Իրականում, այս մոտեցման մեջ դուք իրականում չեք կարգավորում բացառությունը տեղի ունեցած վայրում: Փոխարենը, մենք բացառությունը շեղում ենք ընթացիկ մեթոդից այն մեթոդի, որը կոչվում է ընթացիկ մեթոդ: Հետո սխալը հանձնելը դառնում է արտաքին մեթոդի պարտականություն:

Մեթոդից բացառություն գցելու համար պարզապես պետք է հայտարարեք, որ այս մեթոդը կարող է գցել դիտարկված բացառությունը: Տեսնենք, թե ինչպես կարող ենք կարգավորել import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;

try {

file = new FileReader('source.txt');

file.read();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
finally {

try {


file.close();

}

catch(IOException e) {


e.printStackTrace();

}
}
} }
նետված է throws դասը ՝ օգտագործելով այս մոտեցումը:

Օրինակ:

IOExceptions

նետել

Ի տարբերություն այս ցուցակի այլ մոտեցումների, FileReader հիմնաբառը չի օգտագործվում սխալները կարգավորելու համար: Բայց քանի որ շատ մարդիկ շփոթում են import java.io.FileReader; import java.io.IOException; public class ThrowsExample {
public void readFile throws IOException {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
} }
| բառով | _ _ _ | հիմնաբառ, մենք կարծում էինք, որ ամենալավը կլինի այն քննարկել այստեղ:

throw հիմնաբառը օգտագործվում է բացառապես բացառություն կանչելու համար: Մենք կարող ենք նետել նոր ակնարկված բացառություն կամ բացառություն, որը բռնվել է մեթոդի մեջ:

throw

Օգտագործողի կողմից սահմանված բացառություններ

Ներկառուցված Java բացառություններ օգտագործելուց բացի, կարող եք սահմանել ձեր սեփական բացառությունները: Դուք կարող եք դրանք սահմանել որպես ստուգված կամ չստուգված բացառություններ: Նոր ստուգված բացառություն ստեղծելու համար ձեր նոր բացառությունը պետք է ընդլայնի throws դասարան

Ստեղծել an առանց ճարմանդ բացառություն, ընդլայնել throw դասարան

Հաջորդ կոդի օրինակում մենք ստեղծել ենք օգտագործողի կողմից սահմանված ստուգված բացառություն.

public class ThrowExample {
public void invalidate(int amount) throws Exception {
if (amount < 500) {

throw new Exception('Amount not sufficient');
}
} }

Այժմ մենք կարող ենք վերոհիշյալ բացառությունը օգտագործել մեր ծրագրի տրամաբանության ներսում ՝

Exception

Եթե ​​ստուգենք տողի երկարությունը, օգտագործելով RuntimeException դաս, դա նետելու է public class InvalidLengthException extends Exception {
private int length;
private String message;
public InvalidLengthException(int length, String message) {
this.length=length;
this.message=message;
}
public int getAmount() {
return this.length;
}
public String getMessage() {
return this.message;
} }
եթե լարի երկարությունը ցածր է նվազագույն երկարությունից կամ առավելագույն երկարությունից բարձր:

public class InputChecker {
private int minLength;
private int maxLength;
public InputChecker(int minLength, int maxLength) {
this.minLength=minLength;
this.maxLength=maxLength;
}
public void checkStringLength(String strInput) throws InvalidLengthException {
int strLength = strInput.length();
if (strLength maxLength){

throw new InvalidLengthException(strLength, 'Input should have maximum '+maxLength+' character');
}
} }

Երբ մենք գործարկենք վերոհիշյալ կոդի հատվածը, այն նետելու է InputChecker և մենք կստանանք հետևյալ արդյունքը.

InvalidLengthException

Եզրակացություն

Այս ձեռնարկում մենք ձեզ արագ և հակիրճ ներկայացրեցինք Java բացառությունները: Հուսով ենք, որ դուք այժմ լավ գիտակցում եք, թե որոնք են բացառությունները և ինչպես դրանք կարգավորել ձեր Java ծրագրում: