Is the JVM a compiler or an interpreter?
Solution 1:
First, let's have a clear idea of the following terms
Javac is Java Compiler -- Compiles your Java code into Bytecode
JVM is Java Virtual Machine -- Runs/ Interprets/ translates Bytecode into Native Machine Code
JIT is Just In Time Compiler -- Compiles the given bytecode instruction sequence to machine code at runtime before executing it natively. It's main purpose is to do heavy optimizations in performance.
So now, Let's find answers to your questions..
1)JVM: is it a compiler or an interpreter? -- Ans: Interpreter
2)what about JIT compiler that exist inside the JVM? -- Ans: If you read this reply completly, you probably know it now
3)what exactly is the JVM? -- Ans:
- JVM is a virtual platform that resides on your RAM
- Its component, Class loader loads the
.classfile into the RAM - The Byte code Verifier component in JVM checks if there are any access restriction violations in your code. (This is one of the principle reasons why java is secure)
- Next, the Execution Engine component converts the Bytecode into executable machine code
Hope this helped you..
Solution 2:
It is a little of both, but neither in the traditional sense.
Modern JVMs take bytecode and compile it into native code when first needed. "JIT" in this context stands for "just in time." It acts as an interpreter from the outside, but really behind the scenes it is compiling into machine code.
The JVM should not be confused with the Java compiler, which compiles source code into bytecode. So it is not useful to consider it "a compiler" but rather to know that in the background it does do some compilation.
Solution 3:
Like @delnan already stated in the comment section, it's neither.
JVM is an abstract machine running Java bytecode.
JVM has several implementations:
- HotSpot (interpreter + JIT compiler)
- Dalvik (interpreter + JIT compiler)
- ART (AOT compiler + JIT compiler)
- GCJ (AOT compiler)
- JamVM (interpreter)
...and many others.
Most of the others answers when talking about JVM refer either to HotSpot or some mixture of the above approaches to implementing the JVM.
Solution 4:
It is both. It starts by interpreting bytecode and can (should it decide it is worth it) then compile that bytecode to native machine code.
Solution 5:
It's both. It can interpret bytecode, and compile it to native code.