50 Java Keywords With Examples 73e5q

50 Java Keywords with Examples 1) abstract: abstract keyword is used to implement the abstraction in java. A method which doesn’t have method definition must be declared as abstract and the class containing it must be declared as abstract. You can’t instantiate abstract classes. Abstract methods must be implemented in the sub classes. You can’t use abstract keyword with variables and constructors. abstract class AbstractClass { abstract void abstractMethod(); }

In the computer science perspective, Abstraction is the process of separating ideas from their action. (Courtesy: Wiki). Yes, In the computer science, Abstraction is used to separate ideas from their implementation. Abstraction in java is used to define only ideas in one class so that the idea can be implemented by its sub classes according to their requirements. For example, abstract class Animal { abstract void soundOfAnimal(); // It is just an idea } class Cat extends Animal { void soundOfAnimal() { System.out.println("Meoh"); //Implementation of the idea according to requirements of sub class } } class Dog extends Animal { void soundOfAnimal() { System.out.println("Bow Bow"); //Implementation of the idea according to requirements of sub class } }

Abstraction in java is implemented using Abstract classes and interfaces.Today we will discuss only Abstract Classes. In the next concept, we will discuss about interfaces. Abstract Classes: Abstract classes contain abstract methods (you can refer them as ideas) so that they can be implemented in sub classes according to their requirements. They are also called as incomplete classes as they have some unimplemented abstract methods(ideas). Let’s discuss some rules need to follow while using abstract classes and abstract methods. 

Abstract classes and abstract methods are declared using ‘abstract‘keyword. We can’t create objects to those classes which are declared as abstract. But, we can create objects to sub classes of abstract class, provided they must implement abstract methods.

abstract class AbstractClass { abstract void abstractMethod(); } class ConcreteClass extends AbstractClass { void abstractMethod() { System.out.println("Abstract Method Implemented"); } } public class Abstraction { public static void main(String[] args) { //AbstractClass A = new AbstractClass(); Can't create objects to Abstract class ConcreteClass C = new ConcreteClass(); //ConcreteClass implements abstract method, //so we can create object to ConcreteClass AbstractClass A1 = C; //ConcreteClass object is auto-upcasted to AbsractClass } } 

The methods which are not implemented or which don’t have definitions must be declared with ‘abstract’ keyword and the class which contains it must be also declared as abstract.

// It gives compile time error class AbstractClass { void abstractMethod(); //This method must be declared as abstract or must be defined abstract void abstractMethod(); //The Class must be also declared as abstract } // ***** ***** ***** ***** // This is OK abstract class AbstractClass { abstract void abstractMethod(); } 

It is not compulsory that abstract class must have abstract methods. It may or may not have abstract methods. But the class which has at least one abstract method must be declared as abstract.

abstract class AbstractClass { void methodOne() { //Concrete Method } //No Abstract methods but class is abstract } 

You can’t create objects to abstract class even though it does not contain any abstract methods.

abstract class AbstractClass { void methodOne() { //Concrete Method } void methodTwo() { //Concrete Method } } public class Abstraction { public static void main(String[] args) { AbstractClass a = new AbstractClass(); //Compile time error //You can't create objects to AbstractClass //even though it does not contain any abstract methods. } } 

Abstract Class can be a combination of concrete and abstract methods.

abstract class AbstractClass { void methodOne() { //Concrete Method } void methodTwo() { //Concrete Method } abstract void methodThree(); //Abstract Method abstract void methodFour(); //Abstract Method } 

Any class extending an abstract class must implement all abstract methods. If it does not implement, it must be declared as abstract.

abstract class AbstractClass { abstract void abstractMethodOne(); //Abstract Method abstract void abstractMethodTwo(); //Abstract Method } class ConcreteClass extends AbstractClass { void abstractMethodOne() { //abstractMethodOne() is implemented } //This class must implement second abstract method also, //otherwise, this class has to be declared as abstract void abstractMethodTwo() { //abstractMethodTwo() is also implemented. //No need to declare this class as abstract

} } 

Inside abstract class, we can keep any number of constructors. If you are not keeping any constructors, then compiler will keep default constructor.

abstract class AbstractClass { AbstractClass() { //First Constructor } AbstractClass(int i) { //Second Constructor } abstract void abstractMethodOne(); } 

//Abstract Method

Abstract methods can not be private. Because, abstract methods must be implemented somehow in the sub classes. If you declare them as private, then you can’t use them outside the class.

abstract class AbstractClass { private abstract void abstractMethodOne(); //Compile time error, abstract method can not be private. } 

Constructors and fields can not be declared as abstract.

abstract class AbstractClass { abstract int i; //Compile time error, field can not be abstract abstract AbstractClass() { //Compile time error, constructor can not be abstract } } 

Abstract methods cannot be static.

abstract class AbstractClass { static abstract void abstractMethod(); //Compile time error, abstract methods can not be static }

That’s it for today. Tomorrow we will discuss about interfaces, another way of implementing abstraction in java. 2) assert: assert keyword is used in the assertion statements. These statements will enable you to test your assumptions about a program. Assertion statements provide the best way to detect and correct the programming errors. Assertion statements take one boolean expression

as input and assumes that this will be always true. If the boolean expression returns false, AssertionError will be thrown. public class MainClass { public static void main(String[] args) { System.out.println("Enter your marks"); Scanner sc = new Scanner(System.in); int marks = sc.nextInt(); assert marks > 35 : "FAIL"; } }

3) boolean: boolean keyword is used to define boolean type variables. boolean type variables can hold only two values – either true or false. boolean isActive = true;

4) break: The break keyword is used to stop the execution of a loop(for, while, switch-case) based on some condition. public class MainClass { public static void main(String[] args) { for (int i = 0; i < 100; i++) { System.out.println(i); if(i == 50) { break; } } } }

5) byte: byte keyword is used to declare byte type of variables. A byte variable can hold a numeric value in the range from -128 to 127. byte b = 50;

6) switch 7) case: Both switch and case keywords are used in the switch-case statement. public class MainClass { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Enter Day :"); int day = sc.nextInt(); switch (day) { case 1 : System.out.println("SUNDAY"); break;

case 2 : System.out.println("MONDAY"); break; case 3 : System.out.println("TUESDAY"); break; case 4 : System.out.println("WEDNESDAY"); break; case 5 : System.out.println("THURSDAY"); break; case 6 : System.out.println("FRIDAY"); break; case 7 : System.out.println("SATURDAY"); break; default: System.out.println("Invalid"); break; } } }

8) try 9) catch 10) finally: try, catch and finally keywords are used to handle the exceptions in java. The statements which are to be monitored for exceptions are kept in the try block. The exceptions thrown by the try block are caught in the catch block. finally block is always executed. [See more] public class MainClass { public static void main(String[] args) { try { int i = Integer.parseInt("abc"); } catch(NumberFormatException ex) { System.out.println(ex); } finally { System.out.println("This will be always executed"); } } }

Exception handling in java is implemented using five keywords. 1) try

2)catch

