Open In App

Java Tokens

Last Updated : 12 Mar, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

In Java, Tokens are the smallest elements of a program that is meaningful to the compiler. They are also known as the fundamental building blocks of the program. Tokens can be classified as follows:

  1. Keywords
  2. Identifiers
  3. Constants
  4. Special Symbols
  5. Operators
  6. Comments
  7. Separators

1. Keyword

Keywords are pre-defined or reserved words in a programming language. Each keyword is meant to perform a specific function in a program. Since keywords are referred names for a compiler, they can’t be used as variable names because by doing so, we are trying to assign a new meaning to the keyword which is not allowed. Java language supports the following keywords:


abstract assert boolean
break byte case
catch char class
const continue default
do double else
enum exports extends
final finally float
for goto if
implements import instanceof
int interface long
module native new
open opens package
private protected provides
public requires return
short static strictfp
super switch synchronized
this throw throws
to transient transitive
try uses void
volatile while with

2. Identifiers

Identifiers are used as the general terminology for naming of variables, functions and arrays. These are user-defined names consisting of an arbitrarily long sequence of letters and digits with either a letter or the underscore (_) as a first character. Identifier names must differ in spelling and case from any keywords. You cannot use keywords as identifiers; they are reserved for special use. Once declared, you can use the identifier in later program statements to refer to the associated value. A special kind of identifier, called a statement label, can be used in goto statements. Examples of valid identifiers:

MyVariable
MYVARIABLE
myvariable
x
i
x1
i1
_myvariable
$myvariable
sum_of_array
geeks123

Examples of invalid identifiers:

My Variable  // contains a space
123geeks // Begins with a digit
a+c // plus sign is not an alphanumeric character
variable-2 // hyphen is not an alphanumeric character
sum_&_difference // ampersand is not an alphanumeric character

3. Constants/Literals

Constants are also like normal variables. But the only difference is, their values cannot be modified by the program once they are defined. Constants refer to fixed values. They are also called as literals. Constants may belong to any of the data type. Syntax:

final data_type variable_name;
Java
import java.io.*;

class GFG {
    public static void main (String[] args) {
        final int PI = 3.14; //Here final keyword is used to define the constant PI
    }
}

4. Special Symbols: 

The following special symbols are used in Java having some special meaning and thus, cannot be used for some other purpose.

[] () {}, ; * =
  • Brackets[]: Opening and closing brackets are used as array element reference. These indicate single and multidimensional subscripts.
  • Parentheses(): These special symbols are used to indicate function calls and function parameters.
  • Braces{}: These opening and ending curly braces marks the start and end of a block of code containing more than one executable statement.
  • comma (, ): It is used to separate more than one statements like for separating parameters in function calls.
  • semi colon : It is an operator that essentially invokes something called an initialization list.
  • asterick (*): It is used to create pointer variable.
  • assignment operator: It is used to assign values.

5. Operators

Java provides many types of operators which can be used according to the need. They are classified based on the functionality they provide. Some of the types are-

6. Comments:

In Java, Comments are the part of the program which are ignored by the compiler while compiling the Program. They are useful as they can be used to describe the operation or methods in the program. The Comments are classified as follows:

  • Single Line Comments
  • Multiline Comments
// This is a Single Line Comment
/*
This is a Multiline Comment
*/
Java
import java.io.*;

class GFG {
    public static void main (String[] args) {
      
          // This is a Single line Comment
      
          /*
             This is a Multiline Comment
          */
      
    }
}

7. Separators:

Separators are used to separate different parts of the codes. It tells the compiler about completion of a statement in the program. The most commonly and frequently used separator in java is semicolon (;).

int variable;   //here the semicolon (;) ends the declaration of the variable
Java
import java.io.*;

class GFG {
    public static void main (String[] args) {
        System.out.println("GFG!");  //Here the semicolon (;) used to end the print statement
    }
}

To know more about Java Tokens, watch this video:




Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads