Runtime error compile time error - Исправление ошибок и поиск оптимальных решений проблем

Improve Article

Save Article

Read

Discuss

Improve Article

Save Article

Compile-Time Errors: Errors that occur when you violate the rules of writing syntax are known as Compile-Time errors. This compiler error indicates something that must be fixed before the code can be compiled. All these errors are detected by the compiler and thus are known as compile-time errors.
Most frequent Compile-Time errors are:

Missing Parenthesis (})
Printing the value of variable without declaring it
Missing semicolon (terminator)

Below is an example to demonstrate Compile-Time Error:

C++

#include <iostream>

using namespace std;

int main()

{

int x = 10;

int y = 15;

cout << " "<< (x, y)

}

C

#include<stdio.h>

void main()

{

int x = 10;

int y = 15;

printf("%d", (x, y));

}

Error:

error: expected ';' before '}' token

Run-Time Errors: Errors which occur during program execution(run-time) after successful compilation are called run-time errors. One of the most common run-time error is division by zero also known as Division error. These types of error are hard to find as the compiler doesn’t point to the line at which the error occurs.
For more understanding run the example given below.

C++

#include <iostream>

using namespace std;

int main()

{

int n = 9, div = 0;

div = n/0;

cout <<"result = " << div;

}

C

#include<stdio.h>

void main()

{

int n = 9, div = 0;

div = n/0;

printf("result = %d", div);

}

Error:

warning: division by zero [-Wdiv-by-zero]
     div = n/0;

In the given example, there is Division by zero error. This is an example of run-time error i.e errors occurring while running the program.
The Differences between Compile-Time and Run-Time Error are:

Compile-Time Errors	Runtime-Errors
These are the syntax errors which are detected by the compiler.	These are the errors which are not detected by the compiler and produce wrong results.
They prevent the code from running as it detects some syntax errors.	They prevent the code from complete execution.
It includes syntax errors such as missing of semicolon(;), misspelling of keywords and identifiers etc.	It includes errors such as dividing a number by zero, finding square root of a negative number etc.

Источник

While working with the programming languages like executing a software program, there are many instances that we run into issues due to the run time errors or compilation errors. All these errors occur when the application is running. You might come across an instance where the application acts differently in a negative way to the requirements, then it means that a runtime error took place.

As it is one of the most common type of error that occurs during a software executive, let us get a deep idea on how to fix common types of runtime errors in Java and also the steps to be taken to resolve them on a timely basis.

Contents

1 Fix the 5 Most Common Types of Runtime Errors in Java
- 1.1 What is a Runtime Error in Java?
- 1.2 Differences Between Compile Time Error and Runtime Error in Java
- 1.3 Why Runtime Error Occurs in Java ?
- 1.4 1. Accessing Out of Range Value in an Array
- 1.5 2. Division by Zero Error
- 1.6 3. Less Space or Insufficient Space Memory Error
- 1.7 4. Conversion of an Invalid string into a Number
- 1.8 5. Attempting to Store an Incompatible Value to a Collection
- 1.9 How to solve Runtime Rrror in Java Programming?

Fix the 5 Most Common Types of Runtime Errors in Java

What is a Runtime Error in Java?

A runtime error in Java is referred to as an application error that comes up during the execution process of the program. This runtime error usually takes place when the syntax is corrected as expected while the issue lies during the program execution. All these errors can be detected by JVM – Java Virtual Machine and cannot be identified during the compilation time. Java is one of the most sought-after programming languages for the hiring managers across the world. So become an expert in Java through our Java Training and grab the best job opportunity.

Now, In this post, Let us discuss the top runtime errors in Java.

Division by zero errors
IO errors
Out of range errors
Undefined object errors

Differences Between Compile Time Error and Runtime Error in Java

Compile time errors are those errors in which the syntax would be incorrect in the application code. An example would be like missing semicolons, parenthesis, incorrect keywords, usage of undeclared variables, etc.

The Java compiler is capable of detecting the syntax errors during the compile time and the error message will be appearing on the screen. The compiler is also capable of preventing the code from the execution unless and until the error is resolved. Therefore it is important that these errors are addressed by making the necessary changes before the program is successfully executed.

The runtime errors occur during the program execution after the compilation has completed. Any program that is throwing a runtime error means that there are no issues with Syntax in the program.

Why Runtime Error Occurs in Java ?

Below listed are the most common types of runtime errors that occur in Java.

Accessing an element that is out of range in an array
Dividing a number with 0
Less space or insufficient space memory
Conversion of an invalid string into a number
Attempting to store an incompatible value to a collection

When you come across such an address, you need to know that the Java compiler will be generating an error message and the program gets terminated abnormally. Runtime errors do not require to be caught explicitly. It is useful if you catch the runtime errors and resolve them to complete the program execution.

