6 Java Exceptions na nagmumulto sa mga nagsisimula sa Java.
(Orihinal) (Bago ako sa parehong Java at English, kaya ikalulugod kong makatanggap ng kritisismo at tulong)
Parehong bago at ngayon, nakatagpo ako ng maraming mga newbie sa Java na may problema sa ilang karaniwang mga pagbubukod na kailangan kong ipaliwanag muli. Naniniwala ako na ang ibang mga developer ng Senior Java ay may parehong problema na sinusubukang tulungan ang mga baguhan na harapin ang mga pagbubukod na ito. Kaya, isinulat ko ang artikulong ito para sa aking sariling pag-unlad. Mangyaring huwag mag-atubiling magkomento sa artikulong ito o magdagdag ng mga pagbubukod sa listahan sa ibaba.
Isa ito sa mga pagbubukod na iyon, na may mensahe tulad ng
“Exception in thread “main” NoClassDefFoundError” , na nakakaharap ng karamihan sa mga bagong developer ng Java sa mundo ng Java programming. Ang isang baguhan ay nagsusulat ng isang programa na nagpapakita ng "Hello world!", pumunta sa command line, i-type ang "java ...", pinindot ang enter at BAM! =). At pag-iisip kung paano mai-print ang programa ng "Hello world!" sa monitor, tumatagal ng ilang oras.
Nangyayari ang NoClassDefFoundError kapag sinubukan ng Java Virtual Machine (JVM) na i-access ang isang klase sa oras ng pagsisimula at hindi nahanap ang klase, kahit na natagpuan ang parehong klase sa oras ng pag-compile. Kadalasan ang pagbubukod na ito ay nangyayari kapag sinusubukang magsagawa ng isang programa gamit ang "java" na utos at ang classpath ay hindi naitakda nang maayos. Narito ang isang paglalarawan ng mga dahilan kung bakit nangyayari ang pagbubukod na ito.
- Ang klase ay hindi available sa -classpath.
- Ang CLASSPATH environment variable ay na-override. Maaari mong suriin ang presensya at kawastuhan nito gamit ang command ng Windows na "set".
Ang solusyon sa problema ay inilarawan nang mas detalyado
dito.
Bukod dito, kailangan mong maunawaan ang pagkakaiba sa pagitan ng CLASSPATH environment variable at ng interpreter key -classpath. Hindi inirerekomenda ng mga propesyonal ang paggamit ng CLASSPATH. Ang pinakamahusay na paraan ay ipasa ang -classpath key sa interpreter.
Ang ClassNotFoundException ay isa pang pagbubukod na nagiging bangungot para sa isang baguhan sa sandaling simulan niya ang programming. Kapansin-pansin, ang karaniwang developer ng Java ay madalas
na nalilito sa pagitan ng ClassNotFoundException at NoClassDefFoundError exception . At sa gayon, ang pagkakaiba sa pagitan ng dalawang eksepsiyon na ito ay nananatiling
isa sa mga madalas itanong sa mga panayam para sa posisyong Junior .
Ang ClassNotFoundException ay nangyayari kapag sinubukan ng JVM na mag-load ng isang partikular na klase at hindi ito mahanap sa classpath. Isa sa mga karaniwang lugar kung saan nakatagpo ito ng bagong developer ng Java sa unang pagkakataon ay ang pagkonekta sa isang database gamit ang JDBC library. Doon ay susubukan naming i-load ang driver gamit ang code tulad ng Class.forName("JDBCdriver").
Narito ang isang magandang artikulo tungkol sa ClassNotFoundException . Ang pagsisikap na maunawaan ang konsepto ng
Java Classloaders ay ang pinakaepektibong paraan upang harapin ang problemang ito. Mababasa mo
kung paano i-configure ang Java classpath sa Win/Unix environment . Tulad ng nakasaad sa
java docs , ang isang pagbubukod ay nangyayari sa mga sumusunod na kaso:
- Subukan mong mag-load ng klase gamit ang Class.forName na paraan at ang .class na file ay wala sa classpath. Ito ang pinakakaraniwang senaryo sa tatlong nakalista dito.
- Kapag sinubukan ng class loader na mag-load ng klase gamit ang loadClass.
- Kapag sinubukan ng class loader na mag-load ng klase gamit ang findSystemClass.
Ang pagbubukod na ito ay mas madaling maunawaan ng mga nagsisimula kaysa sa unang dalawa. Bukod dito,
ang pagbubukod na ito ay madaling matukoy dahil kapag nangyari ito, ang mensahe tungkol sa pagbubukod
ay nagpapahiwatig ng numero ng linya sa programa kung saan ito naganap. Ang pagbubukod na ito ay nangyayari kapag sinubukan ng JVM na i-access ang isang bagay o sinubukang tumawag ng isang pamamaraan sa isang bagay at tumatanggap ng isang null sa halip na isang sanggunian sa bagay. Ang Java Doc ay nagsasaad din ng mga sumusunod na dahilan:
- Pag-access o pagbabago ng paraan sa isang bagay na hindi wasto. (ibig sabihin, sa halip na isang sanggunian sa isang JVM object ito ay nagiging null)
- Pagkuha ng haba ng isang array kapag hindi ito wasto. (halimbawa, hindi nasimulan)
- Ang isang pagtatangka ay ginawa upang ma-access ang isang hindi umiiral na elemento ng array ng uri ng Bagay. (i.e. kapag, sa halip na isang object reference, ang array element ay naglalaman ng null)
Ang pinakasimpleng paraan upang maiwasan ang pagbubukod na ito ay ang paggamit ng non-NULL check. Gayunpaman, sa malao't madali, ito ay magiging isang kasanayan sa pag-develop ng Java at makakahanap ka ng mga non-NULL na tseke sa lahat ng dako. Kapansin-pansin, ang
pagpasok ng mga non-NULL na tseke sa lahat ng dako ay hindi itinuturing na magandang istilo ng programming . At ang pangunahing dahilan para gumamit ng non-NULL checking ay ang developer ay gustong magpasa ng null object kung sakaling magkaroon ng kabiguan o error. Sa halip, ito ay
isang mahusay na kasanayan sa programming na dapat gamitin ng mga programmer
upang ibalik ang isang walang laman na bagay, sa halip na isang null value , bilang pangunahing lohika para sa kung paano kikilos ang isang programa sa kaganapan ng isang error. Gayunpaman, ang pag-ampon ng kasanayan sa programming na ito ay mas mahirap kaysa sa tila.
Mayroong isang magandang artikulo tungkol dito sa aming mapagkukunan.
Ito ay isa pang pagbubukod na pamilyar sa mga nagsisimula, na nangyayari kapag sinusubukang i-cast ang isang bagay sa isang klase na hindi isang subclass nito. Muli, ito ay medyo madaling maunawaan, kilalanin, at simpleng ayusin. Ang isang paraan upang maiwasan ang pagbubukod na ito kapag ang uri ng object ay hindi alam sa runtime ay ang paggamit ng
"InstanceOf" upang suriin na ang object ay isang instance ng isang partikular na klase.
Ang pagbubukod na ito ay nagpapaliwanag sa sarili at nangyayari kapag sinubukan ng JVM na i-access ang isang elemento ng array na may hindi umiiral na index, tulad ng negatibong (-1) o mas malaki kaysa o katumbas ng laki ng array.
Ito ay medyo madaling maunawaan, tukuyin at iwasto . Halimbawa, kapag lumilikha ng isang loop,
for (i = 0; i <= cmd_stack.length; i++) System.out.println(cmd_stack[i]); nangyayari ang isang pagbubukod, dahil sa array ang mga index ay nagsisimula mula sa 0, at ang paraan ng haba ay nagbabalik ng bilang ng mga elemento, at ang numero ay 1 na mas malaki kaysa sa halaga ng huling index. Tamang gamit
for (i = 0; i < cmd_stack.length; i++) System.out.println(cmd_stack[i]);
Ang pagbubukod na ito ay hindi gaanong karaniwan at medyo madaling maunawaan, matukoy, at malutas. Nangyayari ito kapag sinubukan ng JVM na tumawag ng isang hindi umiiral na pamamaraan, o isang pamamaraan na may di-wastong argumento.
GO TO FULL VERSION