3)finally

4)throw

5)throws

Today we will discuss about try, catch and finally keywords. Remaining keywords will be discussed in subsequent concepts. try, catch and finally keywords are main fundamentals of exception handling in java. The syntax for using these three keywords is,

try { //This is the try block //In this block, keep those statements which may //throw run time exceptions } catch(Exception e) { //This is the catch block. //It takes one argument of type java.lang.Exception //This block catches the exceptions thrown by try block } finally { //This is the finally block. }

try block : In try block, keep those statements which may throw exceptions during run time. catch block : This block handles the exceptions thrown by try block. It takes one argument of type java.lang.Exception. finally block : Whether exception is thrown or not and thrown exception is caught or not, this block will be always executed. For example, public class ExceptionHandling { public static void main(String[] args) { String[] s = {"abc", "123", "xyz", "456"}; //String Array containing valid and invalid numeric values for (int i = 0; i < s.length; i++) { try { int intValue = Integer.parseInt(s[i]); //This statement may throw NumberFormatException } catch(NumberFormatException ex) { System.out.println("The thrown NumberFormatException will be caught here"); } finally { System.out.println("This block is always executed"); } } } }

In the above example, A string array, containing valid and invalid numeric values, is iterated through for loop. Each element of an array is parsed to primitive int type. Element with valid numeric value is parsed without throwing an exception. Element with invalid numeric value

can not be parsed to int type and it throws the NumberFormatException. This exception is caught in catch block making the flow of the program normal. finally block is executed for every iteration whether element is parsed or not. 

When a statement throws an exception in the try block, the remaining part of the try block will not be executed. Program control comes out of the try block and enters directly into catch block.

public class ExceptionHandling { public static void main(String[] args) { try { int i = 10/0; //This statement throws ArithmeticException System.out.println("This statement will not be executed"); } catch(Exception ex) { System.out.println("This block is executed immediately after an exception is thrown"); } finally { System.out.println("This block is always executed"); } } } 

try, catch and finally blocks form one unit. i.e You can’t keep other statements in between try, catch and finally blocks.

public class ExceptionHandling { public static void main(String[] args) { System.out.println("You can keep any number of statements here"); try { int i = 10/0; //This statement throws ArithmeticException System.out.println("This statement will not be executed"); } //You can't keep statements here catch(ArithmeticException ex) { System.out.println("This block is executed immediately after an exception is thrown"); } //You can't keep statements here finally { System.out.println("This block is always executed"); } System.out.println("You can keep any number of statements here");

} } 

You can display the description of an exception thrown using Exception object in the catch block.

public class ExceptionHandling { public static void main(String[] args) { try { String s = null; System.out.println(s.length()); //This statement throws NullPointerException System.out.println("This statement will not be executed"); } catch(Exception ex) { System.out.println(ex); //Output : java.lang.NullPointerException ex.printStackTrace(); //This prints stack trace of exception } finally { System.out.println("This block is always executed"); } } }

11) char: char keyword is used to declare primitive char type variables. char represents the characters in java. char a = 'A'; char b = 'B'; char c = 'C';

12) class: class keyword is used to define the classes in java. class MyClass { class MyInnerClass { //Inner Class } }

13) continue: continue keyword is used to stop the execution of current iteration and start the execution of next iteration in a loop. public class MainClass {

public static void main(String[] args) { for (int i = 0; i <= 100; i++) { if(i % 5 != 0) { continue; } System.out.println(i); } } }

14) default: default keyword is used to define the default methods in an interface (From Java 8). default keyword is also used in the switch-case statements. interface MyInterface { public default void myDefaultMethod() { System.out.println("Default Method"); } }

15) do: do keyword is used in a do–while loop. do-while loop is used to execute one or more statements repetitively until a condition returns false. public class MainClass { public static void main(String[] args) { int a = 10; int b = 20; do { a = a + b; b = b + 10; System.out.println("a = "+a); System.out.println("b = "+b); } while (a <= 100); } }

16) double: double keyword is used to declare primitive double type of variables. public class MainClass { public static void main(String[] args) { double d1 = 23.56; double d2 = 56.23; double d3 = d1 + d2; System.out.println(d3); }

}

17) if

18) else: if and else keywords are used in if-else block.

public class MainClass { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Enter a string :"); String input = sc.next(); if(input.equalsIgnoreCase("JAVA")) { System.out.println("It's JAVA"); } else { System.out.println("It's not JAVA"); } } }

19) enum: enum keyword is used to define enum types. enum MyEnums { A, B, C, D; }

20) extends: extends keyword is used in inheritance. It is used when a class extends another class. class SuperClass { //Super Class } class SubClass extends SuperClass { //Sub Class }

21) final: final keyword is used when a class or a method or a field doesn’t need further modifications. final class can’t be extended, final method can’t be overridden and the value of a final field can’t be changed. [See more] final class FinalClass { final int finalVariable = 10; final void finalMethod() { //final method } }

A final keyword in java can be used with a class, with a variable and with a method. final keyword restricts the further modification. When you use final keyword with an entity (class or variable or method), it gets the meaning that entity is complete and cannot be modified further. In this post, we will discuss some about 10 important points about final keyword which every java programmer should know. Let’s start with some simple basic things about final keyword in java.

final class in java : We can’t create a subclass to the class or we can’t extend a class or we can’t modify a class which is declared as final. final class FinalClass { //some statements } class SubClass extends FinalClass { //compile time error //Can't create sub class to the final class }

final method in java : We can’t override a method or we can’t modify a method in the sub class which is declared as final in the super class. class SuperClass { final void methodOne() { //some statements } } class SubClass extends SuperClass { @Override void methodOne() { //Compile time error //can not override final method } }

final variable in java : The value of a final variable can not be changed in the whole execution once it got initialized. class AnyClass { final int i = 10; void methodOne()

{ i = 20; //compile time error //final field can not be re-assigned } }

10 Points Every Java Programmer Should Know About final Keyword In Java: 1) Any class or any method can be either abstract or final but not both. abstract and final are totally opposite. Because, abstract class or abstract method must be implemented or modified in the sub classes but final does not allow this. This creates an ambiguity. //The following class gives compile time error final abstract class AnyClass { //Any class can not be final and abstract final abstract void methodOne(); //method can not be final and abstract at a time }

2) final method can be overloaded and that overloaded method can be overridden in the sub class. class SuperClass { final void methodOne() { //final method } void methodOne(int i) { //final method can be overloaded } } class SubClass extends SuperClass { @Override void methodOne(int i) { //Overloaded method can be overridden } }

3) final variable cannot be re-initialized but final variable can be used to initialize other variables. class AnyClassOne { final int i = 10; void methodOne() { i++; //above statement gives Compile time error. //value of final variable can not be changed

int j = i;//final variable can be used to initialize other variables. System.out.println(i); //final variable can be used } }

4) When an array reference variable is declared as final, only variable itself is final but not the array elements. public class UseOfFinalKeyword { public static void main(String[] args) { final int X[] = new int[10]; //final array variable X[2] = 10; X[2] = 20; //Array element can be re-assigned X = new int[30]; //compile time error //can't re-assign new array object to final array variable } }

5) When a reference variable is declared as final, you can’t re-assign a new object to it once it is referring to an object. But, you can change the state of an object to which final reference variable is referring. class A { int i = 10; } public class UseOfFinalKeyword { public static void main(String[] args) { final A a = new A(); //final reference variable a.i = 50; //you can change the state of an object to which final reference variable is pointing a = new A(); //compile time error //you can't re-assign a new object to final reference variable } }

6) Static variables, non-static variables and local variables all can be final. once the final variables are initialized, even you can’t re-assign the same value. class A { static final int i = 10; //final static variable final int j = 20; //final non-static variable void methodOne(final int k) { //k is final local variable k = 20; //compile time error } }

public class UseOfFinalKeyword { public static void main(String[] args) { A a = new (); a.i = 10; //Compile time error a.j = 20; //even you can't assign same value to final variables a.methodOne(20); } }

7) If the global variables are not initialized explicitly, they get default value at the time of object creation. But final global variables don’t get default value and they must be explicitly initialized at the time of object creation. Uninitialized final field is called Blank Final Field. class A { int i; //Non-final global variable, no need to initialize them final int j; //Blank Final Field A() { j=20; //final global variable must get a value at the time of object creation. } } public class UseOfFinalKeyword { public static void main(String[] args) { A a = new A(); } }

8) final non-static global variable must be initialized at the time of declaration or in all constructors or in any one of IIBs – Instance Initialization Blocks. class A { final int i; //Final non-static global variable may be initialized here OR //may be initialized in any one of IIB's, // because while object creation, all IIBs are called. OR { i = 30; } { //i = 40; } //must be initialized in all constructors. //because while object creation, only one constructor is called A() { //i=20; } A(int j) {

// i=j; } A(int j, int k) { // i = 50; } }

9) final static global variable must be initialized at the time of declaration or in any one of SIBs – Static Initialization Blocks. (final static global variable can’t be initialized in constructors) A { static final int i; //final static global variable may be initialized here OR //may be initialized in any one of SIBs. static { i = 30; } static { //i = 40; } //final static global variable can not be initialized in constructors A() { //i=20; } A(int j) { //i=j; } A(int j, int k) { //i = 50; } }

10) The global variable which is declared as final and static remains unchanged for the whole execution. Because, Static are stored in the class memory and they are loaded only once in the whole execution. They are common to all objects of the class. If you declare static variables as final, any of the objects can’t change their value as it is final. Therefore, variables declared as final and static are sometimes referred to as Constants. All fields of interfaces are referred as constants, because they are final and static by default.

22) float: float keyword indicates primitive float type of variables. public class MainClass { public static void main(String[] args) { float f1 = 45.26f; float f2 = 84.25f; float f3 = f2 - f1; System.out.println(f3); } }

23) for: for loop is used to execute the set of statements until a condition is true. public class MainClass { public static void main(String[] args) { for (int i = 0; i <= 10; i++) { System.out.println(i); } } }

24) implements: implements keyword is used while implementing an interface.

interface MyInterface { void myMethod(); } class MyClass implements MyInterface { public void myMethod() { System.out.println("My Method"); } }

25) import: import keyword is used to import the of a particular package into current java file. import java.sql.*; import java.util.Arrays; import java.util.Scanner;

Before discussing about static import in java, first let’s know what normal import does. Consider this java file. package pack1; public class A { //Member Of Pack1 }

If you want to use the member of pack1 (Class A) in another package, then you have to refer it through package name like below. package pack2; //Member Of pack2 public class B { public static void main(String[] args) { pack1.A a = new pack1.A(); //Accessing member of pack1 } }

It will be very annoying if pack1 member has to be used hundreds of times. Each time, member has to be referred through it’s package name. You can avoid this using import statement just after the package declaration statement. If you import the required package in the current file, then you can access the of that package without using package name just like below. package pack2; import pack1.*; //Importing all of pack1 //Member Of pack2 public class B { public static void main(String[] args) { A a = new A(); //Accessing member of pack1 without using package

name } }

Now come to static import in java. Using static import, you can access static of a class without referring them through their class name. For example, package pack1; public class A { public static int i; //Static Member public static void methodOne() { //Static Member } }

The above static of class A can be directly used in another package if you import them as static. package pack2; import static pack1.A.*;//Importing public class B { public static void main(String[] { System.out.println(i); //accessing static member of Class methodOne(); //accessing static member of Class } }

all static of Class A

args) A without using class name. A without using class name.

Notes :   

Using import statement, you can import only of a package like classes, interfaces etc into the current file. Using static import, you can import only static of a class like fields, methods etc into the current file. You can import only individual of a package or a class like import pack1.A; or import static pack1.A.i;

26) instanceOf: instanceOf is used to check whether an object is of specified type. The syntax for using instanceOf keyword is “Object_Reference instanceOf Type“. class A{ } public class MainClass { public static void main(String[] args) { A a = new A(); if(a instanceof A) { System.out.println("a is of type A"); }

} }

27) int: int keyword is used to declare primitive integer type of variables. public class MainClass { public static void main(String[] args) { int i1 = 10; int i2 = 20; int i3 = i1 * i2; System.out.println(i3); } }

28) interface: interface keyword is used to define the interfaces in java. interface MyInterface { void myMethod(); }

29) long: long is used to define the primitive long type variables. public class MainClass { public static void main(String[] args) { long l1 = 101; long l2 = 202; long l3 = l1 + l2; System.out.println(l3); } }

30) native: native keyword is used with a method to indicate that a particular method is implemented in native code using Java Native Interfaces(JNI). class AnyClass { public native void anyMethod(int i, double d); }

31) new: new keyword is used while creating the instances of a class. class A{ } public class MainClass { public static void main(String[] args) { A a = new A(); } }

32) package: package keyword is used to specify a package to which the current file belongs to. package pack1; class A{ }

33) private: private keyword is used to declare a member of a class as private. private methods and fields are visible within the class in which they are defined. class A { private int i = 111; private void method() { //private method } }

//private field

34) protected: protected keyword is used to declare a member of a class as protected. protected of a class are visible within the package only, but they can be inherited to any sub classes. class A { protected int i = 111; //protected field protected void method() { //protected method } }

35) public: public keyword is used to declare the of a class or class itself as public. public of a class are visible from anywhere and they can be inherited to any sub classes. public class A { public int i = 222; //public field public A() { //public constructor } public void method() { //public method } }

36) return: return keyword is used to return the control back to the caller from the method. class A { int method(int i) {

return i*i;

//method returning a value

} }

37) short: short keyword is used to declare primitive short type variables. short s1 = 11; short s2 = 22;

38) static: static keyword is used to define the class level of a class. static of a class are stored in the class memory and you can access them directly through class name. No need to instantiate a class. [See more class A { static int staticField = 555; //Static Field static void staticMethod() { //Static method } } public class MainClass { public static void main(String[] args) { System.out.println(A.staticField); //Accessing staticField via class name A.staticMethod(); //Accessing staticMethod via class name } }

Static variables, Static Initialization Block and Static Methods – these all are static components or static of a class. These static are stored inside the Class Memory. To access static , you need not to create objects. Directly you can access them with class name. Static Initialization Block is used to initialize only static variables. It is a block without a name. It contains set of statements enclosed within { }. The syntax of SIB looks like this, static { //Set Of Statements }

Consider the following program. class StaticComponents { static int staticVariable; static { System.out.println("StaticComponents SIB"); staticVariable = 10;

} static void staticMethod() { System.out.println("From StaticMethod"); System.out.println(staticVariable); } } public class MainClass { static { System.out.println("MainClass SIB"); } public static void main(String[] args) { //Static directly accessed with Class Name StaticComponents.staticVariable = 20; StaticComponents.staticMethod(); } }

Let us discuss execution of above program step by step. Step 1: When you trigger >java MainClass, java command divides allocated memory into two parts – Stack and Heap. First, java command enters stack memory for execution. First, it checks whether MainClass is loaded into heap memory or not. If it is not loaded, loading operation of MainClass starts. Randomly some memory space is allocated to MainClass. It is called Class memory. All static are loaded into this class memory. There is only one satic member in MainClass – main() method. It is loaded into class memory of MainClass. Step 2: After loading all static , SIB – Static initialization Blocks are executed. , SIBs are not stored in the heap memory. They just come to stack, execute their tasks and leaves the memory. So, after loading main() method, SIB of MainClass enters stack for execution. There is only one statement (Line 22) in SIB. it is executed. It prints “MainClass SIB” on console. After executing this statement, SIB leaves the stack memory. Step 3: Now, java command calls main() method for execution. main() method enters the stack. First statement (Line 28) is executed first. First, It checks whether class StaticComponents is loaded into memory. If it is not loaded, loading operation of StaticComponents takes place. Randomly, some memory is allocated to Class StaticComponents, then all static of StaticComponents – ‘staticVariable’ and ‘staticMethod()’ are loaded into that class memory. ‘staticVariable’ is a global variable. So, first it is initialized with default value i.e 0. Step 4: After loading all static of StaticComponents, SIB blocks are executed. So, SIB of class StaticComponents enters the stack for execution. First Statement (Line 7) is executed. It prints “StaticComponents SIB” on the console. In the second statement, value 10 is assigned to ‘staticVariable’. There are no other statements left for execution, so it leaves stack memory.

Step 5: Now control comes back to main() method. The remaining part of first statement i.e value 20 is assigned to ‘staticVariable’ of class StaticComponents, is executed. In the second statement (Line 29), it calls staticMethod() of class StaticComponents for execution. Step 6: staticMethod() of StaticComponents enters stack for execution. First statement (Line 13) is executed first. It prints “From staticMethod” on the console. In the second statement (Line 14), it prints the value of staticVariable i.e 20 on the console. There are no statements left. so, it leaves the stack. Step 7: Again, control comes back to main() method. There are no other statements left in main() method. so, it also leaves stack. java command also leaves the stack. Diagramatic representation of memory allocation of above program looks like this.

Output : Main Class SIB StaticComponents SIB From StaticMethod 20 39) strictfp: strictfp keyword is used to implement the strict precision of floating point calculations on different platforms. strictfp can be used with classes, interfaces and methods. strictfp interface I

{ //strictfp applied on interface } strictfp class C { //strictfp applied on class } class A { strictfp void method() { //strictfp applied on method } }

40) super: super keyword is used to access super class inside a sub class. class A { int i; public A(int i) { this.i = i; } void methodA() { System.out.println(i); } } class B extends A { public B() { super(10); //Calling super class constructor } void methodB() { System.out.println(super.i); //accessing super class field super.methodA();

//Calling super class method

} }

41) synchronized: synchronized keyword is used to implement the synchronization in java. only one thread can enter into a method or a block which is declared as synchronized. Any thread which wants to enter synchronized method or block must acquire object lock of those methods or blocks. [See more] class AnyClass { synchronized void synchronizedMethod() { //Synchronized method } void anyMethod()

{ synchronized (this) { //Synchronized block } } }

Synchronization in java is a strategy or a method to avoid thread interference and hence protecting the data from inconsistency. synchronization is also one of the way to make code thread safe. Through synchronization, we can make the threads to execute particular method or block in sync not simultaneously. Synchronization in java is implemented using synchronized keyword. synchronized keyword can be used with methods or blocks but not with the variables. When a method or block is declared as synchronized, only one thread can enter into that method or block. When one thread is executing synchronized method or block, the other threads which wants to execute that method or block wait or suspend their execution until first thread is done with that method or block. Thus avoiding the thread interference and achieving thread safeness. This can be explained well with the help of an example. class Shared { int i; synchronized void SharedMethod() { Thread t = Thread.currentThread(); for(i = 0; i <= 1000; i++) { System.out.println(t.getName()+" : "+i); } } } public class ThreadsInJava { public static void main(String[] args) { final Shared s1 = new Shared(); Thread t1 = new Thread("Thread - 1") { @Override public void run() { s1.SharedMethod(); } }; Thread t2 = new Thread("Thread - 2") { @Override public void run() { s1.SharedMethod(); } }; t1.start();

t2.start(); } }

In the above example, both threads t1 and t2 wants to execute sharedMethod() of s1 object. But, sharedMethod() is declared as synchronized. So, whichever thread enters first into sharedMethod(), it continues to execute that method. The other thread waits for first thread to finish it’s execution of sharedMethod(). It never enters into sharedMethod() until first thread is done with that method. That means, both threads are executing sharedMethod() one by one not simultaneously. This protects the value of “i” in the memory for a particular thread.

The Logic behind the Synchronization in Java: The synchronization in java is built around an entity called object lock or monitor. Here is the brief description about lock or monitor.     

Whenever an object is created to any class, an object lock is created and is stored inside the object. One object will have only one object lock associated with it. Any thread wants to enter into synchronized methods or blocks of any object, they must acquire object lock associated with that object and release the lock after they are done with the execution. The other threads which want to enter into synchronized methods of that object have to wait until the currently executing thread releases the object lock. To enter into static synchronized methods or blocks, threads have to acquire class lock associated with that class as static are stored inside the class memory.

Synchronized Blocks: Sometimes, you need only some part of the method to be synchronized not the whole method. This can be achieved with synchronized blocks. Synchronized blocks must be defined inside a definition blocks like methods, constructors, static initializer or instance initializer. synchronized block takes one argument and it is called mutex. if synchronized block is defined inside non-static definition blocks like non-static methods, instance initializer or constructors, then this mutex must be an instance of that class. If synchronized block is defined inside static definition blocks like static methods or static initializer, then this mutex must be like ClassName.class. Here is an example of static and non-static synchronized blocks. class Shared { static void staticMethod() { synchronized (Shared.class) { //static synchronized block } } void NonStaticMethod() {

synchronized (this) { //Non-static synchronized block } } void anotherNonStaticMethod() { synchronized (new Shared()) { //Non-static synchronized block } } }

10 Points-To- About Synchronization In Java: 1) You can use synchronized keyword only with methods but not with variables, constructors, static initializer and instance initializers. class Shared { synchronized int i;//compile time error, can't use synchronized keyword with variables synchronized public Shared() { //compile time error, constructors can not be synchronized } synchronized static { //Compile time error, Static initializer can not be synchronized } synchronized { //Compile time error, Instance initializer can not be synchronized } }

2) Constructors, Static initializer and instance initializer can’t be declared with synchronized keyword, but they can contain synchronized blocks. class Shared { public Shared() { synchronized (this) { //synchronized block inside a constructor } } static { synchronized (Shared.class) { //synchronized block inside a static initializer } } {

synchronized (this) { //synchronized block inside a instance initializer } } }

3) Both static and non-static methods can use synchronized keyword. For static methods, thread need class level lock and for non-static methods, thread need object level lock. class Shared { synchronized static void staticMethod() { //static synchronized method } synchronized void NonStaticMethod() { //Non-static Synchronized method } }

4) It is possible that both static synchronized and non-static synchronized methods can run simultaneously. Because, static methods need class level lock and non-static methods need object level lock. 5) A method can contain any number of synchronized blocks. This is like synchronizing multiple parts of a method. class Shared { static void staticMethod() { synchronized (Shared.class) { //static synchronized block - 1 } synchronized (Shared.class) { //static synchronized block - 2 } } void NonStaticMethod() { synchronized (this) { //Non-static Synchronized block - 1 } synchronized (this) { //Non-static Synchronized block - 2 } } }

6) Synchronization blocks can be nested.

synchronized (this) { synchronized (this) { //Nested synchronized blocks } }

7) Lock acquired by the thread before executing a synchronized method or block must be released after the completion of execution, no matter whether execution is completed normally or abnormally (due to exceptions). 8) Synchronization in java is Re-entrant in nature. A thread cannot acquire a lock that is owned by another thread. But, a thread can acquire a lock that it already owns. That means if a synchronized method gives a call to another synchronized method which needs same lock, then currently executing thread can directly enter into that method or block without acquiring the lock. 9) synchronized method or block is very slow. They decrease the performance of an application. So, special care need to be taken while using synchronization. Use synchronization only when you needed it the most. 10) Use synchronized blocks instead of synchronized methods. Because, synchronizing some part of a method improves the performance than synchronizing the whole method. 42) this: this keyword is used to access other of the same class. class AnyClass { int i; AnyClass() { System.out.println("First Constructor"); } AnyClass(int j) { this(); //calling statement to First Constructor System.out.println("Second Constructor"); } void methodOne() { System.out.println("From method one"); } void methodTwo() { System.out.println(this.i); //Accessing same class field this.methodOne(); //Accessing same class method } }

43) throw: throw keyword is used to throw the exceptions manually. public class MainClass {

public static void main(String[] args) { try { //throwing NumberFormatException manually throw new NumberFormatException(); } catch(Exception ex) { System.out.println(ex); } } }

Throwing An Exception : We all know that Throwable class is super class for all types of errors and exceptions. An object to this Throwable class or it’s sub classes can be created in two ways. First one is using an argument of catch block. In this way, Throwable object or object to it’s sub classes is implicitly created and thrown by java run time system. Second one is using new operator. In this way, Throwable object or object to it’s sub classes is explicitly created and thrown by the code. An object to Throwable or to it’s sub classes can be explicitly created and thrown by using throw keyword. The syntax for using throw keyword is, throw InstanceOfThrowableType. where, InstanceOfThrowableType must be an object of type Throwable or subclass of Throwable. Such explicitly thrown exception must be handled somewhere in the program, otherwise program will be terminated. For example, public class ExceptionHandling { public static void main(String[] args) { methodWithThrow(); } static void methodWithThrow() { try { NumberFormatException ex = new NumberFormatException(); //Creating an object to NumberFormatException explicitly throw ex; //throwing NumberFormatException object explicitly using throw keyword } catch(NumberFormatException ex) { System.out.println("explicitly thrown NumberFormatException object will be caught here"); } } }

It is not compulsory that explicitly thrown exception must be handled by immediately following try-catch block. It can be handled by any one of it’s enclosing try-catch blocks.

public class ExceptionHandling { public static void main(String[] args) { try { methodWithThrow(); } catch(NumberFormatException ex) { System.out.println("NumberFormatException object thrown in methodWithThrow() method will be handled here"); } } static void methodWithThrow() { try { NumberFormatException ex = new NumberFormatException("This is an object of NumberFormatException"); throw ex; //throwing NumberFormatException object explicitly using throw keyword } catch(ArithmeticException ex) { System.out.println("Explicitly thrown NumberFormatException object will not be caught here"); } } }

Re-throwing an Exception: We all know that exceptions occurred in the try block are caught in catch block. Thus caught exceptions can be re-thrown using throw keyword. Re-thrown exception must be handled somewhere in the program, otherwise program will terminate abruptly. For example, class ExceptionHandling { public static void main(String[] args) { try { methodWithThrow(); } catch(NullPointerException ex) { System.out.println("NullPointerException Re-thrown in methodWithThrow() method will be handled here"); } } static void methodWithThrow() { try { String s = null; System.out.println(s.length()); //This statement throws NullPointerException

} catch(NullPointerException ex) { System.out.println("NullPointerException is caught here"); throw ex;

//Re-throwing NullPointerException

} } }

44) throws: throws keyword is used to specify the exceptions which the current method may throw. class A { void method() throws NumberFormatException { int i = Integer.parseInt("abc"); } }

If a method is capable of throwing an exception that it could not handle, then it should specify that exception using throws keyword. It helps the callers of that method in handling that exception. The syntax for using throws keyword is, return_type method_name(parameter_list) throws exception_list { //some statements }

where, exception_list is the list of exceptions that method may throw. Exceptions must be separated by commas. public class ExceptionHandling { public static void main(String[] args) { try { methodWithThrows(); } catch(NullPointerException ex) { System.out.println("NullPointerException thrown by methodWithThrows() method will be caught here"); } } static void methodWithThrows() throws NullPointerException { String s = null; System.out.println(s.length()); //This statement throws NullPointerException } }

Let’s see some of the points-to- about throws keyword. Multiple exceptions can be declared using throws keyword separated by commas.

public class ExceptionHandling { static void methodWithThrows() throws NumberFormatException, NullPointerException { int i = Integer.parseInt("abc"); //This statement throws NumberFormatException String s = null; System.out.println(s.length()); //This statement throws NullPointerException } public static void main(String[] args) { try { methodWithThrows(); } catch(Exception ex) { System.out.println("This block can handle all types of exceptions"); } } }

The main use of throws keyword in java is that an exception can be propagated through method calls. public class ExceptionHandling { static void methodOne() throws NumberFormatException { int i = Integer.parseInt("abc"); //This statement throws NumberFormatException } static void methodTwo() throws NumberFormatException { methodOne(); //NumberFormatException is propagated here } static void methodThree() throws NumberFormatException { methodTwo(); //NumberFormatException is propagated here } public static void main(String[] args) { try { methodThree(); } catch(NumberFormatException ex) { System.out.println("NumberFormatException will be caught here"); } } }

Even constructor can use throws keyword. For this, object creation statement must be enclosed in try-catch blocks. A { int i; public A(String s) throws NumberFormatException { i = Integer.parseInt(s); //This statement throws NumberFormatException } } public class ExceptionHandling { public static void main(String[] args) { try { A a = new A("abc"); //Object creation statement enclosed in try-catch block } catch (NumberFormatException ex) { System.out.println("NumberFormatException will be caught here"); } } }

When a method is throwing unchecked type of exceptions, then you need not to mention it using throws keyword. But for a method throwing checked type of exceptions, you must declare it with throws keyword or enclose the statement which is throwing an exception in try-catch block. (We will discuss about this in detail while covering checked and unchecked exceptions). class ExceptionHandling { //method throwing Unchecked Exception declared without throws clause static void methodThrowingUncheckedException() { int i = Integer.parseInt("abc"); //Above statement throws NumberFormatException which is unchecked type of exception } //method throwing checked Exception declared with throws clause static void methodThrowingCheckedException() throws ClassNotFoundException { Class.forName("AnyClassName"); //Above statement throws ClassNotFoundException which is checked type of exception } public static void main(String[] args) { try { methodThrowingUncheckedException(); }

catch(NumberFormatException ex) { System.out.println("NumberFormatException will be caught here"); } try { methodThrowingCheckedException(); } catch (ClassNotFoundException e) { System.out.println("ClassNotFoundException will be caught here"); } } }

45) transient: transient keyword is used in serialization. A variable which is declared as transient will not be eligible for serialization. class MyClass implements Serializable { int a; transient String s; //This will not be serialized double d; }

46) void: void keyword is used to indicate that method returns nothing.? class A { void methodReturnsNothing() { //Method returns no value } }

47) volatile: volatile keyword is used in the concurrent programming. The value of a variable which is declared as volatile will be written into or read from the main memory. class A { public volatile int counter = 0; }

48) while: while keyword is used in the while loop. public class MainClass { public static void main(String[] args) { int i = 10; while (i <= 100) { System.out.println(i);

i = i + 10; } } }

49) goto 50) const Both goto and const are reserved words in java but they are currently not used. Note: true, false and null are not the keywords. They are literals in java. abstract: Abstract is used to implement the abstraction in java. A method which doesn’t have

method definition must be declared as abstract and the class containing it must be declared as abstract. You can’t instantiate abstract classes. Abstract methods must be implemented in the sub classes. You can’t use abstract keyword with variables and constructors. In an abstract class, you can keep abstract method(without body) and non-abstract method(with the body). By the help of abstract keyword, we can make any class as abstract. assert: (added in J2SE 1.4): Assert describes a predicate (a true–false statement) placed in a java-

program to indicate that the developer thinks that the predicate is always true at that place. If an assertion evaluates to false at run-time, an assertion failure results, which typically causes execution to abort. Optionally enable by ClassLoader method. boolean: Defines a boolean variable for the values "true" or "false" only. By default of the value of

boolean primitive type is false. break: Used to end the execution in the current loop body. byte: The byte keyword is used to declare a field that can hold an 8-bit signed two's complement

integer. This keyword is also used to declare that a method returns a value of the primitive type byte. case: A statement in the switch block can be labeled with one or more case or default labels.

The switch statement evaluates its expression, then executes all statements that follow the matching case label. catch: Used in conjunction with a try block and an optional finally block. The statements in the catch block specify what to do if a specific type of exception is thrown by the try block. char: Defines a character variable capable of holding any character of the java source file's

character set. class: A type that defines the implementation of a particular kind of object. A class definition

defines instance and class fields, methods, and inner classes as well as specifying the interfaces the class implements and the immediate superclass of the class. If the superclass is not explicitly specified, the superclass is implicitly Object. The class keyword can also be used in the form Class.class to get a Class object without needing an instance of that class. For example, String.class can be used instead of doing new String().getClass().

continue: Used to resume program execution at the end of the current loop body. If followed by a

label, continue resumes execution at the end of the enclosing labeled loop body. default: The default keyword can optionally be used in a switch statement to label a block of

statements to be executed if no case matches the specified value, Alternatively, the default keyword can also be used to declare default values in a Java annotation. From Java 8 onwards, the default keyword is also used to specify that a method in an interface provides the default implementation of a method. do: The do keyword is used in conjunction with while to create a do-while loop, which executes a

block of statements associated with the loop and then tests a boolean expression associated with the while. If the expression evaluates to true, the block is executed again; this continues until the expression evaluates to false. double: The double keyword is used to declare a variable that can hold a 64-bit double precision

IEEE 754 floating-point number. This keyword is also used to declare that a method returns a value of the primitive type double. else: The else keyword is used in conjunction with if to create an if-else statement, which tests a

boolean expression; if the expression evaluates to true, the block of statements associated with the if are evaluated; if it evaluates to false, the block of statements associated with the else are evaluated. enum (added in J2SE 5.0): A Java keyword used to declare an enumerated type. Enumerations

extend the base class Enum. extends: Used in a class declaration to specify the superclass; used in an interface declaration to

specify one or more superinterfaces. Class X extends class Y to add functionality, either by adding fields or methods to class Y, or by overriding methods of class Y. An interface Z extends one or more interfaces by adding methods. Class X is said to be a subclass of class Y; Interface Z is said to be a subinterface of the interfaces it extends. Also used to specify an upper bound on a type parameter in Generics. final: Define an entity once that cannot be changed nor derived from later. More specifically: a

final class cannot be subclassed, a final method cannot be overridden, and a final variable can occur at most once as a left-hand expression on an executed command. All methods in a final class are implicitly final. finally: Used to define a block of statements for a block defined previously by the try keyword.

The finally block is executed after execution exits the try block and any associated catch clauses regardless of whether an exception was thrown or caught, or execution left method in the middle of the try or catch blocks using the return keyword. float: The float keyword is used to declare a variable that can hold a 32-bit single precision IEEE

754 floating-point number. This keyword is also used to declare that a method returns a value of the primitive type float.

for: The for keyword is used to create a for loop, which specifies a variable initialization, a boolean

expression, and an incrementation. The variable initialization is performed first, and then the boolean expression is evaluated. If the expression evaluates to true, the block of statements associated with the loop are executed, and then the incrementation is performed. The boolean expression is then evaluated again; this continues until the expression evaluates to false. As of J2SE 5.0, the for keyword can also be used to create a so-called "enhanced for loop", which specifies an array or Iterable object; each iteration of the loop executes the associated block of statements using a different element in the array or Iterable. if: The if keyword is used to create an if statement, which tests a boolean expression; if the

expression evaluates to true, the block of statements associated with the if statement is executed. This keyword can also be used to create an if-else statement. Implements: Included in a class declaration to specify one or more interfaces that are

implemented by the current class. A class inherits the types and abstract methods declared by the interfaces. Import: Used at the beginning of a source file to specify classes or entire Java packages to be

referred to later without including their package names in the reference. Since J2SE 5.0, import statements can import static of a class. Instanceof: A binary operator that takes an object reference as its first operand and a class or

interface as its second operand and produces a boolean result. The instanceof operator evaluates to true if and only if the runtime type of the object is assignment compatible with the class or interface. int: The int keyword is used to declare a variable that can hold a 32-bit signed two's complement

integer. This keyword is also used to declare that a method returns a value of the primitive type int. interface: Used to declare a special type of class that only contains abstract or default methods,

constant (static final) fields and static interfaces. It can later be implemented by classes that declare the interface with the implements keyword. By the help of interface we can easily achieve multiple inheritance in java. We can define one interface within another interface. long: The long keyword is used to declare a variable that can hold a 64-bit signed two's

complement integer. This keyword is also used to declare that a method returns a value of the primitive type long. native: Used in method declarations to specify that the method is not implemented in the same

Java source file, but rather in another language. new: Used to create an instance of a class or array object. Using keyword for this end is not

completely necessary (as exemplified by Scala), though it serves two purposes: it enables the existence of different namespace for methods and class names, it defines statically and locally that a fresh object is indeed created, and of what runtime type it is (arguably introducing dependency into the code).

package: Java package is a group of similar classes and interfaces. Packages are declared with the package keyword. private: The private keyword is used in the declaration of a method, field, or inner class; private

can only be accessed by other of their own class. protected: The protected keyword is used in the declaration of a method, field, or inner class;

protected can only be accessed by of their own class, that class's subclasses or classes from the same package. public: The public keyword is used in the declaration of a class, method, or field; public classes,

methods, and fields can be accessed by the of any class. return: Used to finish the execution of a method. It can be followed by a value required by the

method definition that is returned to the caller. short: The short keyword is used to declare a field that can hold a 16-bit signed two's

complement integer. This keyword is also used to declare that a method returns a value of the primitive type short. static: Used to declare a field, method, or inner class as a class field. Classes maintain one copy of

class fields regardless of how many instances exist of that class. static also is used to define a method as a class method. Class methods are bound to the class instead of to a specific instance, and can only operate on class fields. (Classes and interfaces declared as static of another class or interface are actually top-level classes and are not inner classes.) strictfp (added in J2SE 1.2): A Java keyword used to restrict the precision and rounding of

floating point calculations to ensure portability. super: Inheritance basically used to achieve dynamic binding or run-time polymorphism in

java.Used to access of a class inherited by the class in which it appears. Allows a subclass to access overridden methods and hidden of its superclass. The super keyword is also used to forward a call from a constructor to a constructor in the superclass. Also used to specify a lower bound on a type parameter in Generics. switch: The switch keyword is used in conjunction with case and default to create a switch

statement, which evaluates a variable, matches its value to a specific case, and executes the block of statements associated with that case. If no case matches the value, the optional block labelled by default is executed, if included. synchronized: Used in the declaration of a method or code block to acquire the mutex lock for an

object while the current thread executes the code. For static methods, the object locked is the class's Class. Guarantees that at most one thread at a time operating on the same object executes that code. The mutex lock is automatically released when execution exits the synchronized code. Fields, classes and interfaces cannot be declared as synchronized. this: Used to represent an instance of the class in which it appears. this can be used to access

class and as a reference to the current instance. The this keyword is also used to forward a call from one constructor in a class to another constructor in the same class.

throw: Causes the declared exception instance to be thrown. This causes execution to continue with

the first enclosing exception handler declared by the catch keyword to handle an assignment compatible exception type. If no such exception handler is found in the current method, then the method returns and the process is repeated in the calling method. If no exception handler is found in any method call on the stack, then the exception is ed to the thread's uncaught exception handler. throws: Used in method declarations to specify which exceptions are not handled within the

method but rather ed to the next higher level of the program. All uncaught exceptions in a method that are not instances of RuntimeException must be declared using the throws keyword. transient: Declares that an instance field is not part of the default serialized form of an object.

When an object is serialized, only the values of its non-transient instance fields are included in the default serial representation. When an object is deserialized, transient fields are initialized only to their default value. If the default form is not used, e.g. when a serialPersistentFields table is declared in the class hierarchy, all transient keywords are ignored. try: Defines a block of statements that have exception handling. If an exception is thrown inside the try block, an optional catch block can handle declared exception types. Also, an optional finally

block can be declared that will be executed when execution exits the try block and catch clauses, regardless of whether an exception is thrown or not. A try block must have at least one catch clause or a finally block. void: The void keyword is used to declare that a method does not return any value. volatile: Used in field declarations to specify that the variable is modified asynchronously by

concurrently running threads. Methods, classes and interfaces thus cannot be declared volatile, nor can local variables or parameters. while: The while keyword is used to create a while loop, which tests a boolean expression and

executes the block of statements associated with the loop if the expression evaluates to true; this continues until the expression evaluates to false. This keyword can also be used to create a dowhile loop.

Reserved words for literal values true: A boolean literal value. null: A reference literal value. false: A boolean literal value.

Unuseds const: Although reserved as a keyword in Java, const is not used and has no function. For

defining constants in Java, see the final keyword. goto: Although reserved as a keyword in Java, goto is not used and has no function.