1) What is Java ?

Ans:- Java technology is both a programming

language and a platform from Oracle Corporation.
2)Why Java is called as “Platform” ?
ans:- A platform is basically the hardware or
software environment in which a program
runs. Java provides software-based platform
i.e. JVM, which can run applications
developed using the Java Programming
Language.

3)What are the features of Java ?

Ans:- Features of Java

1) Simple
Simple syntax. No pointers, no multiple
inheritance with the classes which causes
ambiguity error. For almost every task API
(Application Programming Interface) is
available; Programmer just need to know how
to use that API.
2) Object Oriented
Java is strong object oriented as it does not
allow features like global data, friend function
which are against OOP principles.

3) Automatic Garbage Collection:

Automatic garbage collection is the process of
looking at heap memory, identifying which
objects are in use and which are not, and
deleting the unused objects. An in use object, or
a referenced object, means that some part of
your program still maintains a pointer to that
object. An unused object, or unreferenced
object, is no longer referenced by any part of
your program. So the memory used by an
unreferenced object can be reclaimed.

3) Robust
Robust means strong. Java puts a lot of
emphasis on early checking for possible errors,
as Java compilers are able to detect many
problems that would first show up during
execution time in other languages.
It provides the powerful exception handling and
type checking mechanism as compare to other
programming languages.

4) Platform Independent
Unlike other programming languages such as
C, C++ etc which are compiled into platform
specific machines. Java is guaranteed to be
compile-once, run-anywhere language.
On compilation Java program is compiled into
bytecode. This bytecode is platform
independent and can be run on any machine.
Any machine with Java Runtime Environment
can run Java Programs.
5)

Secure
If a bytecode contains any virus or malicious
code, JVM will not execute it. This features
saves your system especially when u download
java code and try to execute.

6) Multi Threading
Java multithreading feature makes it possible to
write program that can do many tasks
simultaneously.

7) Portable
Java Byte code can be carried to any platform.

8) Architectural Neutral
No implementation dependent features.
Everything related to storage is predefined,
example: size of primitive data types is same on
all the platforms.

8) High Performance
Java enables high performance with the use of
Just-In-Time (JIT) compiler.
4)How java is platform independent ?
Ans:- Java program, once compiled , can be run on
any platform without recompiling.
5) is Java Pure-Object oriented Language ?
Ans:- No. Java is not because it supports Primitive
datatype[^] such as int, byte, long... etc, to be used,
which are not objects.

There are seven qualities to be satisfied for a

programming language to be pure Object Oriented.
They are:
1. Encapsulation/Data Hiding
2. Inheritance
3. Polymorphism
4. Abstraction
5. All predefined types are objects
6. All operations are performed by sending messages
 to objects
7. All user defined types are objects.

5)Which version of java have u learned? Name some

of the new features added to it.
Ans:- java8 version. Some of the new features are:

 default methods and static methods inside

interface

 lambda expressions

 java fx

 method reference

 stream api

 Nashorn engine

6) What is native code?

Ans:- Native code is computer programming (code) that
is compiled to run with a particular processor (such as an
Intel x86-class processor) and its set of instructions.

6)What is the difference bet’n JDK and JRE.

JRE is an acronym for Java Runtime
Environment. It is used to provide
runtime environment. It contains JVM +
API ( jars and dlls)

JDK is an acronym for Java Development

Kit. It contains JRE + development tools
like compiler,debugger etc.

7)What is JVM ? What it does?

Ans:- JVM (Java Virtual Machine) is an
abstract machine. It is a specification that
provides runtime environment in which java
bytecode can be executed.

JVMs are available for various platforms

(i.e.JVM is platform dependent).

It is:
1.A specification where working of Java
Virtual Machine is specified. But
implementation provider is independent to
choose the algorithm. Its implementation
has been provided by Sun and other
companies.

2.An implementation Its implementation

is different for different platforms.

3.Runtime Instance Whenever you write

java command on the command prompt to
 run the java class, and instance of JVM is
created.

The JVM performs following operation:

Loads code

Verifies code

