Java Keywords

Q1)What are different types of access modifiers in Java?

Ans)There are four different types of modifiers:


Accessible in the same package

Accessible in different package






Yes, only if the class extends the main class







Q2) What is the use of final keyword?

Ans)The final keyword can be assigned to:

  1. Class level variable
  2. method
  3. class
  4. Objects

If a final is assigned to a variable, the variable behaves as a constant. It means that value of the variable once set cannot be changed.

final int i = 1;
i = 5; // error

If a final is assigned to a method then it cannot be overridden in its child class.

class Parent {
  final void print() {
class Child extends Parent {
  public final void print() {
   // error cannot  override final method

If a class is made as final, then no other class can extend it and make it as parent class. E.g. String Class cannot be extended.

Final objects are instantiated only once. i.e

final Map map = new HashMap();
map = new HashMap(); // error

Q3)What is the use of synchronized keyword?

Ans)This keyword is helps to prevent concurrent access of a block of code or modifiying objects. Synchronized keyword can be applied to static/non-static methods or a block of code. Only one thread at a time can access synchronized methods and if there are multiple threads trying to access the same method then other threads have to wait for the execution of method by one thread. Synchronized keyword provides a lock on the object and thus prevents race condition. E.g.

public void synchronized simpleMethod() {}
  public void synchronized staticMethod() {}
  public void myMethod() {
    synchronized (this) { // synchronized keyword on block  of code

Q4)What is a volatile keyword?

Ans)In general each thread has its own copy of a variable, such that one thread is not concerned with the value of the same variable in the other thread. But sometimes this may not be the case. Consider a scenario in which the count variable is holding the number of times a method is called for a given class irrespective of any thread calling, in this case, irrespective of thread access the count has to be increased and value needs to be consistent across all the threads. In this case the count variable is declared as volatile.

The copy of a volatile variable is stored in the main memory, so every time a thread access the variable even for reading purpose the local copy is updated each time from the main memory. The volatile variable may have performance issues.

Q5)What is a transient variable?

Ans)If some of the properties of a class are not required to be serialized then the variables are marked as transient. When an object is deserialized the transient variables retains the default value depending on the data type of variable and will loose its original value.

Q6)What is a strictfp modifier?

Ans)Only variables can be marked as strictfp. It is used to restrict floating point calculations ( fp ) to ensure portability ( platform Independent ). When this modifier is specified, the JVM adheres to the Java specifications ( IEEE-754 floating-point specification ) and returns the consistent value independent of the platform. That is, if you want the answers from your code (which uses floating point values) to be consistent across all then platforms, then you need to specify the strictfp modifier.

Q7)What is a static variable?

Ans) Static keyword can be used with the variables and methods but not with the class. Anything declared as static is related to class and not objects.

Static variable: Multiples objects of a class shares the same instance of a static variable.Consider the example:

public class Counter {
 private static int count=0;
 private int nonStaticcount=0;

 public void incrementCounter() {
 public static int getCount() {
  return count;
 public int getNonStaticcount() {
  return nonStaticcount;
 public static void main(String args[]) {
   Counter countObj1 = new Counter(); 
   Counter countObj2 = new Counter();
   System.out.println("Static count for Obj1: "+countObj1.getCount());
   System.out.println("NonStatic count for Obj1: "+countObj1.getNonStaticcount());
   System.out.println("Static count for Obj2: "+countObj2.getCount())
   System.out.println("NonStatic count for Obj2: "+countObj2.getNonStaticcount())
Static count for Obj1: 2
NonStatic count for Obj1: 1
Static count for Obj2: 2
NonStatic count for Obj2: 1

In the above program obj1 and obj2 share the same instance of static variable count hence if the value is incremented by one object , the incremented value will be reflected for obj1 and obj2.

Q8) What is a static method?

Ans) A static method can be accessed without creating the objects. Just by using the Class name the method can be accessed.

Static method can only access static variables and not local or global non-static variables. For eg:

public class Test{
 public static void printMe() {
  System.out.println("Hello World");

public class MainClass {
  public static void main(String args[]) {
Hello World

Static method can call only static methods but not non-static methods. But non-static methods can call static methods.

Q9) Why static methods cannot access non static variables or methods?

Ans) A static method cannot access non static variables or methods because static methods can be accessed without instantiating the class, so if the class is not instantiated the variables are not intialized and thus cannot be accessed from a static method.

Q10) What is a static class?

Ans)A class cannot be declared static except inner class. But a class can be said a static class if all the variables and methods of the class are static and the constructor is private. Making the constructor private will prevent the class to be instantiated. So the only possibility to access is using Class name only

Q9)How is throw keyword used?

Ans) Throw keyword is used to throw the exception manually. It is mainly used when the program fails to satisfy the given condition and it wants to warn the application.The exception thrown should be a subclass of Throwable.

public void parent() {
    try {
        } catch(MyCustomException e) {
          //oops error is here
public void child() throws MyCustomException {
  if(2%2 == 0) {
    throw new MyCustomException("exception using throw keyword");

Q10) What is the use of throws keyword?

Ans) Throws clause is used to throw the exception from a method to the calling method which could decide to handle the exception or throw to its calling method in a class.

 public void parent(){
  try {
      } catch(MyCustomException e) {  }

  public void child throws MyCustomException {
    //put some logic so that the exception occurs.

Further Reading

  1. How java manages Memory?
  2. Why is it advised to use hashcode and equals together?
  3. Comparable and Comparator in java
  4. How to create Singleton class in Java?
  5. Difference between equals and ==?
  6. When to use abstract class over interface?
  7. Cap Theorem in Details
  8. Why is it recommended to use Immutable objects in Java