Java >> Java tutorial >  >> Tag >> throw

Sådan kaster du undtagelser i Java

Nøgleordet throw i Java bruges til eksplicit at kaste en undtagelse. Det undtagelsesobjekt, der kastes, er angivet. Undtagelsen har en meddelelse knyttet til sig, der beskriver fejlen. Disse fejl kan udelukkende være forårsaget af brugerinput, serveren eller noget andet.

I Java bruges throw nøgleordet til at kaste en undtagelse fra en metode eller et hvilket som helst andet stykke kode. At kaste tilpassede undtagelser er den mest almindelige brug af søgeordet throw. Vi har mulighed for at kaste en markeret eller umarkeret undtagelse.

Hvis vi dividerer et tal med et andet tal, kan vi kaste en ArithmeticException. Først skal vi indstille betingelsen og bruge søgeordet throw til at kaste en undtagelse. Vi kan også bruge søgeordet throw til at fastslå vores omstændigheder og eksplicit afgive undtagelser.

Java-kast

Syntaksen er som følger:

throw Instance

Eksempel:

throw new ArithmeticException("/ by zero");

Forekomsten skal dog være af typen Throwable eller en underklasse af Throwable i dette tilfælde. Dette skyldes, at brugerdefinerede undtagelser ofte udvider Exception-klassen, en Throwable-underklasse. I modsætning til C++ kan datatyper som int, char, float og ikke-kastbare klasser ikke bruges som undtagelser.

Programmets udførelsesflow stopper umiddelbart efter, at throw-sætningen er kørt. Den nærmeste omsluttende try-blok undersøges for en catch-sætning, der passer til undtagelsestypen. Hvis der findes et match, overføres kontrollen til denne erklæring. Ellers undersøges den næste omsluttende forsøgsblok, og så videre. Standard undtagelsesbehandleren vil afslutte programmet, hvis der ikke findes en matchende catch.

// program  demonstrating the use of throw
class ThrowExcep
{
	static void play()
	{
		try
		{
			throw new NullPointerException("trial");
		}
		catch(NullPointerException e)
		{
			System.out.println("Caught inside play().");
			throw e; // rethrowing the exception
		}
	}

	public static void main(String args[])
	{
		try
		{
			play();
		}
		catch(NullPointerException e)
		{
			System.out.println("Caught in the main method");
		}
	}
}

}

Eksempel:kaste

// program demonstrating how to use throw
class throwTest
{
	public static void main(String[] args)
	{
		System.out.println(1/0);
	}
}

kast

I Java bruges udtrykket throws i metodesignaturen for at indikere, at metoden kan kaste en af ​​de givne typeundtagelser. Derfor skal kalderen af ​​disse metoder bruge en try-catch-blok for at håndtere undtagelsen.

Syntaksen er som følger:

type method_name(parameters) throws exception_list

En undtagelsesliste er en kommasepareret liste over alle mulige undtagelser fra en metode. Hvis der er en chance for at rejse en undtagelse i et program, vil compileren altid advare os om det, og vi skal håndtere den kontrollerede undtagelse. Ellers får vi en kompileringsadvarsel, der siger, at urapporteret undtagelse XXX skal fanges eller erklæres for at blive kastet. Vi kan håndtere undtagelsen på to måder for at undgå denne kompileringsfejl:

  • Ved brug af try-catch-metoden
  • Brug af søgeordet throws

Vi kan bruge nøgleordet throws til at uddelegere undtagelseshåndtering til den, der ringer (hvilket kunne være en metode eller en JVM), og så er den, der ringer, ansvarlig for at håndtere undtagelsen.

// program illustrating the error in case
// of unhandled exception
class testError
{
	public static void main(String[] args)
	{
		Thread.sleep(10000);
		System.out.println("Codeunderscored");
	}
}

I den tidligere applikation får vi en kompileringstidsfejl, fordi hvis hovedtråden går i dvale, vil andre tråde have mulighed for at udføre main()-metoden, hvilket resulterer i en InterruptedException.