Executes code

Provides runtime environment

8) Why JVM is called as “virtual machine”?

Ans:- The JVM is "virtual" because it is generally
implemented in software on top of a "real" hardware
platform and operating system. All Java programs are
compiled for the JVM. Therefore, the JVM must be
implemented on a particular platform before
compiled Java programs will run on that platform.

9)What is the lifetime of Java Virtual Machine ?

 Ans:- When a Java application starts, a runtime
instance of JVM is born. When the application
completes, the instance dies.

10) What are the main components of JVM?

Explain them. Or Explain JVM Architecture.
Ans:- a) ClassLoader Subsystem b) Various Runtime
Data Areas c) Execution Engine
Class loader Subsystem:

Several parts
Loading
Linking
Initializing

a) Loading
BootStrap class loader
Load classes from “rt.jar” ie. All core
java API classes are loaded.
 Extension class loader
Loads classes from “ext” folder.
Application class loader
Loads classes from application level class
path – set inside environment

Amongst all these “BootStrap class loader” will

get highest priority. If “BootStrap class loader is
unable to load classes then “Extension class
loader” will load the the classes. If “Extension
class loader” is also unable to load class file,
then, “application class loader” will try to load
the class file.

b)Linking
Verify
BytecodeVerifier is going to check whether
ur generated bytecode is proper or not. Ie.
Whether it contains any virus or malicious code
and whether class file format is compatible with
JVM class specification. If verification fails then
 we will get “Verify Error”. Java program is always
secure. You can execute on any machine happily
because Bytecode Verifier is going to take care
,is it valid or not.

Prepare
For static variables memory will be
allocated and assigned with the default values.
( not the values u have initialized with)
Resolve
All symbolic references are replaced with
original references from “Method Area”.
Suppose u have references to other classes,
these are changed from symbolic to the actual
reference
c) Initialization
Static variables are assigned with the values u have
initialized. Static blocks are executed in the textual
order.
After Initialization only “class loading” completed
successfully by “Class Loader SubSystem”.
ClassNotFoundException :- happens when class
loader fails to find the bytecodes correspond to a
class we mention.
ClassDefNotFoundException:- happens during a
“Resolve” phase. E.g if we say
Java X
Now X will be loaded, verified , prepared. Next
step is resolve. Suppose class X contains reference of
class Y, resolve phase will try to find out Y.class. if
class Y can not be found exception will be thrown
“ClassDefNotFoundException” for X which wraps
“ClassNotFoundException” for Y.

Consider following example:

public class X
{
Y ref;
public static void main(String args[])
 {
X ob=new X();
ob.ref=new Y();
}
}
class Y
{
}

After compiling X.java we will get two .class files

X.class and Y.class
if we delete “Y.class” and execute application by
saying
java X
we will get following error:

Exception in thread "main"

java.lang.NoClassDefFoundError: Y
 at X.main(X.java:7)
Caused by: java.lang.ClassNotFoundException: Y

when u say
java Sample.class, Sample.class is an input to
“ClassLoaderSubsytem”.
In short, ClassLoaderSubsytem is responsible to load our
classes. In order to load the classes, some memory is
required.
There are various Runtime DataAreas present inside
JVM.
a) Method area:- will consists of following things:
class bytecode
class loader who loads the class information
reference to class Class
static variables
various literals (String,Integer,float etc)

Type Information
For each type it loads, a Java virtual machine must
store the following kinds of information in the
method area:
• The fully qualified name of the type
• The fully qualified name of the type's direct
superclass (unless the type is an interface or class
java.lang.Object, neither of which have a superclass)
• Whether or not the type is a class or an
interface
• The type's modifiers ( some subset of` public,
abstract, final)
• An ordered list of the fully qualified names of
any direct super-interfaces

Method Information
For each method declared in the type, the following
information must be stored in the method area. As
with fields, the order in which the methods are
declared by the class or interface must be recorded
as well as the data. Here's the list:
• The method's name
 • The method's return type (or void)
