Որպես Java մշակող, դուք պետք է լավ տիրապետեք Java- ի բացառություններին և բացառությունների մշակմանը:
Այս ձեռնարկը տալիս է հիմնական գիտելիքները, որոնք յուրաքանչյուր ծրագրավորող պետք է ունենա Java ծրագրերի հետ աշխատելիս: Սկսելու համար եկեք սկսենք հասկանալ, թե կոնկրետ ինչ են Java- ի բացառությունները:
Java ծրագիրը կարող է բախվել այնպիսի խնդիրների, որոնք հանգեցնում են նրան, որ դրա կատարման ընթացքում ծրագիրը կտրուկ դադարեցվում է: Այս խնդիրները կոչվում են բացառություններ:
Լավ ծրագրավորողը պետք է կարողանա ճանաչել կատարման ընթացքում առաջացող սխալները և այդպիսի բացառության դեպքում ծրագրի այլընտրանքային երթուղիներ տրամադրել: Այս պրակտիկան կոչվում է բացառությունների վարում:
Այժմ դուք կարող եք մտածել, թե ինչու մեզ ընդհանրապես բացառությունների մշակման կարիք կա: Ինչու՞ չգրվել այնպիսի ծրագրեր, որոնք բացառություններ չեն գցի:
Ինչպես պարզվեց, բացառություններ չթողնող ծրագրեր գրելը այնքան էլ հեշտ չէ, որքան թվում է: Unամանակի մեծ մասում այս անխուսափելի սխալները դուրս են գալիս ծրագրավորողի վերահսկողությունից:
Userրագրերը, որոնք ընդունում են օգտագործողի մուտքագրումը, հակված են բացառությունների հանդիպելուն ՝ օգտագործողի կողմից տրամադրվող անվավեր մուտքի պատճառով: Արտաքին ֆայլեր կարդալը նույնպես հաշվի առնելով այն հնարավորությունը, որ դրանք տեղափոխվել են, վերանվանվել կամ ջնջվել են արտաքին աղբյուրի կողմից ՝ առանց ծրագրավորողի գիտության:
Նման դեպքերում ծրագիրը պետք է կարողանա նրբագեղորեն կարգավորել բացառությունը ՝ առանց կատարումը դադարեցնելու:
Java- ի բոլոր բացառությունները պետք է լինեն Exception
- ի զավակ դաս, որն ինքնին Throwable
| -ի զավակ է դասարան
Exception
Երկու հիմնական ենթադաս դաս են RuntimeException
եւ IOException
.
Throwable
Մանկական մեկ այլ դաս դասը Error
դասարան Այնուամենայնիվ, սխալները տարբերվում են բացառություններից:
Սխալները ցույց են տալիս այն խնդիրները, որոնք JVM- ն կարող է բախվել կատարման ընթացքում: Սովորաբար այս խնդիրները կրիտիկական են և անուղղելի: Հիշողության արտահոսքը և գրադարանի անհամատեղելիության խնդիրները ծրագրերում սխալների ընդհանուր պատճառներն են:
StackOverflowError
եւ OutOfMemoryError
Java սխալների երկու օրինակ են:
Մենք կարող ենք բաժանել Java բացառությունները երկու հիմնական կատեգորիաների. ստուգվում և չստուգված բացառություններ:
Ստուգված բացառությունները բացառություններ են, որոնք պետք է մշակվեն ծրագրում նախքան կազմելը: Եթե այս բացառությունները չեն մշակվում, ապա ծրագիրը չի կազմվի Java կազմողի կողմից: Հետեւաբար, դրանք կոչվում են նաև կազմման ժամանակի բացառություններ: IOExceptions
ստուգված բացառությունների լավ օրինակներ են:
Չստուգված բացառությունները բացառություններ են, որոնք կազմողը անտեսում է ծրագիրը կազմելիս: Whetherրագրում մենք գործածել ենք այս բացառությունները, թե ոչ, նշանակություն չունի, երբ կազմվում է ծրագիրը: Քանի որ բացառությունների մշակումը չի կիրառվում այդ բացառությունների վրա, մեր ծրագիրը կարող է բախվել RuntimeExceptions
որոնք հանգեցնում են ծրագրի դադարեցմանը:
Բոլոր դասերը, որոնք տարածում են RuntimeException
դասը չստուգված բացառություններ են: Նման դասերի երկու օրինակ են NullPointerException
եւ ArrayIndexOutOfBoundsException
.
Մենք կանցնենք Java- ի Exception
սովորաբար օգտագործվող մի քանի մեթոդների դասարան:
getMessage
. վերադարձնում է հաղորդագրություն, որը պարունակում է մանրամասներ տեղի ունեցած բացառության մասին:printStackTrace
. վերադարձնում է տեղի ունեցած բացառության կույտի հետքը: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 ծրագրում: