Throw exception in java with message

Throwing Exceptions in Java

It is important to understand how to throw exceptions in Java. This will allow you to create higher quality code where errors are checked at compile time instead of runtime, and create custom exceptions that make debugging and recovery easier.

How to throw exceptions in Java

Throwing an exception is as simple as using the «throw» statement. You then specify the Exception object you wish to throw. Every Exception includes a message which is a human-readable error description. It can often be related to problems with user input, server, backend, etc. Here is an example that shows how to throw an exception:

throw new Exception("Exception message");

It’s limiting to use a generic exception because it makes it difficult for the calling code to catch it. It’s better to throw custom exceptions, which we will come back to in a bit.

Using the Throws keyword

Throws is a keyword used to indicate that this method could throw this type of exception. The caller has to handle the exception using a try-catch block or propagate the exception. We can throw either checked or unchecked exceptions.

The throws keyword allows the compiler to help you write code that handles this type of error, but it does not prevent the abnormal termination of the program. With the help of the throws keyword, we can provide information to the caller of the method about the types of exceptions the method might throw.

type method_name(parameters) throws exception_list

In the above syntax, exception_list is a comma-separated list of all the exceptions a method might throw. For example:

void testMethod() throws ArithmeticException, ArrayIndexOutOfBoundsException < // rest of code >

In the example below, we have created a test method to demonstrate throwing an exception. The toString() method returns a textual representation of an object, but in this case the variable is null. Calling a method on a null reference or trying to access a field of a null reference will trigger a NullPointerException .

static void testMethod() throws Exception

This must be handled with a try/catch block:

public class Example < public static void main(String[] arg) < try < testMethod(); >catch (Exception e) < e.printStackTrace(); >> >

The Exception class

To use exceptions within your application more effectively, it is important to understand how to create and throw your own. But before we get into throwing exceptions, let’s first take under the hood: We’ll describe what an exception is and how to define your own, starting with the global exception class that all Java exceptions stem from:

package java.lang; public class Exception extends Throwable < static final long serialVersionUID = -3387516993124229948L; public Exception() < super(); >public Exception(String message) < super(message); >public Exception(String message, Throwable cause) < super(message, cause); >public Exception(Throwable cause) < super(cause); >protected Exception(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) < super(message, cause, enableSuppression, writableStackTrace); >>

The Exception class is the superclass of all classes that represent recoverable exceptions. When exceptions are thrown, they may be caught by the application code. The exception class extends Throwable . The constructor contains two parameters: message and cause. The detailMessage parameter gives the details of the message for this exception, and the throwable parameter gives the cause of this exception.

Types of exceptions

There are two types of exceptions in Java: checked (compile time) exceptions and unchecked (runtime) exceptions. For clarity, we’ll also discuss how errors are different than exceptions in Java.

Checked exception (compile time exception)

Checked exceptions must be caught and handled during compile time. If the compiler does not see a try or catch block or throws keyword to handle a checked exception, it throws a compilation error. Checked exceptions are generally caused by faults outside code like missing files, invalid class names, and networking errors.

FileInputStream fis = null; try < fis = new FileInputStream("B:/myfile.txt"); >catch (FileNotFoundException e)

Unchecked exception (runtime exception)

Unchecked exceptions do not need to be explicitly handled; they occur at the time of execution, also known as run time. These exceptions can usually be avoided by good coding practices. They are typically caused by programming bugs, such as logic errors or improper use of APIs. These exceptions are ignored at the time of compilation. For example:

The example above will cause an ArithmeticException at the time of program, since a number can’t be divided by 0. It would throw an unhandled exception and the program would end.

Errors

People often refer to «errors» and “exceptions” as the same thing colloquially. However, in Java these are separate concepts. Errors are thrown by the Java Virtual Machine and cannot be caught or handled. They derive from java.lang.Error and they occur because of some fault in the environment in which the application is running. For example, stack overflows and out of memory exceptions are environment errors that result in the application exiting.

Custom exceptions

Java’s built-in exceptions don’t always provide the information we need. So, we sometimes need to supplement these exceptions with our own. During some specific operation, if an exception occurs in your application, you need to recover and make the user know about it. A custom exception gives you more control to provide extra data about the problem and to handle the exception in your code.

The best practice is to extend the java.lang.Exception class with a new class, following the general naming convention as provided by the JDK (Java Development Kit). The new class requires a constructor that will take a string as the error message—it is called the parent class constructor.

public class HandledException extends Exception < private String code; public HandledException(String code, String message) < super(message); this.setCode(code); >public HandledException(String code, String message, Throwable cause) < super(message, cause); this.setCode(code); >public String getCode() < return code; >public void setCode(String code) < this.code = code; >>

For example, let’s say a program fails to connect to a database. You could use a custom exception to collect information like the database URL, username, password, etc. In the catch block, you could write this information to the log and display a basic message to the user like «failed to connect to database.»

