1.What are the important features of Java 8 release?

Java 8 has been one of the biggest release after Java 5 annotations and generics.
Some of the important features of Java 8 are:

1. Interface changes with default and static methods

2. Functional interfaces and Lambda Expressions
3. Java Stream API for collection classes
4. Java Date Time API

2.What is JVM and is it platform independent?

Java Virtual Machine (JVM) is the heart of java programming language. JVM is
responsible for converting byte code into machine readable code. JVM is not platform
independent, thats why you have different JVM for different operating systems. We can
customize JVM with Java Options, such as allocating minimum and maximum memory
to JVM. It’s called virtual because it provides an interface that doesn’t depend on the
underlying OS.

3.What is the difference between JDK and JVM?

Java Development Kit (JDK) is for development purpose and JVM is a part of it to
execute the java programs.

JDK provides all the tools, executables and binaries required to compile, debug and
execute a Java Program. The execution part is handled by JVM to provide machine
independence.

4.What is the difference between JVM and JRE?

Java Runtime Environment (JRE) is the implementation of JVM. JRE consists of JVM
and java binaries and other classes to execute any program successfully. JRE doesn’t
contain any development tools like java compiler, debugger etc. If you want to execute
any java program, you should have JRE installed.
5.Why Java doesn’t support multiple inheritance?
Java doesn’t support multiple inheritance in classes because of “Diamond Problem”.
However multiple inheritance is supported in interfaces. An interface can extend
multiple interfaces because they just declare the methods and implementation will be
present in the implementing class. So there is no issue of diamond problem with
interfaces.

6.Why Java is not pure Object Oriented language?

Java is not said to be pure object oriented because it support primitive types such as int,
byte, short, long etc

7.What is the importance of main method in Java?

main() method is the entry point of any standalone java application. The syntax of main
method is public static void main(String args[]).

main method is public and static so that java can access it without initializing the class.
The input parameter is an array of String through which we can pass runtime arguments
to the java program.

Method overloading and overriding in java

8.What is overloading and overriding in java?

When we have more than one method with same name in a single class but the
arguments are different, then it is called as method overloading.

Overriding concept comes in picture with inheritance when we have two methods with
same signature, one in parent class and another in child class. We can use @Override
annotation in the child class overridden method to make sure if parent class method is
changed, so as child class.
9.What is method signature? What are the things it
consists of?
Method signature is used by the compiler to differentiate the methods. Method
signature consists of three things.

a) Method name

b) Number of arguments

c) Types of arguments

10.Can we declare one overloaded method as static

and another one as non-static?
Yes. Overloaded methods can be either static or non static.

11.How do compilers differentiate overloaded

methods from duplicate methods?
Compiler uses method signature to check whether the method is overloaded or
duplicated. Duplicate methods will have same method signatures i.e same name, same
number of arguments and same types of arguments. Overloaded methods will also
have same name but differ in number of arguments or else types of arguments.

12.Is it possible to have two methods in a class with

same method signature but different return types?
No, compiler will give duplicate method error. Compiler checks only method signature
for duplication not the return types. If two methods have same method signature,
straight away it gives compile time error.

13.In “MyClass” , there is a method called

“myMethod” with four different overloaded forms. All
four different forms have different visibility ( private,
protected, public and default). Is “myMethod” properly
overloaded?
Yes. Compiler checks only method signature for overloading of methods not the visibility
of methods.

14.Can overloaded methods be synchronized?

Yes. Overloaded methods can be synchronized.

15.Can we overload main() method?

Yes, we can overload main() method. A class can have any number of main() methods
but execution starts from public static void main(String[] args) only.

16.In the below class, is constructor overloaded or is

method overloaded?
?
1
2 public class A
{
3
public A()
4 {
5 //-----> (1)
6 }
7
8 void A()
{
9 //-----> (2)
10 }
11 }
12

None of them. It is neither constructor overloaded nor method overloaded. First one is a
constructor and second one is a method.

17.Overloading is the best example of dynamic

binding. True or false?
False. Overloading is the best example for static binding.

18.Can overloaded method be overrided?

Yes, we can override a method which is overloaded in super class.
Method signature have one more point it also depends on
3. Order of parameters…
ex: class A{
void method(Double a, int b){
}
void method(int a, Double b){
}
}
But we need pass the parameter declared order…in order to get correct output