• The number and types (in order) of the
method's parameters
• The method's modifiers (some subset of public,
private, protected, static, final, synchronized, native,
abstract)

method tables

A Java virtual machine can always determine the

amount of memory required to represent an object
by looking into the class data stored in the method
area.

Since Java8, there is no “Method Area” , Now it is

called as “metaspace”.
b)Heap area:- objects and corresponding instance
variables will be stored in heap area.

Method area and Heap area are per JVM.

c) Stack area:- for every thread a separate runtime
stack will be created. Each entry (method name) in
the stack is called as “Stack frame”. For every thread,
one runtime stack is there.
So if inside JVM 10 threads are running, 10 stacks are
there.
The data which is stored inside “Stack Memory” is
always a “Thread-Safe”.
It is because that data is available only for that
thread not for other thread and vice-versa.
In case of recursive function if u forget to put a
condition it goes into infinite loop. That is it will go
on creating stack frame over stack frame over stack
frame………….. That means u will go out of space in
stack area memory and u will get
“java.lang.StackOverflowError”

d)PC register:- Program Counter Register

Every thread has got a different PC register which
stores pointer to next line to be executed by JVM.
i.e. to hold address of next executing instruction.
 Suppose u r running three threads T1,T2 and T3.
In this case there will be 3 program counters each for
T1, T2 and T3.
e)Native method stack:- if threads are invoking any
native method, then for every thread a different
stack will be created inside native method stack.

PC registers, Stack and Native Method Stack are per

thread. So Thread1 can’t see what is there in stack
frame created for Thread2 and vice-versa. That
means whatever happens in method execution
generally is thread-safe.
At the same time “Method Area or metaspace(in
java8) “ and “heap area” are not per thread. These
are created per JVM.

Execution engine:-
execution area will communicate with “Memory
areas”.
i.e. once a data area is loaded which is an instruction
to be executed, i.e. current instruction to be
executed is ready ( using PC register) what happens
is that “Java Interpreter” interprets the current
instruction that is there in the bytecode and
executes it.
Execution Engine has 4 components
(i) Interpreter (ii) JIT Compiler (iii) HotSpot
profiler (iv) GC
Interpreter takes bytecode instruction, looks at it
finds out what native operation to be done and
executes that native operation. That is done by using
“native interface” which interfaces the native
libraries which are present in the JVM. If u look at
the JRE bin folder, and if u r on windows u will see lot
of dll files. So those are the platform specific native
libraries used by the Execution Engine. If u r on unix
system or linux system u will see “.so” files inside JRE
bin folder which is the native library.
They allow lot of optimizations in Execution Engine
so java is fast today. E.g JIT Just in time compiler is,
what it does if we have certain instructions which are
executed all the time again and again those will not
 be interpreted again and again. Instead what
happens is the JIT compiler will on the fly compiles
these set of instructions and keeps the target
machine code ready for execution. So there is no
more interpretation involved here. Its only machine
code execution when u know there are so called
“HotSpots” that are repeating in the application so,
that what the HotSpot profiler does it keeps an eye
on bytecodes which are running and grabs lot of
different statistics that are useful in various formats.
So that is the role of HotSpot profiler. e.g. it helps JIT
Compiler to compile frequently used bytecode
instructions.
Inside Execution engine two main imp. Parts are
there:
a) Interpreter
Read , interpret and execute java bytecode line by
line.
b)JIT compiler

There are other components also inside “Execution

Engine”
  Garbage Collector
 Security manager

So “Execution Engine” is a central component of JVM just

like our CPU or just like our “Processor”.
Execution Engine is responsible to run our program.
Interpreter is responsible to execute our program line by
line. With Interpreter we face one problem. Suppose one
method we call multiple times, every time interpretation
must be required. Instead of that if it is a repetitive
required method, better to generate machine code
directly only once, next time without interpreting directly
we can execute. JIT compiler is responsible to that. I.e. It
is used to enhance the execution performance.
So JIT compiler is useful only in case of repeatedly
invoked methods and not for every method.

When JIT compiler will come into picture?

