Important Java Keywords List – Reserved Words In Java

In this tutorial, we will Explore the Java Keywords List and learn about some Important Reserved Words, their Meaning along with Examples:

Keywords in Java are the reserved words that act as a key to the code. As these words are predefined, they cannot be used for any other purpose like variable name or object name or any other identifier. Java has around 51 reserved words or keywords.

In this tutorial, we will discuss the list of keywords in Java. Then we will take up some of the important keywords in Java and see their meaning along with the programming examples.

=> Check Here To See A-Z Of Java Training Tutorials.

Java Keyword List

Given below is a list of all the keywords in Java. In this list, we have also included the keywords that are no longer used in Java.

We will discuss the below keywords in a separate tutorial as they have a great significance as far as Java programming is concerned.

These words are:

#1) “this” keyword

The keyword “this” points to the current object in the program.

Also Read => Java ‘THIS’ Keyword With Code Examples

#2) “static” keyword

A static keyword is a keyword that is used to indicate an object that cannot be instantiated. So if we have a static method, then it need not be called using an object. It can be called just using a class name.

Similarly, if we have a static variable, then its value is preserved throughout the program.

#3) “super” keyword

The “super” keyword in Java is used to refer to the objects of the immediate parent class. The parent class is also referred to as “Superclass”. We will explore the details of the super keyword while discussing inheritance in our OOPS tutorial series.

#4) “final” keyword

The keyword “final” is used with variables, methods, or classes. A final variable is a constant variable. A final method is a method that cannot be overridden. A final class is a class that cannot be inherited or extended. We will discuss the final one in detail in our OOPS tutorial series.

Now let’s implement a program wherein we will use these important keywords in Java.

import java.util.*;

class MyClass {
    int i;
  
    MyClass()  {
        System.out.println("MyClass:: Default Constructor");
    }
  
    MyClass(int j) {
        this();    //calling statement to First Constructor
        System.out.println("MyClass:: Parameterized Constructor");
    }
    //static method
    static void methodOne()  {
        System.out.println("MyClass:: static methodOne");
    }
    //final method  
    final void methodTwo()  {
        System.out.println("MyClass:: Final methodTwo");
        System.out.println("MyClass::Calling methodOne from methodTwo");  //Accessing same class field
        this.methodOne();      //Accessing same class method
    }
    //regular method
    void methodThree()   {
        System.out.println("MyClass::MethodThree");  //Accessing same class field
        System.out.println("MyClass::Calling methodTwo from methodThree");
        this.methodTwo();      //Accessing same class method
    }
}
class MyDerivedClass extends MyClass{
    void methodThree(){
        System.out.println("MyDerivedClass::methodThree");
        System.out.println("MyDerivedClass::Calling methodThree from MyClass");
        super.methodThree();    //calling regular method    
        super.methodTwo();      //calling final method
        super.methodOne();      //calling static method
    }
    //void methodOne(){}    //overriding final method gives compiler error
    //void methodTwo(){}    //overriding final method gives compiler error
    
}
public class Main{
    public static void main(String[] args){
        MyClass.methodOne();		//call static method from MyClass
        MyDerivedClass d1 = new MyDerivedClass ();
        d1.methodOne();		//call static method from MyDerivedClass
        d1.methodTwo();		//call final method from MyDerivedClass
        d1.methodThree();
   }    
}

As shown in the above program, the first keyword we have used is import followed by many other keywords like class, int, etc. The main keywords in this program are this, static, final, and super.

We have used this keyword in the second constructor to call the first constructor. The parent class MyClass has a static method and a final method declared in it.

In the derived class – MyDerivedClass, we override a regular method methodThree. Note that we also try to override methodOne and methodTwo but the compiler gives an error as they are static and final methods respectively. Note the commented code.

In the main class, we first call the static class using MyClass and then create a derived class object. Note that no error is given even while calling static and final methods using the derived class objects.

Output

Note the colored output. This entire output is the result of calling methods using the derived class objects.

Frequently Asked Questions

Q #1) What is the use of Keywords in Java?

Answer: Keywords are also called as Reserved words. These are the words that the programming language uses for internal processing and pre-defined actions.

Thus programming language doesn’t allow these keywords to be used by the programmer as identifiers or variable names etc. Despite that, if we use these keywords it will result in a compiler error.

Q #2) How many Keywords are present in Java?

Answer: Java has a total of 51 keywords that have predefined meaning and are reserved for use by Java. Out of these 51 keywords, 49 keywords are currently used while the remaining 2 are no more used.

Q #3) What is the difference between integer and int?

Answer: Both int and Integer store integer values. But ‘int’ is a keyword that is a primitive data type int. An integer is a class type. Integer converts int into an object and vice versa.

Q #4) Is null a keyword in Java?

Answer: No. Null is not a keyword in Java but it is literal. Yet, we cannot use it for declaring identifiers.

Q #5) Is new a keyword in Java?

Answer: Yes, new is a keyword in Java. The new keyword is used to create a new object and allocate memory to this new object on the heap. Apart from the class objects, we also use the new keyword to create array variables and allocate memory.

Conclusion

In this tutorial, we have discussed various keywords used in Java. Java supports a total of 51 keywords out of which 49 keywords are currently used and 2 are not currently used. Of these keywords, four keywords i.e. this, static, super, and final are important keywords that need special attention.

‘This’ keyword points to the current object. The static keyword is used to indicate the instantiation that is not needed. The super keyword is used to refer to the parent class and the final keyword is used to indicate the constant or non-inheritance.

=> Visit Here To See The Java Training Series For All.