What is compile time error

Runtime and compile time, these are two programming terms
that are more frequently used in java programming language. The programmers specially beginners find it little difficult to understand what exactly they are. So
let’s understand what these terms
means in java with example.

In java running a program happens in two steps, compilation and then execution. The image below shows where does compile time and runtime takes place
in execution of a program.

What is compile time in Java

After writing the program, programmer needs to compile that
program. As soon as the programmer starts compiling the program
using
javac
compiler, the compile time gets started, and it ends when either
a .class file is generated after successful compilation or an
error is thrown in compilation. In other way we can say, the
process of compiling a program is referred as compile time.

For an example if you wrote a program and saved it as
MyFirstProgram.java, Once you start compiling this program using
javac command as
javac MyFirstProgram.java,
the compile time gets started and it ends when a .class file as
MyFirstProgram.class is generated or any error is thrown in compilation.

What is compile time error in java ?

If a program element(class, method, variable, statements etc) is not written as per it’s syntax in java, the compiler throws
error for that element while compiling the program. We call these errors as compile time errors as these errors are detected at compile time by the java compiler.

Let us see compile time error by an example. The most
common mistake that beginners do is, they forget to add
semicolon(;) at the end of a statement which results as a compilation error while compiling the program.

 class MyFirstProgram {	
   public static void main(String [] args) {
     System.out.println("first statement") // missing semicolon(;)
     System.out.println("second statement");
   }	
 }		

Once you compile above program as javac MyFirstProgram.java, it will display a compilation error in console window like below :

Compile time Error:

 MyFirstProgram.java:3: error: ';' expected
             System.out.println("first statement") // missing semicolon(;)
                                                  ^
 1 error

What is Runtime in Java

As soon as the programmer starts executing the program using
java
command, runtime gets started and it ends when execution of
program ended either successfully or unsuccessfully. In other way the process of running a program is known as
runtime.

For an example if you wrote a program and saved it as
MyFirstProgram.java. After compilation when you execute the command
java MyFirstProgram
for running the program, runtime gets started and it ends when either
the output of program is generated or any runtime error is thrown.

What is runtime error in java ?

Errors which comes during the execution(runtime) of a program are known as runtime errors.
If a program contains runtime error, it won’t run successfully,
rather that error will be displayed in command window(eg. cmd) at the time of execution.

Let us suppose if you wrote a program MyFirstProgram.java
like below, After compilation when you run the below
program using java MyFirstProgram command, it
will throw a runtime error.

 class MyFirstProgram {	
  public static void main(String [] args) {	
     int num1 = 10;
     int num2 = 0;
     System.out.println(num1/num2); // Runtime error: Divide by zero exception
   }	
 }	

Runtinme Error:

 Exception in thread "main" java.lang.ArithmeticException: / by zero
         at MyFirstProgram.main(MyFirstProgram.java:5)

Difference between runtime and compile time

Compile time is a process in which java compiler compiles the java program and generates a .class file. In other way, in compile time
java source code(.java file) is converted in to .class file using java compiler. While in runtime, the java virtual machine loads the .class file in memory
and executes that class to generate the output of program.

Difference between compile time error and runtime error

Compile time errors are the error that comes while compiling the program whereas runtime errors are errors that comes at the time of execution(run-time) of the program. An example of
compile time error is "not adding a semicolon(;) at the end of a statement" in your java program while "dividing a number by zero" is an example of runtime error.

When a method is declared as having a return type of void, it cannot contain any return statements which return a value (it can, however, contain a return statement by itself, which will simply end the execution of the method). This problem is usually caused by accidentally making a method be of type void when it shouldn’t be or by accidentally including a return statement where there shouldn’t be one.

This error will most likely be caused when you omit the keyword class or interface, as seen in the example below.

Using TestInterface, consider the following example.

This error occurs when you have an else or else if clause without an if clause above it. This is most likely because you have accidentally forgotten/added extra { or } braces, or you have placed an else clause in the wrong place, as illustrated in the example below. The key idea is that every else clause needs to have an associated if clause which occurs before it.