19.DifferenceBetween Static Binding And Dynamic

Binding In Java
Before knowing what are the differences between static binding and dynamic binding in
java, let’s know what is binding first.
Binding refers to the link between method call and method definition. This picture
clearly shows what is binding.

In this picture, “a1.methodOne()” call is binding to

corresponding methodOne() definition and“a1.methodTwo()” call is binding to
corresponding methodTwo() definition.

For every method call there should be proper method definition. This is a rule in java. If
compiler does not see the proper method definition for every method call, it throws
error.

Now, come to static binding and dynamic binding in java.

Static Binding In Java :

Static binding is a binding which happens during compilation. It is also called early
binding because binding happens before a program actually runs. Static binding can be
demonstrated like in the below picture.

In this picture, ‘a1’ is a reference variable of type Class A pointing to object of class
A. ‘a2’ is also reference variable of type class A but pointing to object of Class B.
During compilation, while binding, compiler does not check the type of object to which a
particular reference variable is pointing. It just checks the type of reference variable
through which a method is called and checks whether there exist a method definition for
it in that type.

For example, for “a1.method()” method call in the above picture, compiler checks
whether there exist method definition for method() in Class A. Because ‘a1′ is Class A
type. Similarly, for“a2.method()” method call, it checks whether there exist method
definition for method() in Class A. Because ‘a2′ is also Class A type. It does not check
to which object, ‘a1’ and ‘a2’ are pointing. This type of binding is called static binding.

Dynamic Binding In Java :Dynamic binding is a binding which happens during run
time. It is also called late binding because binding happens when program actually is
running. During run time actual objects are used for binding. For example,
for “a1.method()” call in the above picture, method() of actual object to which ‘a1’ is
pointing will be called. For“a2.method()” call, method() of actual object to which ‘a2’ is
pointing will be called. This type of binding is called dynamic binding.
The dynamic binding of above example can be d

demonstrated like below.

20.Differences between Static Binding and Dynamic
Binding In Java:
The above findings can be summarized like below.

Static Binding Dynamic Binding

It is a binding that happens at compile

time. It is a binding that happens at run time.

Actual object is not used for binding. Actual object is used for binding.

It is also called early binding because It is also called late binding because
binding happens during compilation. binding happens at run time.

Method overloading is the best example of Method overriding is the best example of
static binding. dynamic binding.

Private, static and final methods Other than private, static and final
show static binding. Because, they cannot methods show dynamic binding. Because,
be overridden. they can be overridden.

3) What is method hiding in Java?

static method cannot be overriding in Java because their method calls are resolved at
compile time but it didn't prevent you from declaring method with same name in sub
class. In this case we say that method in sub class has hided static method from parent
class. If you have a case where variable of Parent class is pointing to object of Child
class then also static method from Parent class is called because overloading is
resolved at compile time.
21.What is Java Package and which package is
imported by default?
Java package is the mechanism to organize the java classes by grouping them. The
grouping logic can be based on functionality or modules based.

22.What are access modifiers?

Java provides access control through public, private and protected access modifier
keywords. When none of these are used, it’s called default access modifier.
A java class can only have public or default access modifier.

23. What is final keyword?

final keyword is used with Class to make sure no other class can extend it, for example
String class is final and we can’t extend it.

We can use final keyword with methods to make sure child classes can’t override it.

final keyword can be used with variables to make sure that it can be assigned only
once.

Java interface variables are by default final and static.

24. What is finally and finalize in java?

finally block is used with try-catch to put the code that you want to get executed always,
even if any exception is thrown by the try-catch block. finally block is mostly used to
release resources created in the try block.

finalize() is a special method in Object class that we can override in our classes. This
method get’s called by garbage collector when the object is getting garbage collected.
This method is usually overridden to release system resources when object is garbage
collected.

Declaration
Following is the declaration for java.lang.Object.finalize() method
protected void finalize()

Parameters
NA

Return Value
This method does not return a value.

Exception
Throwable -- the Exception raised by this method

Example
The following example shows the usage of lang.Object.finalize() method.
package com.tutorialspoint;

import java.util.*;

public class ObjectDemo extends GregorianCalendar {

public static void main(String[] args) {

try {
// create a new ObjectDemo object
ObjectDemo cal = new ObjectDemo();

// print current time

System.out.println("" + cal.getTime());

// finalize cal
System.out.println("Finalizing...");
cal.finalize();
System.out.println("Finalized.");

} catch (Throwable ex) {

ex.printStackTrace();
}

}
}
25. Can we declare a class as static?
We can’t declare a top-level class as static however an inner class can be declared as
static. If inner class is declared as static, it’s called static nested class.
Static nested class is same as any other top-level class and is nested for only
packaging convenience.

26.What is static import?

If we have to use any static variable or method from other class, usually we import the
class and then use the method/variable with class name.

import java.lang.Math;

//inside class

double test = Math.PI * 5;

We can do the same thing by importing the static method or variable only and then use
it in the class as if it belongs to it.

import static java.lang.Math.PI;

//no need to refer class now

double test = PI * 5;

Use of static import can cause confusion, so it’s better to avoid it. Overuse of static
import can make your program unreadable and unmaintainable.
27. What is try-with-resources in java?
One of the Java 7 features is try-with-resources statement for automatic resource
management. Before Java 7, there was no auto resource management and we should
explicitly close the resource. Usually, it was done in the finally block of a try-catch
statement. This approach used to cause memory leaks when we forgot to close the
resource.

From Java 7, we can create resources inside try block and use it. Java takes care of
closing it as soon as try-catch block gets finished.

Before Java 7:

try{

//open resources like File, Database connection, Sockets

etc

} catch (FileNotFoundException e) {

// Exception handling like FileNotFoundException,

IOException etc

}finally{

// close resources

}
Java 7 try with resources implementation:

try(// open resources here){

// use resources

} catch (FileNotFoundException e) {

// exception handling

// resources are closed as soon as try-catch block is executed.

Java 7 Try With Resources Example

package com.journaldev.util;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class Java7ResourceManagement {

public static void main(String[] args) {

try (BufferedReader br = new BufferedReader(new

FileReader(

"C:\\journaldev.txt"))) {
 System.out.println(br.readLine());

} catch (IOException e) {

e.printStackTrace();

Java try with resources benefits

Some of the benefits of using try with resources in java are;

1. More readable code and easy to write.

2. Automatic resource management.
3. Number of lines of code is reduced.
4. No need of finally block just to close the resources.
5. We can open multiple resources in try-with-resources statement separated by a
semicolon.

28. What is multi-catch block in java?

Java 7 one of the improvement was multi-catch block where we can catch multiple
exceptions in a single catch block. This makes are code shorter and cleaner when every
catch block has similar code.

If a catch block handles multiple exception, you can separate them using a pipe (|) and
in this case exception parameter (ex) is final, so you can’t change it.

Before Java 7:
1
2 catch (IOException ex) {
logger.error(ex);
3 throw new MyException(ex.getMessage());
4 catch (SQLException ex) {
5 logger.error(ex);
6 throw new MyException(ex.getMessage());
7 }catch (Exception ex) {
logger.error(ex);
8 throw new MyException(ex.getMessage());
9 }
10
In Java 7, we can catch all these exceptions in a single catch block as:

1 catch(IOException | SQLException | Exception ex){

2 logger.error(ex);
3 throw new MyException(ex.getMessage());
4 }

29. What is static block?

Java static block is the group of statements that gets executed when the class is loaded
into memory by Java ClassLoader. It is used to initialize static variables of the class.
Mostly it’s used to create static resources when class is loaded.

30. What is an interface?

Interfaces are core part of java programming language and used a lot not only in JDK
but also java design patterns, most of the frameworks and tools. Interfaces provide a
way to achieve abstraction in java and used to define the contract for the subclasses to
implement.

Interfaces are good for starting point to define Type and create top level hierarchy in our
code. Since a java class can implements multiple interfaces, it’s better to use interfaces
as super class in most of the cases.

31. What is an abstract class?

Abstract classes are used in java to create a class with some default method
implementation for subclasses. An abstract class can have abstract method without
body and it can have methods with implementation also.

abstract keyword is used to create a abstract class. Abstract classes can’t be

instantiated and mostly used to provide base for sub-classes to extend and implement
the abstract methods and override or use the implemented methods in abstract class.

32. What is the difference between abstract class and

interface?
abstract keyword is used to create abstract class whereas interface is the keyword for
interfaces.

Abstract classes can have method implementations whereas interfaces can’t.

A class can extend only one abstract class but it can implement multiple interfaces.

We can run abstract class if it has main() method whereas we can’t run an interface.

33. Can an interface implement or extend another

interface?
Interfaces don’t implement another interface, they extend it. Since interfaces can’t have
method implementations, there is no issue of diamond problem. That’s why we have
multiple inheritance in interfaces i.e an interface can extend multiple interfaces.

34. What is Marker interface?

A marker interface is an empty interface without any method but used to force some
functionality in implementing classes by Java. Some of the well known marker
interfaces are Serializable and Cloneable.

35. What are Wrapper classes?

Java wrapper classes are the Object representation of eight primitive types in java. All
the wrapper classes in java are immutable and final. Java 5 autoboxing and unboxing
allows easy conversion between primitive types and their corresponding wrapper
classes.

36. What is Enum in Java?

Enum was introduced in Java 1.5 as a new type whose fields consists of fixed set of
constants. For example, in Java we can create Direction as enum with fixed fields as
EAST, WEST, NORTH, SOUTH.

enum is the keyword to create an enum type and similar to class. Enum constants are
implicitly static and final.

37. What is Java Reflection API? Why it’s so important

to have?
Java Reflection API provides ability to inspect and modify the runtime behavior of java
application. We can inspect a java class, interface, enum and get their methods and
field details. Reflection API is an advanced topic and we should avoid it in normal
programming. Reflection API usage can break the design pattern such as Singleton
pattern by invoking the private constructor i.e violating the rules of access modifiers.

Even though we don’t use Reflection API in normal programming, it’s very important to
have. We can’t have any frameworks such as Spring, Hibernate or servers such as
Tomcat, JBoss without Reflection API. They invoke the appropriate methods and
instantiate classes through reflection API and use it a lot for other processing.

38. What is Java Reflection API? Why it’s so important

to have?
Java Reflection API provides ability to inspect and modify the runtime behavior of java
application. We can inspect a java class, interface, enum and get their methods and
field details. Reflection API is an advanced topic and we should avoid it in normal
programming. Reflection API usage can break the design pattern such as Singleton
pattern by invoking the private constructor i.e violating the rules of access modifiers.

Even though we don’t use Reflection API in normal programming, it’s very important to
have. We can’t have any frameworks such as Spring, Hibernate or servers such as
Tomcat, JBoss without Reflection API. They invoke the appropriate methods and
instantiate classes through reflection API and use it a lot for other processing.

39. What is Java Annotations?

Java Annotations provide information about the code and they have no direct effect on
the code they annotate. Annotations are introduced in Java 5. Annotation is metadata
about the program embedded in the program itself. It can be parsed by the annotation
parsing tool or by compiler. We can also specify annotation availability to either compile
time only or till runtime also. Java Built-in annotations are @Override, @Deprecated
and @SuppressWarnings.

40. What is composition in java?

Composition is the design technique to implement has-a relationship in classes. We can
use Object composition for code reuse.

Java composition is achieved by using instance variables that refers to other objects.
Benefit of using composition is that we can control the visibility of other object to client
classes and reuse only what we need.

41. What is the benefit of Composition over

Inheritance?
One of the best practices of java programming is to “favor composition over
inheritance”. Some of the possible reasons are:

 Any change in the superclass might affect subclass even though we might not be using
the superclass methods. For example, if we have a method test() in subclass and
 suddenly somebody introduces a method test() in superclass, we will get compilation
errors in subclass. Composition will never face this issue because we are using only what
methods we need.
 Inheritance exposes all the super class methods and variables to client and if we have no
control in designing superclass, it can lead to security holes. Composition allows us to
provide restricted access to the methods and hence more secure.
 We can get runtime binding in composition where inheritance binds the classes at compile
time. So composition provides flexibility in invocation of methods.

42. How to sort a collection of custom Objects in

Java?
We need to implement Comparable interface to support sorting of custom objects in a
collection. Comparable interface has compareTo(T obj) method which is used by sorting
methods and by providing this method implementation, we can provide default way to
sort custom objects collection.

However, if you want to sort based on different criteria, such as sorting an Employees
collection based on salary or age, then we can create Comparator instances and pass it
as sorting methodology.

43. What is inner class in java?

We can define a class inside a class and they are called nested classes. Any non-static
nested class is known as inner class. Inner classes are associated with the object of the
class and they can access all the variables and methods of the outer class. Since inner
classes are associated with instance, we can’t have any static variables in them.

We can have local inner class or anonymous inner class inside a class.

44. What is anonymous inner class?

A local inner class without name is known as anonymous inner class. An anonymous
class is defined and instantiated in a single statement. Anonymous inner class always
extend a class or implement an interface.

Since an anonymous class has no name, it is not possible to define a constructor for an
anonymous class. Anonymous inner classes are accessible only at the point where it is
defined.

45. What is Classloader in Java?

Java Classloader is the program that loads byte code program into memory when we
want to access any class. We can create our own classloader by extending
ClassLoader class and overriding loadClass(String name) method.

46. What are different types of classloaders?

There are three types of built-in Class Loaders in Java:

1. Bootstrap Class Loader – It loads JDK internal classes, typically loads rt.jar and
other core classes.
2. Extensions Class Loader – It loads classes from the JDK extensions directory,
usually $JAVA_HOME/lib/ext directory.
3. System Class Loader – It loads classes from the current classpath that can be set
while invoking a program using -cp or -classpath command line options.

47.What is ternary operator in java?

Java ternary operator is the only conditional operator that takes three operands. It’s a
one liner replacement for if-then-else statement and used a lot in java programming.

48. What does super keyword do?

super keyword can be used to access super class method when you have overridden
the method in the child class.
We can use super keyword to invoke super class constructor in child class constructor
but in this case it should be the first statement in the constructor method.

package com.journaldev.access;

public class SuperClass {

public SuperClass(){

public SuperClass(int i){}

public void test(){

System.out.println("super class test method");

Use of super keyword can be seen in below child class implementation.

package com.journaldev.access;

public class ChildClass extends SuperClass {

 public ChildClass(String str){

//access super class constructor with super keyword

super();

//access child class method

test();

//use super to access super class method

super.test();

@Override

public void test(){

System.out.println("child class test method");

49. What is break and continue statement?

We can use break statement to terminate for, while, or do-while loop. We can use break
statement in switch statement to exit the switch case. You can see the example of break
statement at java break. We can use break with label to terminate the nested loops.
The continue statement skips the current iteration of a for, while or do-while loop. We
can use continue statement with label to skip the current iteration of outermost loop.

50. What is this keyword?

this keyword provides reference to the current object and it’s mostly used to make sure
that object variables are used, not the local variables having same name.

//constructor

public Point(int x, int y) {

this.x = x;

this.y = y;

We can also use this keyword to invoke other constructors from a constructor.

public Rectangle() {

this(0, 0, 0, 0);

public Rectangle(int width, int height) {

this(0, 0, width, height);

public Rectangle(int x, int y, int width, int height) {

this.x = x;

this.y = y;
 this.width = width;

this.height = height;

51.What is default constructor?

No argument constructor of a class is known as default constructor. When we
don’t define any constructor for the class, java compiler automatically creates the
default no-args constructor for the class. If there are other constructors defined,
then compiler won’t create default constructor for us.

52.Can we have try without catch block?

Yes, we can have try-finally statement and hence avoiding catch block.

53. What is Garbage Collection?

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. In Java, process of
deallocating memory is handled automatically by the garbage collector.

We can run the garbage collector with code Runtime.getRuntime().gc() or use

utility methodSystem.gc().

54.What is Serialization and Deserialization?

We can convert a Java object to an Stream that is called Serialization. Once an object is
converted to Stream, it can be saved to file or send over the network or used in socket
connections.
The object should implement Serializable interface and we can use
java.io.ObjectOutputStream to write object to file or to any OutputStream object.

The process of converting stream data created through serialization to Object is called
deserialization.

55. How to run a JAR file through command prompt?

We can run a jar file using java command but it requires Main-Class entry in jar manifest
file. Main-Class is the entry point of the jar and used by java command to execute the
class.

56. What is the use of System class?

Java System Class is one of the core classes. One of the easiest way to log information
for debugging is System.out.print() method.

System class is final so that we can’t subclass and override it’s behavior through
inheritance. System class doesn’t provide any public constructors, so we can’t
instantiate this class and that’s why all of it’s methods are static.

Some of the utility methods of System class are for array copy, get current time, reading
environment variables.

57. What is instanceof keyword?

We can use instanceof keyword to check if an object belongs to a class or not. We
should avoid it’s usage as much as possible. Sample usage is:

public static void main(String args[]){

Object str = new String("abc");

 if(str instanceof String){

System.out.println("String value:"+str);

if(str instanceof Integer){

System.out.println("Integer value:"+str);

Since str is of type String at runtime, first if statement evaluates to true and second one
to false.

58. Can we use String with switch case?

One of the Java 7 feature was improvement of switch case of allow Strings. So if you
are using Java 7 or higher version, you can use String in switch-case statements.

59. What is difference between Heap and Stack

Memory?
Major difference between Heap and Stack memory are as follows:

 Heap memory is used by all the parts of the application whereas stack memory is
used only by one thread of execution.
 Whenever an object is created, it’s always stored in the Heap space and stack
memory contains the reference to it. Stack memory only contains local primitive
variables and reference variables to objects in heap space.
 Memory management in stack is done in LIFO manner whereas it’s more complex
in Heap memory because it’s used globally.
60. Java Compiler is stored in JDK, JRE or JVM?
The task of java compiler is to convert java program into bytecode, we
have javac executable for that. So it must be stored in JDK, we don’t need it in JRE
and JVM is just the specs.

61. What will be the output of following programs?

1. static method in class

2. package com.journaldev.util;

3.

4. public class Test {

5.

6. public static String toString(){

7. System.out.println("Test toString called");

8. return "";

9. }

10.

11. public static void main(String args[]){

12. System.out.println(toString());

13. }

Answer: The code won’t compile because we can’t have an Object class
method with static keyword. You will get compile time error as “This static
 method cannot hide the instance method from Object”. The reason is that
static method belongs to class and since every class base is Object, we
can’t have same method in instance as well as in class.

14. static method invocation

15. package com.journaldev.util;

16.

17. public class Test {

18.

19. public static String foo(){

20. System.out.println("Test foo called");

21. return "";

22. }

23.

24. public static void main(String args[]){

25. Test obj = null;

26. System.out.println(obj.foo());

27. }

Answer: Well this is a strange situation. We all have

seen NullPointerException when we invoke a method on object that is
NULL. But here this program will work and prints “Test foo called”.
 The reason for this is the java compiler code optimization. When the java
code is compiled to produced byte code, it figures out that foo() is a static
method and should be called using class. So it changes the method
call obj.foo() to Test.foo() and hence no NullPointerException.

I must admit that it’s a very tricky question and if you are interviewing

someone, this will blow his mind off.

62. What is multithreading?

Multithreading is a process of executing multiple threads simultaneously. Its main

advantage is:

o Threads share the same address space.

o Thread is lightweight.

o Cost of communication between process is low.

63. What is thread?

A thread is a lightweight sub process. It is a separate path of execution. It is called separate

path of execution because each thread runs in a separate stack frame.

64. What is the difference between preemptive scheduling and

time slicing?

Under preemptive scheduling, the highest priority task executes until it enters the waiting or
dead states or a higher priority task comes into existence. Under time slicing, a task
executes for a predefined slice of time and then reenters the pool of ready tasks. The
scheduler then determines which task should execute next, based on priority and other
factors.

65. The join() method

The join() method waits for a thread to die. In other words, it causes the currently running
threads to stop executing until the thread it joins with completes its task.
Syntax:

public void join()throws InterruptedException

public void join(long milliseconds)throws InterruptedException

66. What is difference between wait() and sleep() method?

wait() sleep()

1) The wait() method is defined in Object class. The sleep() method is defined in Thread class.

2) wait() method releases the lock. The sleep() method doesn't releases the lock.

67.Is it possible to start a thread twice?

No, there is no possibility to start a thread twice. If we does, it throws an exception

(java.lang.IllegalThreadStateException).

68.Can we call the run() method instead of start()?

yes, but it will not work as a thread rather it will work as a normal object so there will not
be context-switching between the threads.

69. Daemon thread in java is a service provider thread that provides services to the user
thread. Its life depend on the mercy of user threads i.e. when all the user threads dies, JVM
terminates this thread automatically. It is a low priority thread.

There are many java daemon threads running automatically e.g. gc, finalizer etc.
You can see all the detail by typing the jconsole in the command prompt. The jconsole tool
provides information about the loaded classes, memory usage, running threads etc.

70. Why JVM terminates the daemon thread if there is no user

thread?

The sole purpose of the daemon thread is that it provides services to user thread for
background supporting task. If there is no user thread, why should JVM keep running this
thread. That is why JVM terminates the daemon thread if there is no user thread.

71. Methods for Java Daemon thread by Thread class

The java.lang.Thread class provides two methods for java daemon thread.

No. Method Description

1) public void setDaemon(boolean status) is used to mark the current thread as daemon threa

2) public boolean isDaemon() is used to check that current is daemon.

Note: If you want to make a user thread as Daemon, it must not be started otherwise it will throw
IllegalThreadStateException.

72.What is shutdown hook?

The shutdown hook can be used to perform cleanup resource or save the state when JVM
shuts down normally or abruptly. Performing clean resource means closing log file, sending
some alerts or something else. So if you want to execute some code before JVM shuts
down, use shutdown hook.

When does the JVM shut down?

The JVM shuts down when:

o user presses ctrl+c on the command prompt

o System.exit(int) method is invoked

 o user logoff

o user shutdown etc.

The addShutdownHook(Thread hook) method

The addShutdownHook() method of Runtime class is used to register the thread with the
Virtual Machine. Syntax:

1. public void addShutdownHook(Thread hook){}

The object of Runtime class can be obtained by calling the static factory method
getRuntime(). For example:

Runtime r = Runtime.getRuntime();

Factory method

The method that returns the instance of a class is known as factory method.

Simple example of Shutdown Hook

1. class MyThread extends Thread{

2. public void run(){
3. System.out.println("shut down hook task completed..");
4. }
5. }
6.
7. public class TestShutdown1{
8. public static void main(String[] args)throws Exception {
9.
10. Runtime r=Runtime.getRuntime();
11. r.addShutdownHook(new MyThread());
12.
13. System.out.println("Now main sleeping... press ctrl+c to exit");
14. try{Thread.sleep(3000);}catch (Exception e) {}
15. }
16. }
Output:Now main sleeping... press ctrl+c to exit
shut down hook task completed..

Note: The shutdown sequence can be stopped by invoking the halt(int) method of Runtime class.

Interrupting a Thread:
If any thread is in sleeping or waiting state (i.e. sleep() or wait() is invoked), calling the
interrupt() method on the thread, breaks out the sleeping or waiting state throwing
InterruptedException. If the thread is not in the sleeping or waiting state, calling the
interrupt() method performs normal behaviour and doesn't interrupt the thread but sets
the interrupt flag to true. Let's first see the methods provided by the Thread class for
thread interruption.

The 3 methods provided by the Thread class for

interrupting a thread
o public void interrupt()

o public static boolean interrupted()

o public boolean isInterrupted()

Synchronization in Java
Synchronization in java is the capability to control the access of multiple threads to
any shared resource.

Java Synchronization is better option where we want to allow only one thread to access the
shared resource.
 Why use Synchronization
The synchronization is mainly used to

1. To prevent thread interference.

2. To prevent consistency problem.

Types of Synchronization
There are two types of synchronization

1. Process Synchronization

2. Thread Synchronization

Here, we will discuss only thread synchronization.

Thread Synchronization
There are two types of thread synchronization mutual exclusive and inter-thread
communication.

1. Mutual Exclusive

1. Synchronized method.

2. Synchronized block.

3. static synchronization.

2. Cooperation (Inter-thread communication in java)

73.What is the purpose of Synchronized block?

o Synchronized block is used to lock an object for any shared resource.

o Scope of synchronized block is smaller than the method.

Syntax to use synchronized block

1. synchronized (object reference expression) {
2. //code block
3. }

74.Can Java object be locked down for exclusive use by a given

thread?

Yes. You can lock an object by putting it in a "synchronized" block. The locked object is
inaccessible to any thread other than the one that explicitly claimed it.

75.What is static synchronization?

If you make any static method as synchronized, the lock will be on the class not on object.

76.What is the difference between notify() and notifyAll()?

The notify() is used to unblock one waiting thread whereas notifyAll() method is used to
unblock all the threads in waiting state.

77.What is deadlock?

Deadlock is a situation when two threads are waiting on each other to release a resource.
Each thread waiting for a resource which is held by the other waiting thread.