If a method is repeatedly invoked methods.
Who is going to take care whether it is repeatedly
required method or Hotspot method ?
Hotspot Profiler is responsible to identify whether
method is repeatedly required ( i.e. it is HotSpot)

Sometimes while executing java programs my execution

engine may require native method library that’s why we
have “Native Method Libraries “ inside JRE.
Who is responsible to provide “Native Method Libraries”
information?
Java Native Interface [ JNI ]
So Execution Engine will communicate with “JNI”
JNI will provide information about “Native Method
Libraries” to Execution Engine.

11) What is the job done by classloader ?

Ans:- classloader loads the java class. In java , classes
are loaded on demand basis i.e. only when u use the
 class for the first time in ur application, class will be
loaded.

12) Explain the hierarchy of classloaders in java.

Ans:- There are 3 types of class loaders in java
a) BootStrap Class Loader or Premordial Class Loader
b)Extension Class Loader
c) System Class Loader
BootStrap or Premordial class loader :-
BootStrap class loader loads those classes which are
essential for JVM to function properly. BootStrap class
loader is responsible for loading all core java classes for
instance java.lang.* ,java.io.* etc. BootStrap class loader
finds these necessary classes from “jdk/jre/lib/rt.jar” .
Extension class loader :-
Extensions Classloader is the immediate child of
Bootstrap classloader. This classloader loads the classes
in lib\ext directory of the JRE.
System class loader :-
 System-Classpath classloader is the immediate
child of Extensions classloader. It loads the classes
and jars specified by the CLASSPATH environment
variable, java.class.path system property, -cp or
-classpath command line settings. If any of the jars
specified in one of the above manner have a
MANIFEST.MF file with a Class-Path attribute, the jars
specified by the Class-Path attribute are also loaded.
This class loader is also used to load an application’s
entry point class that is the “static void main()”
method in a class.

13) What is the role played by Bytecode Verifier ?

Ans:- Bytecode Verifier performs verification of
bytecodes. When a class loader presents the
bytecodes of a newly loaded Java platform class to
the virtual machine, these bytecodes are first
inspected by a verifier. The verifier checks that the
instructions cannot perform actions that are
obviously damaging. All classes except for system
classes are verified.

14) What are the memory areas allocated by JVM ?

Ans:-
a) Class(Method) Area or metaspace(according to java8):
Class(Method) Area stores per-class structures such as
the runtime constant pool, field and method data, the
code for methods.
b) Heap:
It is the runtime data area in which objects are allocated.
c) Stack:

Java Stack stores frames. It holds local variables and

partial results, and plays a part in method invocation
and return.
Each thread has a private JVM stack, created at the
same time as thread.
A new frame is created each time a method is invoked.
A frame is destroyed when its method invocation
completes.
d) Program Counter Register:
PC (program counter) register. It contains the address of
the Java virtual machine instruction currently being
executed.
e) Native Method Stack:
It contains all the native methods used in the application.
15) What is the difference between Java
compiler ( javac ) and JIT ?
Ans:- javac converts source code into the
bytecode whereas JIT converts bytecode into
native code.

16) Is JRE different for different Platforms ?

Ans:- yes
17) Difference bet’n C++ and java in terms of object
creation.
Ans:- in C++ object can be created on stack as well as
on heap (because java has given importance to late
binding from the very beginning)

18) What is garbage collection ?

Ans:- Automatic garbage collection is the process of
looking at heap memory, identifying which objects
are in use and which are not, and deleting the unused
objects. An in use object, or a referenced object,
means that some part of your program still maintains
a pointer to that object. An unused object, or
unreferenced object, is no longer referenced by any
part of your program. So the memory used by an
unreferenced object can be reclaimed.

19) Can we force garbage collection

programmatically ?
Ans:- no, we can at the most request for Garbage
Collection using “System.gc()” or “Runtime.gc()”

20) What is an alternative for finalized method?

Ans:- It is not recommended to rely on finalize
method because of its non-guaranteed behavior but
then what is alternative of releasing resource,
 performing cleanup because there is no destructor in
