Runtime and compile-time ?

[Ugur Likoglu]

Hi guys,

Do you exactly know what are the differences between the concepts compile-time and runtime? For example; some variable types are created at runtime, while others are created at compile-time. How do we understand this? By looking at the code, or knowing something? Could you define these two concepts please? Thanks.

[Abdulla Mamuwala]

Hi Ugur

To demonstrate the difference between runtime and compile time errors lets look at some simple code that causes these errors.

Compile time error

class CompileTime
{
public static void main(String args[])
{
int a=5;
int b=2;
[B]int c=a/b[/B]
System.out.println("This will be a compile time error"+c);
}
}
 

The above code will cause a compile time error because a semicolon is missing in the highlighted line.

Runtime time error
class RunTime
{
public static void main(String args[])
{
int a=5;
int b=0;
int c=a/b;
System.out.println("This will be a compile time error"+c);
}
}
The above code will give you a runtime error because in the line shown highlighted you are dividing a number by zero and assigning the same to an integer, thereby causing an ArithmaticException.
But notice that the above example will not cause a compile time error because the value assigned could have been something other than '0', say '2' which was shown in the CompileTime error program.

From the above two examples we can conclude that if the compiler can predict during compile time that an error will occur, such as an obvious error like a missing semicolon, it will result in a compile time error.
If the compiler cannot find any syntax error in your code, the program compiles fine.

Although the code causing a RunTime error may be syntatically correct, like the one in the RunTime example, but it might not be obeying the Java language specifications when the expression is actually executed.

[Layne Lund]

In general, these two terms mean exactly what they say:

compile time - when a program is compiled
run time - when a program is run

Abdulla gave a good example of the difference between compile-time and run-time errors. To answer your question about class types, you need to understand inheritence. My favorite inheritence example is something like the following:

public class ShapeExample {
  public static void main(String[] args) {
    Shape[] shapes = new Shape[2];
    shapes[0] = new Rectangle(2, 4);
    shapes[1] = new Circle(5);
 
    for(int i = 0; i < shapes.length; shapes++) {
      System.out.println("The area of shapes[" i + "] is " + shapes[0].area());
      System.out.println("The perimeter of shapes[" i + "] is " + shapes[0].perimeter());
    }
  }
}
 
class Shape {
  public abstract double area();
  public abstract double perimeter();
}
 
class Rectangle extends Shape {
  private double height;
  private double width;
 
  public Rectangle (double h, double w) {
    this.height = h;
    this.width = w;
  }
 
  public double area() {
    return this.height * this.width;
  }
 
  public double perimeter() {
    return 2 * this.height + 2 * this.width;
  }
}
 
class Circle extends Shape() {
  private double radius;
 
  public Circle(double r) {
    this.radius = r;
  }
 
  public double area() {
    return Math.PI * this.radius * this.radius;
  }
 
  public double perimeter() {
    // technically this is the circumference
    return 2 * Math.PI * this.radius;
  }
}

The difference between when the type of an object is determined is illustrated quite well here. At compile-time, the compiler only knows that the array "shapes" holds Shape objects. It doesn't know exactly which kind of shapes they are. However, at run-time, the JVM figures out which version of area() and perimeter() to call when appropriate.

I'm not sure what else I can say here, so I'll leave it open for any questions you may have. Understanding the code above will greatly help you learn about what information about an objects type is available at any given moment.

HTH

Layne