Gwt Java.lang.runtimeexception: Unable to Read From Byte Cache

Introduction to Java RuntimeException

Exceptions are the ones thrown when any error is encountered while running a lawmaking in Coffee. RuntimeException in java is the 1 which is called the parent class of all the exceptions in the Java programming language, which will either crash or intermission downwardly during the execution of the program or the application as and when they occur. Merely as compared to other exceptions, these are unlike and cannot be caught by specifying in the code like for others.

Working of RuntimeException in Coffee

Information technology belongs to the parent course of Exception in the order of Object -> Throwable -> Exception ->RuntimeException. Hence it can be chosen as the superclass of all the exceptions which can exist thrown while running the regular operations of the JVM (Java Virtual Machine). This RuntimeException and its subclasses come up under a class of exceptions chosen "unchecked exceptions". These cannot and need not be specified in the constructor'south or the method's clause.

Constructors of RuntimeException in Java

Beneath are the constructors of RuntimeException:

1. RuntimeException (): This throws u.s. the new runtime exception having its detailed message as null.

Syntax:

public RuntimeException()

The crusade here will not exist initialized and can be done by calling to the class Throwable.initCause (java.lang.Throwable).

2. RuntimeException (Cord msg): This also throws a new runtime exception simply has the divers detail bulletin we take provided in the Coffee code.

Syntax:

public RuntimeException (String msg)

Same every bit the higher up function, the cause will not be initialized past default, and the same can be washed past calling Throwable.initCause (coffee.lang.Throwable). The msg here is the particular message, which will exist saved to recollect later past the Throwable.getMessage () method.

3. RuntimeException (String msg, Throwable crusade): This throws a new runtime exception with the defined mistake message and its cause.

Syntax:

public RuntimeException (String message, Throwable cause)

Annotation that the msg here is not automatically included and has to exist specified explicitly. Here, the cause is fetched from the Throwable.getCause () function, and here a null value is allowed, which symbolises that its cause does not exist or is unknown.

4. RuntimeException (Cord msg, Throwable crusade, booleanenableSupp, booleanwritableStack): This gives a new runtime exception with the described error message in detail, its specific cause, enableSupp representing whether its suppression has been enabled or disabled, and the writableStack beingness its stack trace if it is enabled or disabled.

Syntax:

protected RuntimeException (String message,
Throwable crusade,
booleanenableSuppression,
booleanwritableStackTrace)

This gives a new runtime exception with the divers crusade and a specified detail message, its cause, whether the suppression is enabled or disabled, and if the writable stack trace has been enabled or not. The message here is the specific message we are displaying, the cause indicating whether it exists or not, enableSuppression indicates whether suppression is allowed or non, and writableStackTrace specifies whether the stack trace should be writable or not.

five. RuntimeException (Throwable cause): This throws a new runtime exception with the given crusade and specified detailed fault bulletin of the condition (crusade==null ? zip : cause.toString ()), which basically has the course and its particular crusade bulletin.

Syntax:

public RuntimeException (Throwable cause)

The cause is kept for later fetching by the Throwable.getCause () method, and when a null value is permitted, information technology indicates that its cause is not known.

How to Avert RuntimeException in Java?

The method nosotros do to avoid such exceptions is chosen exception handling. Information technology is one of the most fundamental things a developer should continue in heed while coding as the unabridged code will be useless if an exception occurs and if it cannot handle the same.

We use certain clauses called the throw and throw to handle checked exceptions in Java. Runtime exceptions usually occur because of the input being given faulty and cause exceptions like ArrayIndexOutOfBoundsException, IllegalArgumentException, NumberFormatException or a NullPointerException. Including these errors in lawmaking, handling does not make any modify, but it tin can be used for the aske of documentation as a good practice.

We can custom ascertain a Runtime exception every bit below:

public course AuthenticateUser extends RuntimeException {
public AuthenticateUser (String msg) {
super (msg);
}
}

Examples of Java RuntimeException

Beneath are the examples of 4 major kinds of Runtime exceptions:

Example #i – ArrayIndexOutOfBoundsException

This occurs when we request an index value of an array that is invalid or non bachelor.

Code:

public class Main
{
public static void main (Cord[] args)
{
// Random array of numbers
intip[] = {16, 17, eighteen, 19, 20};
for (inti=0; i<=ip.length; i++)
Organisation.out.println (ip[i]);
}
}

Output:

Every bit seen in this case, in the input array has its index value from 0 to 4. But in this for loop, the length of the array retrieved will be 5, and when that is tried to access in the array, information technology will throw the ArrayIndexOutOfBoundsException during RunTime of the code.

Example #2 – IllegalArgumentException

The cause of this exception is when the statement format provided is invalid.

Code:

public form Main {
inti;
public void getMark (int score) {
if (score < 0 || score > 100)
throw new IllegalArgumentException (Integer.toString (score));
else
i = score;
}
public static void main (String[] args) {
Main t = new Chief ();
t.getMark (30);
Organization.out.println (t.i);
Master t1 = new Main ();
t1.getMark (120);
Arrangement.out.println (t1.i);
}
}

Output:

Here we know that the maximum value of a percentage value is 100. So when we laissez passer the value as 101, we become the Illegal argument exception during run time.

Example #three – NumberFormatException

This exception is normally thrown when a string is to be converted to a numeric value similar either float or integer value, just the class of the string given as input is either illegal or inappropriate.

Code:

public class Main {
// giving input string as zippo
public static void main (String[] args) {
inti = Integer.parseInt (zip);
}
}

Output:

In this example, we are giving the input string to exist parsed into an integer as nix. Hence the number format exception is thrown.

Case #iv – NullPointerException

This exception occurs when a reference object that the variable is referring to is nada.

Code:

public class Primary {
public static void master (Cord[] args) {
Object reference = null;
reference.toString ();
}
}

Output:

In this case, we are creating an object chosen reference having a null value. The same object is being called for an operation, and hence this mistake is thrown.

Conclusion:Runtime exceptions are thrown at runtime and hence difficult to be detected during compile time. They are difficult to handle, and the throws clause tin can only exist used to define them merely non grab them.

Recommended Article

This is a guide to Java RuntimeException. Hither we discuss the Introduction and how to Avoid RuntimeException in Coffee, and it'south Working along with its examples. You can also go through our other suggested articles to larn more than –

1. Introduction to Heap Sort in Java
2. Overriding in Java (Examples)
3. Iterators in C# With Advantages and Disadvantages
4. Top x Java Drove Interview Questions

longtheltorither.blogspot.com

Source: https://www.educba.com/java-runtimeexception/

Share this post