Errors in Java | Runtime, Compile Time Errors
Errors in Java occur when a programmer violates the rules of Java programming language.
It might be due to programmer’s typing mistakes while developing a program. It may produce incorrect output or may terminate the execution of the program abnormally.
For example, if you use the right parenthesis in a Java program where a right brace is needed, you have made a syntax error. You have violated the rules of Java language.
Therefore, it is important to detect and fix properly all errors occurring in a program so that the program will not terminate during execution.
Types of Errors in Java Programming
When we write a program for the first time, it usually contains errors. These errors are mainly divided into three types:
1. Compile-time errors (Syntax errors)
2. Runtime errors
3. Logical errors
Java Compile Time Errors
Compile-time errors occur when syntactical problems occur in a java program due to incorrect use of Java syntax.
These syntactical problems may be missing semicolons, missing brackets, misspelled keywords, use of undeclared variables, class not found, missing double-quote in Strings, and so on.
These problems occurring in a program are called syntax errors in Java.
Since all syntax errors are detected by Java compiler, therefore, these errors are also known as compile time errors in Java.
When Java compiler finds syntax errors in a program, it prevents the code from compile successfully and will not create a .class file until errors are not corrected. An error message will be displayed on the console screen.
These errors must be removed by debugging before successfully compile and run the program. Let’s take an example program where we will get a syntax error.
Program source code 1:
public class CompileTimeErrorEx < public static void main(String[] args) < System.out.println("a") // Syntax error. Semicolon missing. >> Compile time error in Java code: Exception in thread "main" java.lang.Error: Unresolved compilation problem: Syntax error, insert ";" to complete BlockStatements
When you will try to compile the above program, Java compiler will tell you where errors are in the program. Then you can go to the appropriate line, correct error, and recompile the program.
Let’s create a program where we will try to call the undeclared variable. In this case, we will get unresolved compilation problem.
Program source code 2:
public class MisspelledVar < public static void main(String[] args) < int x = 20, y = 30; // Declare variable sum. int sum = x + y; // Call variable Sum with Capital S. System.out.println("Sum of two numbers: " + Sum); // Calling of undeclared variable. >> Compile time error in Java code: Exception in thread "main" java.lang.Error: Unresolved compilation problem: Sum cannot be resolved to a variable
Program source code 3: Missing parenthesis in for statement.
public class MissingBracket < public static void main(String[] args) < int i; int sum = 0; // Missing bracket in for statement. for (i = 1; i System.out.println("Sum of 1 to 5 \n"); System.out.println(sum); > > Compile time error in Java code: Exception in thread "main" java.lang.Error: Unresolved compilation problem: Syntax error, insert ") Statement" to complete ForStatement
Program source code 4: Missing double quote in String literal.
public class MissingDoubleQuote < public static void main(String[] args) < String str main" java.lang.Error: Unresolved compilation problem: String literal is not properly closed by a double-quote
We may also face another error related to the directory path. An error such as
means that you have not set the path correctly.
Runtime Errors in Java
Runtime errors occur when a program is successfully compiled creating the .class file but does not run properly. It is detected at run time (i.e. during the execution of the program).
Java compiler has no technique to detect runtime errors during compilation because a compiler does not have all of the runtime information available to it. JVM is responsible to detect runtime errors while the program is running.
Such a program that contains runtime errors, may produce wrong results due to wrong logic or terminate the program. These runtime errors are usually known as exceptions.
For example, if a user inputs a value of string type in a program but the computer is expecting an integer value, a runtime error will be generated.
The most common runtime errors are as follows:
1. Dividing an integer by zero.
2. Accessing an element that is out of range of the array.
3. Trying to store a value into an array that is not compatible type.
4. Passing an argument that is not in a valid range or valid value for a method.
5. Striving to use a negative size for an array.
6. Attempting to convert an invalid string into a number.
7. and many more.
When such errors are encountered in a program, Java generates an error message and terminates the program abnormally. To handle these kinds of errors during the runtime, we use exception handling technique in java program.
Let’s take different kinds of example programs to understand better. In this program, we will divide an integer number by zero. Java compiler cannot detect it.
Program source code 5:
public class DivisionByZeroError < public static void main(String[] args) < int a = 20, b = 5, c = 5; int z = a/(b-c); // Division by zero. System.out.println("Result: " +z); >> Output: Exception in thread "main" java.lang.ArithmeticException: / by zero at errorsProgram.DivisionByZeroError.main(DivisionByZeroError.java:8)
The above program is syntactically correct. There is no syntax error and therefore, does not cause any problem during compilation. While executing, runtime error occurred that is not detected by compiler.
The error is detected by JVM only in runtime. Default exception handler displays an error message and terminates the program abnormally without executing further statements in the program.
Let’s take an example program where we will try to retrieve a value from an array using an index that is out of range of the array.
Program source code 6:
public class AccessingValueOutOfRangeError < public static void main(String[ ] args) < int arr[ ] = ; // Here, array size is 5. System.out.println("Value at 5th position: "+arr[5]); > > Output: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 at errorsProgram.AccessingValueOutOfRangeError.main(AccessingValueOutOfRangeError.java:9)
Logical Errors in Java Program
Logical errors in Java are the most critical errors in a program and they are difficult to detect. These errors occur when the programmer uses incorrect logic or wrong formula in the coding.
The program will be compiled and executed successfully but does not return the expected output.
Logical errors are not detected either by Java compiler or JVM (Java runtime system). The programmer is entirely responsible for them. They can be detected by application testers when they compare the actual result with its expected result.
For example, a programmer wants to print even numbers from an array but he uses division (/) operator instead of modulus (%) operator to get the remainder of each number. Due to which he got the wrong results.
Let’s see the following source code related to this problem.
Program source code 7:
public class LogicalErrorEx < public static void main(String[] args) < int a[]=; System.out.println("Even Numbers:"); for(int i = 0; i > > > As you can see the program is successfully compiled and executed but the programmer got the wrong output due to logical errors in the program.
Seldom does a program run successfully at its first attempt. A software engineer in a company also commits several errors while designing the project or developing code.
These errors in a program are also called bugs and the process of fixing these bugs is called debugging.
All modern integrated development environments (IDEs) such as Eclipse, NetBeans, JBuilder, etc provide a tool known as debugger that helps to run the program step by step to detect bugs.
If you need professional help with Java homework assignments online, please address experts from AssignmentCore to get your Java projects done with no errors.
In this tutorial, we have familiarized different types of errors in java that may possibly occur in a program.
Thanks for reading.
Next ⇒ Exception handling Interview Programs for Practice
50 Common Java Errors and How to Avoid Them (Part 1)
There are many types of errors that could be encountered while developing Java software, but most are avoidable. We’ve rounded up 50 of the most common Java software errors, complete with code examples and tutorials to help you work around common coding problems.
For more tips and tricks for coding better Java programs, download our Comprehensive Java Developer’s Guide, which is jam-packed with everything you need to up your Java game – from tools to the best websites and blogs, YouTube channels, Twitter influencers, LinkedIn groups, podcasts, must-attend events, and more.
If you’re working with .NET, you should also check out our guide to the 50 most common .NET software errors and how to avoid them. But if your current challenges are Java-related, read on to learn about the most common issues and their workarounds.
Compiler Errors
Compiler error messages are created when the Java software code is run through the compiler. It is important to remember that a compiler may throw many error messages for one error. So fix the first error and recompile. That could solve many problems.
1. “… Expected”
This error occurs when something is missing from the code. Often this is created by a missing semicolon or closing parenthesis.
private static double volume(String solidom, double alturam, double areaBasem, double raiom)if (solidom.equalsIgnoreCase("esfera")vol=(4.0/3)*Math.pi*Math.pow(raiom,3);if (solidom.equalsIgnoreCase("cilindro")vol=Math.pi*Math.pow(raiom,2)*alturam;vol=(1.0/3)*Math.pi*Math.pow(raiom,2)*alturam;Syntactical Errors in Java
A syntactical error in Java code is one in which the language you use to create your code is incorrect. For example, if you try to create an if statement that doesn’t include the condition in parentheses, even when the condition is present on the same line as the if statement, that’s a syntax error.
The compiler will catch most of these errors for you. If the syntax of your code is incorrect, then in most cases the compiler can’t use the code to create byte code for the JRE. Here’s a list of the most common syntax errors:
- Using incorrect capitalization: One of the most common syntax errors that new developers make is to capitalize keywords, rather than use lowercase. Java is case sensitive, so using the proper case when you type your code is essential. This same error can occur with class names, variables, or any other code you type as part of your Java application. A variable named MyVar is always different from one named myVar.
- Splitting a string over two lines: In most cases, Java doesn’t care if your code appears on one or more lines. However, if you split a string across lines so that the string contains a newline character, then the compiler will object. The answer is to end the string on the first line with a double quote, add a plus sign to tell the compiler you want to concatenate (add) this string with another string, and then continue the string on the next line like this:
System.out.print("This is a really long " + "string that appears on two lines."); // Import the required API classes. import java.util.Scanner; import java.lang.Character; public class UseAMenu03 < public static void main(String[] args) < // Create the scanner. Scanner GetChoice = new Scanner(System.in); // Obtain input from the user. System.out.println("Optionsn"); System.out.println("A. Yellow"); System.out.println("B. Orange"); System.out.println("C. Greenn"); System.out.print("Choose your favorite color: "); char Choice = GetChoice.findInLine(".").charAt(0); // Convert the input to uppercase. Choice = Character.toUpperCase(Choice); // Choose the right color based on a switch statement. switch (Choice) < case 'A': System.out.println("Your favorite color is Yellow!"); //break; case 'B': System.out.println("Your favorite color is Orange!"); //break; case 'C': System.out.println("Your favorite color is Green!"); //break; default: System.out.println( "Type A, B, or C to select a color."); //break; >> > When you execute this code and answer A, the application outputs all the possible responses, as shown in this figure. If you compare this output to the output shown in the second figure, you’ll see that the application isn’t working correctly.
public static void main (String []args)
You can create many other syntax errors. As you’ve discovered by reading this list, the compiler will find some of them, the JRE will find others, but some, like omitting the break clause of a switch statement, are left for you to figure out. Of the three main types of error, syntactical errors tend to be the easiest to find.