How does the java compiler look at the source code?

1. What does the Java compiler know before we actually run the program? (What things are checked as we type a program in an IDE vs what are the things which are checked at runtime?)

e.g. A) As far as I know, constant values are evaluated immediately (as we type them) in the source code in an IDE whereas, in case of variables, the compiler only checks if the variable is reachable and/or type compatibility of the variable but does not load the actual value of the variable right then. It is done at run time.
e.g. B) Overloading is checked at the compile-time, but overriding is (partially) checked at runtime.

2. Are there any other such examples and/or any criteria/rule by which the compiler decides if a particular type of code should be checked at compile time or run time?

I have tried going through a few books and Java docs as well, but I couldn't find a satisfactory answer.

Without an IDE:

1. Using an editor, you write source code in one or more files, assume you call a file Foo.java.

2. You compile it to a class file: javac Foo.java.

3. You run the resulting compiled code in a Java virtual machine: java Foo.

So, the compiler is given the source code.

An IDE is (loosely speaking) an integrated interface to the editor, compiler, and Java virtual machine. It may also do "on the fly" checking of the Java code you type, so you find errors earlier. Being part of the IDE, it obviously has access to the source code.

For the amended question:

I prefer not to use the word 'throw' for all cases of generating an error, since 'throw' has a very specific meaning with respect to Java exception handling.

The compiler analyzes your source code according to the definition of the language. If the source code is not legal Java, it will tell you. It may also offer useful warnings about questionable constructs in the code. If the compiler can tell you, it will.

But there are things the compiler cannot know about before the program is run (if that were not true, then there would be no point in ever running programs). This includes errors that might occur. For example, if you're doing arithmetic calculations with user-entered data, arithmetic exceptions (divide by zero, maybe) may happen with particular data values but not others. These are all run-time errors, outside any responsibility of the compiler. The compiler is not running at this point. Years may have elapsed between compiling the code and running it.

Your overriding/overloading example is a bit confusing. Those are both checked by the compiler, so if you're doing it wrong, you get compiler errors for both.

The difference is that for overloaded methods, the compiler can link to the implementation immediately, while for overridden methods, the compiler needs to insert a small piece of runtime code to look up the implementation by checking which subclass it has at runtime.

In general, the compiler tries to check as much as possible at compile-time, but the exact list of checks is constantly changing between different versions of the compiler and the language.