// program illustrating how throws functions
class testError
{
	public static void main(String[] args)throws InterruptedException
	{
		Thread.sleep(10000);
		System.out.println("Codeunderscored");
	}
}

Vi håndterede InterruptedException i det følgende program ved hjælp af throws nøgleordet, og outputtet er Codeunderscored.

Eksempel:demonstration af, hvordan kast fungerer

class demoThrowsExecp
{
	static void play() throws IllegalAccessException
	{
		System.out.println("Inside play(). ");
		throw new IllegalAccessException("demonstrating Throws exception");
	}
	public static void main(String args[])
	{
		try
		{
			play();
		}
		catch(IllegalAccessException e)
		{
			System.out.println("caught in main method.");
		}
	}
}

Væsentlige ting at huske på, når du bruger søgeordet "kast":

  • Throws-nøgleordet er kun påkrævet for markerede undtagelser; det er meningsløst at bruge det til ukontrollerede undtagelser.
  • Nøgleordet throws er blot påkrævet for at overtale compileren; det forhindrer ikke unormal programafslutning.
  • Vi kan tilbyde detaljer om undtagelsen til metodens opkald ved hjælp af throws-søgeordet.

Eksempel:Sådan smider du en ukontrolleret undtagelse

public class testThrowUncheckedException {

public class testThrowUncheckedException {   

    //function to check if person is eligible to vote or not   
    public static void validate(int score) {  
        if(score<70) {  
            //throw Arithmetic exception if not eligible to vote  
            throw new ArithmeticException("Student cannot qualify for this course");    
        }  
        else {  
            System.out.println("Student qualifies to take this course!!");  
        }  
    }  
    //main method  
    public static void main(String args[]){  
        //trigger the function  
        validate(65);  
        System.out.println(" After primary code execution");    
  }    
}    

En umarkeret undtagelse kastes af koden ovenfor. Vi kan også smide umarkerede og brugerdefinerede undtagelser på samme måde. Hvis en metode kaster en ukontrolleret undtagelse, skal den håndteres eller erklæres i throws-klausulen. Hvis vi bruger søgeordet throw til at kaste en markeret undtagelse, skal vi håndtere det med en catch-blok eller erklære det med en throws-erklæring i metoden.

Eksempel:Sådan smider du kontrollerede undtagelser

import java.io.*;  
  
public class TestThrowCheckedException {   
  
    //function to check if a student qualifies for a specified course or not   
    public static void method() throws FileNotFoundException {  
  
        FileReader file = new FileReader("C:\\Users\\Code\\Desktop\\underscored.txt");  
        BufferedReader fileInput = new BufferedReader(file);  
  
      
        throw new FileNotFoundException();  
      
    }  
    //main method  
    public static void main(String args[]){  
        try  
        {  
            method();  
        }   
        catch (FileNotFoundException e)   
        {  
            e.printStackTrace();  
        }  
        System.out.println(" runs after the rest of the code");    
  }    
}    

I Java er hver fejl- og RuntimeException-underklasse en umarkeret undtagelse. Alt andet i Throwable-klassen er en markeret undtagelse.

Eksempel:Sådan smider du brugerdefinerede undtagelser

// class representation of user-defined exceptions
class classUserDefinedException extends Exception  
{  
    public classUserDefinedException(String strVal)  
    {  
        // Calling constructor of parent Exception  
        super(strVal);  
    }  
}  
// Class using the above UserDefinedException  
public class TestThrowUserDefinedException
{  
    public static void main(String args[])  
    {  
        try  
        {  
            // throw an object of user defined exception  
            throw new classUserDefinedException("Elucidating user-defined exceptions");  
        }  
        catch ( classUserDefinedException userdefExceptions)  
        {  
            System.out.println(" Exceptions caught ");  

            // Printing UserDefinedException's message object  
            System.out.println(userdefExceptions .getMessage());  
        }  
    }  
}   

Konklusion

Undtagelser i Java giver os mulighed for at producere kode af høj kvalitet ved at kontrollere problemer på kompileringstidspunktet snarere end ved kørsel. Vi kan bygge tilpassede undtagelser for at gøre kodegendannelse og fejlfinding nemmere.


Java tag