Java? Having a method like close() or destroy() make
more sense for releasing resources held by classes. In
fact JDK library follows this. E.g various inputstream
and outputstream implementations are having
“close()” method to release the resources. in fact it’s
one of the best practice to call close method from
finally block in java. Only problem with this approach
is its not automatic, client has to do the cleanup and
if client forgot to do cleanup there are chances
of resources getting leaked, which again suggest us
that we could probably give another chance to
finalize method.
21) What is the difference between System.gc()
and Runtime.getRuntime().gc() ?
Ans:- Both are same. System.gc() is effectively equivalent
to Runtime.gc(). System.gc()internally calls Runtime.gc().
The only difference is System.gc() is a class method
where as Runtime.gc() is an instance method.
So, System.gc() is more convenient.
if you look at System class source code, it has got
following method:
public static void gc()
{
Runtime.getRuntime().gc();
 }

22) When do u get NullPointerException ?

Ans:- when reference variable containing null, used
to invoke member, we get NullPointerException.

23) What is the signature of main function in java ?

Ans:- public static void main(String args[])
or
public static void main(String …
args)

24) Who invokes main() function ?

Ans:- JVM invokes main() function.

25) Can we define more than one public class in a

java source code ? what is the rule of public class
and file name . ?
Ans:- no we can’t define more than one public class
in one source file. Name of the public class and the
file name must match.

26) Difference bet’n path and classpath.

Ans:- path is used for “exe”,”dll” and “bat” files
Classpath is used for “jar” files.
27) What is the rule for local member in java.
Ans:- local member must be initialized before use.

28) What is .class file known as ?

Ans:- java bytecode

29) How java is strong object oriented ?

Ans:- java does not allow global members, friend
function. Everything (variables as well as methods)
must be defined inside the class.

30) What is finalized() method ?

Ans:- finalize method in java is called
before Garbage collector reclaim the Object. It’s last
chance for any object to perform cleanup activity i.e.
releasing any system resources held, closing
connection if open etc. Main issue with finalize
method in java is its not guaranteed by JLS that it will
be called by Garbage collector or exactly when it will
be called, for example an object may wait
indefinitely after becoming eligible for garbage
collection and before its finalize() method gets
called. Because of this reason it make no sense to
use finalize method for releasing critical resources or
 performing time critical activity inside finalize. It may
work in development in one JVM but may not work
in other JVM.
31) Why there is no sizeof operator in java ?
Ans:- because size of all the java datatypes is
identical across all platforms.

32) What kinds of programs u can develop using

Java ?

There are mainly 5 type of

applications that can be created using
java:
a) Standalone Application
It is also known as desktop application
or window-based application. An
application that contain “main”
function as an entry point.
b) Applet
It is a java program which can run on
java-enabled web browser
c) Web Application
 An application that runs on the server
side and creates dynamic page, is
called web application. Currently,
servlet, jsp, struts, jsf etc.
technologies are used for creating web
applications in java.
d) Enterprise Application
An application that is distributed in
nature, such as banking applications
etc. It has the advantage of high level
security, load balancing and
clustering. In java, EJB is used for
creating enterprise applications.
e) Mobile Application
An application that is created for
mobile devices. Currently Android and
Java ME are used for creating mobile
applications.

33) Difference bet’n C++ pointer and Java

reference.
 Ans:- similarity bet’n two is both of them store the
address of heap based object. Difference is c++
pointer can be incremented, decremented and also
can be dereferenced. None of these operations u can
invoke on java reference variable.
34) U have reference type as a member of class.
What is the default value it gets?
Ans:- null

35) What are the expressions allowed in switch

block of java ?
Ans:- byte,short,int,char and String ( jdk 1.7
onwards)

36) In a java source code there are 3 classes define

e.g class A{} class B{} and class C{}. When u compile
the source code how many .class files u get and
what are their names ?
Ans:- A.class, B.classs, C.class

37) What is java’s old name ?

Ans:- oak

38) What are the technologies come under

“Distributed Object System “ ?
Ans:- RMI, CORBA and EJB
 39) What do u mean by Java Enabled Browser, Web