Let us review a few of the most common runtime errors in Java programming with examples to gain a deeper understanding.

1. Accessing Out of Range Value in an Array

public class ValueOutOfRangeErrorExample {

public static void main(String[] args) {

int k[] = new int[8];

System.out.println(«8th element in array: « + k[8]);

}

In the above example, the array is initialized with 8 elements. with the above code, An element at position number 8 is trying to get access and does not exist at all, leading to the Exception java.lang.ArrayIndexOutOfBoundsException:

Error :

Exception in thread «main» java.lang.ArrayIndexOutOfBoundsException:

Index 8 out of bounds for length 8

at ValueOutOfRangeErrorExample.main(ValueOutOfRangeErrorExample.java:4)

2. Division by Zero Error

Below is an example of java.lang.ArithmeticException which occurs when the user is trying to code in such a way that they perform the division by zero.

public class ArithmeticExceptionExample {

public static void main(String[] args) {

int num1 = 10, num2 = 0;

System.out.println(«Result: «+ num1/num2);

}

In the above code, the integer num1 is getting to be divided by num2 which has a value of zero, which is leading to the exception called java.lang.ArithmeticException

Below is the Error Thrown :

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

at ArithmeticExceptionExample.main(ArithmeticExceptionExample.java:4)

3. Less Space or Insufficient Space Memory Error

Below is an example of java.lang.OutOfMemoryError, which occurs when the user is trying to initialize an Integer array with a very large size, and due to the Java heap being insufficient to allocate this memory space, it throws an Error java.lang.OutOfMemoryError: Java heap space

public class OutOfMemory {

public static void main(String[] args) {

Integer[] myArray = new Integer[1000*1000*1000];

}

Error :

Exception in thread «main» java.lang.OutOfMemoryError: Java heap space

at OutOfMemory.main(OutOfMemory.java:5)

4. Conversion of an Invalid string into a Number

Below is an example of java.lang.NumberFormatException, occurs when the user is trying to convert an alphanumeric string to an integer which leads to java.lang.NumberFormatException

public class NumberFormatException {

public static void main(String[] args) {

int a;

a= Integer.parseInt(«12Mehtab»);

System.out.println(a);

}

Error :

Exception in thread «main» java.lang.NumberFormatException: For input string: «12Mehtab»

at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)

at java.lang.Integer.parseInt(Integer.java:580)

at java.lang.Integer.parseInt(Integer.java:615)

at NumberFormatException.main(NumberFormatException.java:6)

5. Attempting to Store an Incompatible Value to a Collection

Below is an example where user has created the ArrayList of String but trying to store the integer value which leads to Exception java.lang.Error: Unresolved compilation problem

import java.util.ArrayList;

public class IncompatibleType {

public static void main(String[] args) {

ArrayList<String> student = new ArrayList<>();

student.add(1);

}

Error :

Exception in thread «main» java.lang.Error: Unresolved compilation problem:

The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)

at IncompatibleType.main(IncompatibleType.java:7)

How to solve Runtime Rrror in Java Programming?

The runtime errors can be solved by using the try catch blocks in Java. Below are the steps to be followed:

You will need to Surround the statements that are capable of throwing an exception or a runtime error in the try catch blocks.
The next step is to catch the error.
Based on the requirements of the court or an application, it is important to take the necessary action.

Like we discussed earlier about the ArithmeticException example, it can be corrected by making the below changes.

public class ArithmeticExceptionExample {

public static void main(String[] args) {

try {

int num1 = 10, num2 = 0;

System.out.println(«Result: « + num1/num2);

} catch (ArithmeticException ae) {

System.out.println(«Arithmetic Exception — cannot divide by 0»);

}

System.out.println(«Let’s continue the execution…»);

}

As the code is surrounded in the try catch blocks, the program will continue to execute after the exception is encountered.

Result :

Arithmetic Exception — cannot divide by 0

Let’s continue the execution...

In this way, it is important for you to identify the Runtime errors and also clear them without any hesitation. You can make use of the try catch blocks and many other resolutions which were helped in successful program execution. Also you will be able to track, manage and analyze the errors in real time. So this was all from this tutorial about fixing the 5 most common types of Runtime Errors in Java But still, if you have any queries, feel free to ask in the comment section. And don’t forget to stay tuned with the Tutorials field to learn this type of awesome tutorial. HAPPY CODING.

People Are Also Reading…

How to Play Mp3 File in Java Tutorial | Simple Steps
Menu Driven Program in Java Using Switch Case
Calculator Program in Java Swing/JFrame with Source Code
Registration Form in Java With Database Connectivity
How to Create Login Form in Java Swing
Text to Speech in Java
How to Create Splash Screen in Java
Java Button Click Event
11 Best WebSites to Learn Java Online for Free

Источник

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 ⇒

Источник

Both of these are types of errors. In this article, we will discuss the major difference between compile-time errors and runtime errors, but let us first know a bit more about errors.

An error or exception refers to an interruption in the execution of code due to which we cannot attain the expected outcome to the end-users. We classify these errors on the basis of the event when we generate the error.

What are Compile Time Errors?

These errors occur when we violate the rules present in a syntax. The compile-time error indicates something that we need to fix before compiling the code. A compiler can easily detect these errors. It is the reason why we call them compile-time errors. Here are the most frequent errors (compile-time):

Terminator- missing semicolon.
Missing parenthesis.
Printing the overall value of a variable with no declaration.

What are Runtime Errors?

These errors occur during the run-time program execution after a successful compilation. Division error is one of the most common errors (runtime). It occurs due to the division by zero. It is very difficult for a compiler to find out a runtime error because it cannot point out the exact line at which this particular error occurs.

Difference Between Compile Time Errors and Runtime Errors

Here is a list of the differences present between Compile Time Errors and Runtime Errors.

Parameters	Compile Time Errors	Runtime Errors
Detection	Compilers can easily detect compile-time errors during the development of code.	A compiler cannot easily detect a runtime error. Thus, we need to identify it during the execution of code.
Reference	A compile-time error generally refers to the errors that correspond to the semantics or syntax.	A runtime error refers to the error that we encounter during the code execution during runtime.
Fixation	We can easily fix a compile-time error during the development of code.	A compiler cannot identify a runtime error. But we can fix it after the execution of code and identification of the code in prior.

Keep learning and stay tuned to get the latest updates on GATE Exam along with GATE Eligibility Criteria, GATE 2023, GATE Admit Card, GATE Application Form, GATE Syllabus, GATE Cut off, GATE Previous Year Question Paper, and more.

Источник

Overview

A compiler translates the entire program written in a high-level language to machine language before execution, and the process of translation of high-level language to machine language is known as compilation. The code is just translated into the machine-level language but not evaluated during the compilation.

Errors encountered during the compilation of programs are known as compilation errors. Runtime is the period of time when a program is running, and the errors encountered at this time are known as runtime errors.

Scope of the Article

In this article, we will look at the difference between compile-time vs run-time.
Some of the errors that are encountered at the compile-time and run-time.
We will also understand the different types of compile-time errors, such as syntax and Semantic errors. And also errors at the run-time.

Introduction

Computers understand only binary language, If we want to communicate with computers, we have to use binary language. Imagine writing a program to add two numbers in just 1’s and 0’s. Sounds impossible, right? To overcome this problem, we write codes in a high-level language. Writing a program in a high-level language might be easy for us, but the computer doesn’t understand the high-level language. To fix this problem, we make use of compilers. A compiler translates the entire program written in a high-level language to machine language before execution.

Let us take an example of a robot. The robot responds to a set of commands for which they are programmed. Suppose you give a command for which the robot is not programmed. The robot won’t do anything but go blank. Even computers understand only a few words; if you say something the computer does not know, it’ll get confused and shows an error.

With this basic knowledge, It will be easy for us to understand compile-time vs run-time errors.

Before jumping into the difference between compile-time vs run-time errors, Let us understand what is compile time.

What is Compile Time?

Compile time is the period when the programming code is converted to machine code.

In the above illustration, We can see that a compiler converts the High-level language into low-level language. If there are any errors in the high-level language, the compiler shows a compilation error.

Compile-time errors

These are the errors that occur at the time of compilation. There are mainly two types of Compile-time errors.

Semantic errors.
Syntax errors.

Semantic errors

The code having absurd meaning refers to semantic errors. In other words, meaningless statements are termed semantic errors.

Syntax errors

Syntax refers to the rules that define the structure of a language. The syntax error is an incorrect construction of the source code.

What is Run Time?

So far, in our compile time vs runtime journey, we have understood what compile-time is. Now let us understand what is run-time?

Runtime is the period of time when a program is running and generally occurs after compile time.

Run-time errors

These are the errors that occur during the execution of the program. The compiler does not detect the Runtime errors. One of the few basic runtime exceptions is «Array Index Out of Bound.» Let us take an example

#include<stdio.h>
int main(){
    int ary[] = {10,9,8,7,6,5};
    printf("ary[0] is %dn", ary[0]);
    printf("ary[10] is %dn", ary[10]);
    return 0;
}


In the above code, we have declared an array with 6 elements. If we try to access the 10th element in the array, An error is encountered because we have declared 6 elements in the array, and we are trying to access the 10th element, Which does not exist.
The output of the above code is as follows:
ary [0] is 10
ary[10] is -1303609165


We can observe that arr[10] accesses a memory location that stores a garbage value. Such errors are known as array out of bounds in C.

Difference Between Compile Time Errors vs Runtime Errors

Compile-time error	Run-time error
These errors are detected during the compile-time	These errors are detected at the run-time
Compile-time errors do not let the program be compiled	Programs with run-time errors are compiled successfully, but an error is encountered when the program is executed
Compile-time errors can occur because of wrong syntax or meaningless statements	Run-time errors occur because of absurd operations

Examples of Compile-time Errors and Run-time Errors

Now that we have understood the basic definition of the errors, what is compile time vs runtime, types of errors in compile time vs runtime let’s look at some examples to make the concepts clear.

Compile-time errors

Syntax errors

Syntax errors can be of different types, Such as

Missing semicolon.
Missing Parenthesis (}).
Printing the value of a variable without declaring it.

Missing Semicolon

#include <stdio.h>

void main(){
    printf("I love scaler !"):
}


As we can see in the program, we have put «:» instead of «;» which is the wrong syntax. Therefore the compiler will throw a compile-time syntax error something like this.
main.c:4:30: error: expected ‘;’ before ‘:’ token
    4 |     printf("I love scaler !"):
      |                              ^
      |                              ;


Semantic Errors



  


                       
  




Let’s look at an example,
#include<stdio.h>
void main(){
    int x,y,z;
    x=y=z=2;
    x*y=z;
    printf("%d",z);
}


In the above code at line 5, x * y = z; is a semantic error because we know that values are assigned to the left side variable after the execution of the right-hand expression.

Here in the above example, we have x*y as the operand on the left-hand side and z on the right-hand side, which is incorrect.
The output for the above code looks something like this:
main.c:5:8: error: lvalue required as left operand of assignment
    5 |     x*y=z;
      |        ^


Missing Parenthesis
Parenthesis plays a significant role in the syntax of the code. An extra or a missing parenthesis can change the logic of the whole code, or sometimes it will yield an error.
#include<stdio.h>

void main() {
    int i;
    for (i = 0; i < 2; i++) {
      printf("The value of i is %d", i);
    }


In the above example, we can see that the closing parenthesis of the for loop is missed. Let us look at the output of this code.
main.c:7:1: error: expected declaration or statement at end of input
    7 | }
      | ^


We can see that the compiler says that a parenthesis is missing.
Printing the value of undeclared variable
Variables are used to store information to be referenced and manipulated in a computer program. If we try to print a variable without declaring it, an error will occur while running the program.
#include <stdio.h>

void main()
{
    int a=1,b=5;
    printf("%d",c);
}


In the above code, it is clear that we declared the variables a and variable b of integer datatype. In line 6, we are trying to print the value of variable c, which had not been declared. Such mistakes will result in a compile-time error.



  


                       
  




The output of the above program will be as follows:
main.c:6:17: error: ‘c’ undeclared (first use in this function)
    6 |     printf("%d",c);
      |                 ^


Runtime errors
#include<stdio.h>

int main() {
  int a = 1;
  a = a / (a - a);
  printf("%d", a);
  return 0;
}


In the above program, we can see that the value of a will be divided by 0 (Because «a» is initialized to «1» and we have «a-a» in the denominator).
This results in a solution that is not defined. Therefore we get a runtime error something like this.
main.c:6:8: warning: division by zero [-Wdiv-by-zero]
    6 |     a=a/(a-a);
      |       ~^~~~~~


Finally, We are at the end of the topic compile time vs runtime errors. I’m sure you would have understood the concept of compile-time vs runtime errors clearly.

Conclusion

*Compile time is the period when the programming code is converted to the machine code.

Compile-time errors are the errors that are encountered at the time of compilation of the program. They are Syntax errors and Semantic errors.
Syntax errors are the compile-time errors that occur due to the use of the wrong syntax.
Semantic errors occur because of the absurd use of logic.
Runtime is the period of time when a program is running and generally occurs after compile time.
Run-time errors occur when we try to access index out of bound, ‘divide by zero`, etc.

Источник

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 happens at compile time in java ?

At compile time, the
java compiler(javac) takes the source code(.java file) and checks if there is any syntax, type-checking or any semantic errors inside the program. If there is no error, the
compiler generates a .class(bytecode) file for that .java file. If there is any compilation error, java compiler displays that error in command window(eg cmd).

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.

Does java compiler generates .class file even if it throws compilation error ?

No, it will not generate .class file, it will only display the compilation error in console(eg. cmd) window.

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.

★★★

Without compilation you can not run the program,
compile first then run.
The output of a program is generated in runtime, not in
compile time.
If you made any changes in program after compilation, you need to compile the program again to see the changes in output.

Источник