Java is very specific about use of characters such as semicolons, brackets, or braces. Forgetting a semicolon is the simplest of these errors, and is fixed by placing a semicolon at the end of the line which causes the error. Brackets can be more complicated, because you may have to read through several nested if statements or loops in order to make sure that all brackets «match up» with each other properly. This is one of the reasons why indenting your code properly is a good idea.

An identifier is another term for a variable. In Java, every variable name must begin with a letter/underscore and can then have any combination of letters, numbers, and underscores. The example below illustrates two cases you may run into.

In a Java assignment statement, the type of the variable on the left hand side must be the same as the type of the variable on the right hand side (or it needs to be able to be cast first in order to make it work). The example below would give three ‘incompatible types’ error messages.

This error may also occur when trying to pass a value of one type into a method which expects another. An example of this is below.

You may also get a similar error if you are attempting to cast incorrectly. Recall that a primitive type may not be cast to an object or vice-versa. When casting between two objects, recall that object «A» may be cast to be of the same type as object «B» only if B’s class extends A’s class. As an example, consider a class Cat which extends the class Animal.

In Java, every method which does not have a return type of void must have at least one return statement.

This compile-time error can have a very subtle point which is often overlooked. If the return type of a method is not void, Java needs to ensure that the method will return a value in every possible case. That is, if all of your return statements are nested within if statements, Java will disallow the compilation process to continue because there is a chance that no return statement will be reached. The example below illustrates this.

In Java, recall that a method’s signature consists of the method’s name and the types of its actual parameters. For example, the method public void move(int howFar) has the signature move(int). When a method call is made, a method with a signature exactly matching that of the method call must exist (e.g. the method name, the number of parameters, and the types of all parameters must match exactly). This error is illustrated below.

Each line of Java code must have some sort of meaningful purpose. The compile-time error «not a statement» is usually the result of typing only part of a statement, leaving it incomplete and meaningless. One example of how this may occur (there are many) is seen below. In general, asking yourself «what was I trying to do with this line of code?» is sufficient to fix the problem.

For each method, Java requires a return type (e.g. String, int, boolean). Note that void is also considered to be a «return type» even though a method with a void return type does not return a value.

This error usually occurs if you have a statement placed directly after a return statement. Since Java executes code line-by-line (unless a method call is made), and since a return statement causes the execution of the program to break out of that method and return to the caller, then anything placed directly after a return statement will never be reached.

This compile-time error is typically caused by a programmer attempting to declare a variable twice. Recall that a statment such as int temp; declares the variable named temp to be of type int. Once this declaration has been made, Java can refer to this variable by its name (e.g. temp = 15;) but does not let the programmer declare it a second time by including the variable type before the name, as seen in the example below.

You may also get this error if you have tried to declare two variables of different types using the same variable name (in Java, every variable must have a unique name). The example below illustrates this using two variables of type int and String.

The only time where repetition of variable names or declarations are allowed is if the two variables are in different scopes. Recall that the scope of a variable is determined by the set of braces, { and }, in which it is enclosed. This is illustrated in the two examples below.

This error occurs when a variable is not declared within the same (or an «outer») scope in which it is used. Recall that the scope of a variable declaration is determined by its location with { and } braces. The example below illustrates a simple case of this error. To fix this problem, make sure that the variable is declared either in the same scope in which it is being used, or it being delcared in an «outer» scope.

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

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 <= 5; i++ // insert " ) Statement" to complete For Statement.
 {
   sum = sum + 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 = "Scientech; // Missing double quote in String literal.
 System.out.println(str);
  }
}

Compile time error in Java code:
       Exception in thread "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

javac : command not found

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[ ] = {1, 2, 3, 4, 5}; // 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[]={1, 2 , 5, 6, 3, 10, 12, 13, 14};  
 
System.out.println("Even Numbers:");  
for(int i = 0; i <a.length; i++)
{  
if(a[i] / 2 == 0) // Using wrong operator.
{  
  System.out.println(a[i]);  
 }  
}  
 }
}

Output:
       Even Numbers:
       1

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

⇐ Prev Next ⇒