Server and Application Server?
Ans:- Java-Enabled means having “JRE” inside it.

40) What is “this”? What is its importance?

Ans:- this is a reference to the current object or
invoking object. With the help of “this” reference
member function comes to know about the invoking
object. Actually when u invoke any member function,
compiler implicitly passes the “this” reference to the
method being invoked.

41) What is UnsupportedClassVersion error ?

Ans:- when a upper-version class file is executed in the
lower-version JVM, (e.g. javac belongs to 8 and JRE
belongs to 1.7 )
java.lang.UnsupportedClassVersionError occurs.

42) What is Unicode Character Set in Java ?

Ans:- Since Java is designed to support
Internationalization ( I18N ),it makes sense that it would
use Unicode to represent characters. Unicode defines a
fully international character set that can represent all of
the characters found in all human languages. It is a
unification of dozens of character sets such as Latin,
Greek, Arabic and many more. For this purpose, it
requires 16 bits. Thus char in java is 16 bit type. The
range of char is 0 to 65535. There are no negative chars.

43) Explain Java Execution Flow.

Ans:- Virtual Machine Start-Up

A Java virtual machine starts execution by invoking the

method main of some specified class, passing it a single
argument, which is an array of strings if provided else an
empty array.

For example:
java Test

will typically start a Java virtual machine by invoking

method main of class Test .

Load the Class Test

Link Test: Verify, Prepare, (Optionally) Resolve

Linking involves verification, preparation and
(optionally) resolution.
Verification checks that the loaded representation of Test
is well-formed, with a proper symbol table. Verification
also checks that the code that implements Test obeys the
semantic requirements of the Java programming language
and the Java virtual machine. If a problem is detected
during verification, then an error is thrown.

Preparation involves allocation of static storage and any

data structures that are used internally by the virtual
machine, such as method tables.

Resolution is the process of checking symbolic

references from Test to other classes and interfaces, by
loading the other classes and interfaces that are mentioned
and checking that the references are correct.
Resolution can be either “lazy (in case of non-static
references)” or “early (in case of static references)”.

Initialize Test: Execute Initializers

Initialization consists of execution of any class variable
initializers and static initializers of the class Test, in
textual order. But before Test can be initialized, its direct
superclass must be initialized, as well as the direct
superclass of its direct superclass, and so on, recursively.
In the simplest case, Test has Object as its implicit direct
superclass; if class Object has not yet been initialized,
then it must be initialized before Test is initialized. Class
Object has no superclass, so the recursion terminates here.
If class Test has another class Super as its superclass, then
Super must be initialized before Test. This requires
loading, verifying, and preparing Super if this has not
already been done and, depending on the implementation,
may also involve resolving the symbolic references from
Super and so on, recursively.
Initialization may thus cause loading, linking, and
initialization errors, including such errors involving other
types.

Invoke Test.main
Finally, after completion of the initialization for class Test
(during which other consequential loading, linking, and
initializing may have occurred), the method main of Test
is invoked.

The method main must be declared public, static, and

void. It must accept a single argument that is an array of
strings. This method can be declared as either public static
void main(String[] args)
Or public static void main(String... args)

Loading of Classes and Interfaces which are

referenced from main() function………
44) What is the difference bet’n Lazy and Eager
Resolution?
Ans:- e.g. suppose Car class has Engine as a member.
Here if Car has Engine as static member, Engine will
be resolved as soon as Car is loaded ( Eager ). On the
other hand if Car has Engine as non-static member,
Engine will be resolved only after you instantiate the
Car (Lazy).

45) Does Java pass by reference or by

value?
Ans:- Java passes everything by value,
and not by reference. When we say
everything, that means – Primitive types
as well as reference types, these are all
passed by value in Java.
In case of reference types, what happens is
you pass a reference to an object to a method.
Inside method it is collected in another reference
(formal argument) to that same object.
Now you can modify this formal argument inside
the method as much as you want but no matter
how hard you try you'll never be able to modify
the passed reference that will keep referencing
the same Object no matter what!