public class MainClass < private static String DATABASE_EXCEPTION = "DATABASE_EXCEPTION"; private static final Logger logger = Logger.getLogger(MainClass.class); public static void main(String[] args) < try < makeDatabaseConnection(); >catch (HandledException e) < rollbar.error(e, "Hello, Rollbar"); // Display custom message to the user System.out.println("Code: "+e.getCode()+” Exception Message : ”+e.getMessage()); // Log the exception detail logger.error("Exception: ", e); >> static void makeDatabaseConnection() throws HandledException < String dbURL = "jdbc:sqlserver://localhost\sqlexpress"; String userName = "sa"; String password = "secret"; Connection conn = null; try < conn = DriverManager.getConnection(dbURL, userName, password); >catch (SQLException e) < rollbar.error(e, "Hello, Rollbar"); throw new HandledException(DATABASE_EXCEPTION,"Failed to connect to database", e); >> >

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Rollbar can help throw Java exceptions as well as track, analyze, and manage errors in real-time to help you to proceed with more confidence. Try it today!

Источник

How to Throw an Exception in Java (with Examples)

In this article, we will learn about the throw keyword in Java in detail for exception Handling with a set of examples. But first, we need to understand what are exceptions in java.

What are Exceptions in Java?

In Java, there are 2 types of exceptions:

Unchecked Exceptions:

These exceptions are checked at the run-time, not at the compile-time. These exceptions include:

• ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException exceptions under Error class, etc.

Checked Exceptions:

These exceptions are checked at the compile time. These exceptions include:

Note: Unchecked exceptions occur due to programming errors so generally, we don’t handle them instead it’s a good practice to correct them.

Now let’s see how to handle checked exceptions in Java in detail!

Java throw keyword

The throw keyword in Java is used to throw an exception explicitly from a method or any block of code. When an exception is thrown, the flow of program execution transfers from the try block to the catch block. An exception can be either checked or unchecked.

Additionally, the throw keyword is majorly used to throw custom exceptions. We use the throw keyword within a method.

Syntax

The syntax for using the throw keyword to throw exceptions is:

Here, the exception i.e, Instance must be of type Throwable or a subclass of Throwable. For example:

A throwable object is an instance of the class Throwable or a subclass of the Throwable class. The throw statement is used together with an exception type which is often used together with a custom method.

Note: Unlike C++, data types such as int, char, floats, or non-throwable classes cannot be used as exceptions.

When the throw statement is executed, the flow of execution of the program stops immediately and the nearest enclosing try block is checked to see if it has a catch statement that matches the type of exception.

If that catch handles the same type of exception then, control is transferred to that statement otherwise next enclosing try block is checked, and so on. If no matching catch is found then the default exception handler will halt the program.

Example 01) Throwing Unchecked Exception

In this example, we will throw an unchecked exception if the age is below 18:

// Welcome To FavTutor public class Main  static void checkAge(int age)  if (age  18)  throw new ArithmeticException("Access denied - You must be at least 18 years old."); > else  System.out.println("Access granted - You are old enough!"); > > public static void main(String[] args)  checkAge(15); > > 

Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old. at Main.checkAge(Main.java:4) at Main.main(Main.java:12) 

In this example, we are explicitly throwing an ArithmeticException.

Note: ArithmeticException is an unchecked exception. It’s usually not necessary to handle unchecked exceptions.

Example 02) Throwing Unchecked Exception

In this example, we are again throwing the unchecked exception as given below:

// Welcome To FavTutor // Java program that demonstrates the use of throw class ThrowExcep  static void fun()  try  throw new NullPointerException("demo"); > catch(NullPointerException e)  System.out.println("Caught inside fun()."); throw e; // rethrowing the exception > > public static void main(String args[])  try  fun(); > catch(NullPointerException e)  System.out.println("Caught in main."); > > > 

Caught inside fun(). Caught in main. 

Example 03) Throwing Unchecked Exception

Another example showing the use of the throw keyword:

// Java program that demonstrates the use of throw // Welcome To FavTutor class Test  public static void main(String[] args)  System.out.println(1/0); > > 

Output :

Exception in thread "main" java.lang.ArithmeticException: / by zero

Example 04) Throwing Checked Exception

In this example, we will throw a checked exception named IOException with the message we passed to its constructor :

// Welcome To FavTutor import java.io.*; class Main  public static void findFile() throws IOException  throw new IOException("File not found"); > public static void main(String[] args)  try  findFile(); System.out.println("Rest of code in try block"); > catch (IOException e)  System.out.println(e.getMessage()); > > > 

The findFile() method throws an IOException with the message we passed to its constructor. We are specifying it in the throws clause because it is the checked exception.

The methods that call this findFile() method need to either handle this exception or specify it using the throws keyword themselves.

We have handled this exception in the main() method. The flow of program execution transfers from the try block to the catch block when an exception is thrown. So, the rest of the code in the try block is skipped and statements in the catch block are executed.

throw and throws in Java

In exception handling, we also use the throws keyword. Some of the differences between throw and throws are given below:

Conclusion

In this article, we learned in great detail about the throw keyword in Java and how to throw exceptions using them. Using throw while exception handling increases the quality of our code. Some of the crucial points to keep in mind about the throw keyword are :

• used to throw custom exceptions.
• We use the throw keyword within a method.
• The instance must be of type Throwable or a subclass of Throwable.
• The throw statement is used together with an exception type which is often used together with a custom method.

Congratulations on getting this far! Now give yourself a pat on the back. Good job!

Источник