Java Tokens

Java tokens

When we learn a language like English, we learn the parts of speech. These parts of speech are:- nouns, pronouns, adjectives, verbs, etc. Just like that, we have Java tokens for Java Programming Language. Java tokens serve as the essential building blocks that compose a Java program. Java tokens are categorized into five types:-

Keywords
Identifiers
Literals
Operators
Separators

Developers may use these tokens to generate Java programmes’ fundamental words and sentences. We will explore each type of Java token in this blog article. With real life examples let’s understand their significance & usage.

Keywords in Java

The Keywords are like special words in Java that have specific meanings to the compiler. They are reserved and cannot be used as names for anything (variables, methods, or classes). They are like “reserved words” in a language.

For example:- Let’s take the keyword “public”. It tells the compiler that we can access a class / method from anywhere in the code. It’s like the chef saying, “This recipe is public! Anyone can use it & share it with others”. It’s a way of controlling the visibility and accessibility of certain parts of the code.

So, you use keywords in a Java program to define the structure & behavior of your code. Just like following a recipe with special words and giving unique names to ingredients and steps, using keywords in Java helps the computer understand and execute your code correctly.

Here are some examples of keywords

Keyword	Description
abstract	a class cannot be instantiated.
assert	insert assertions into a program.
boolean	a variable can only hold the value true or false.
break	exit a loop or switch statement.
byte	a variable can only hold a whole number between -128 and 127.
case	label a block of code in a switch statement.
catch	handle exceptions.
char	a variable can only hold a single character.
class	a new class is being defined.
const	Not currently used.
continue	skip the rest of the current iteration of a loop.
default	specify a default case in a switch statement.
do	create a do-while loop.
double	a variable can hold a floating-point number with 64 bits of precision.
else	specify an alternative block of code to execute if a condition is not met.
enum	a new enumeration is being defined.
extends	specify that a class is derived from another class.
final	a variable cannot be changed after it is initialized.
finally	execute code regardless of whether an exception is thrown.
float	a variable can hold a floating-point number with 32 bits of precision.
for	create a for loop.
goto	Not currently used.
if	create an if statement.
implements	specify that a class implements an interface.
import	import a class or package into a program.
instanceof	test if the object is an instance of a class.
int	whole number between -2147483648 and 2147483647.
interface	a new interface is being defined.
long	whole number between -9223372036854775808 and 9223372036854775807.
native	Not currently used.
new	create a new object.
package	declare the package that a class belongs to.
private	a variable or method can only be accessed by code within the class in which it is defined.
protected	can only be accessed by the code in the class
public	variable or method can be accessed anywhere code.
return	exit a function and return a value.
short	a variable can hold a whole number between -32768 and 32767.
static	a variable or method is associated with the class rather than an instance of the class.
strictfp	floating-point operations should be performed with strict precision.
switch	create a switch statement.
synchronized	control access to a shared resource.
this	Refers to a current object
throw	throw an exception.
throws	specifies that a method can throw an exception.
transient	a variable should not be serialized when an object is serialized.
try	create a try-catch block.
void	a method does not return a value.
volatile	a variable may be changed by another thread.
while	create a while loop.

Here are some examples of how keywords can be used in a Java program:

The code above defines a class called “MyClass”. The class has two methods, “myMethod()” and “myOtherMethod()”.

The “myMethod()” method is “static”, which means it can be accessed without creating an instance of the class. The “myOtherMethod()” method is not static, which means it must be accessed by creating an instance of the class.

The code also declares a variable called “myVariable”. The variable is of type “int”, which means it can store an integer value. The code then prints the value of “myVariable” to the standard output stream.

Identifiers in Java

In a Java program, an identifier is like a name we give to something. It could be a variable, method, class, or package. Identifiers help us refer to specific things in our code.

Imagine you’re organizing a collection of books. Each book needs a unique identifier, like a title or a code. That makes it easy to find them. In Java, identifiers do the same job—they give unique names to different parts of your program.

Imagine you’re writing a Java program to calculate the area of a rectangle. In this program, we’ll use identifiers to name the variables and methods.

In this code, we have several identifiers. Let’s break them down:-

`length` and `width` are identifiers for variables. They are meaningful names that describe what they represent.
`area` is an identifier for a variable that will store the calculated area of the rectangle. It represents the result of the calculation.
`calculateArea` is an identifier for a method that calculates the area of the rectangle using those values. It returns the calculated area.

By using these identifiers, the code becomes more readable. When someone reads the code, they can easily understand the purpose of each variable and method based on their descriptive names.

Literals

In Java, a literal is a constant value that appears directly in the source code. Literals can be used to represent numbers, strings, characters & boolean values.

Here are some examples of literals:

Integer literals: Integer literals represent whole numbers. We can write them as..
- Decimal: 123
- Octal: 0123
- Hexadecimal: 0x123
Floating-point literals: Floating-point literals represent numbers with decimal points. They can be written in decimal or scientific notation.
- Decimal: 123.45
- Scientific notation: 1.2345e+02
String literals: String literals represent sequences of characters. They are enclosed in double quotes.
- “Hello, world!”
Character literals: Character literals represent a single character. They are enclosed in single quotes.
- ‘a’
Boolean literals: Boolean literals represent the values true and false. They are written as true and false, respectively.
- true
- false

Literals can be used to initialize variables, to pass arguments to methods, and to perform calculations.

Here are some examples of how literals can be used:

Table of literals in Java:

Literal type	Description	Examples
Integer literal	Represents a whole number.	123, 0123, 0x123
Floating-point literal	Represents a number with a decimal point.	123.45, 1.2345e+02
String literal	Represents a sequence of characters.	“Hello, world!”
Character literal	Represents a single character.	‘a’
Boolean literal	Represents the values true and false.	true, false

Operators

The Operators are a feature in Java. Operators are symbols or keywords that perform specific operations on operands (values, variables, or expressions). They are used to manipulate and operate on data.

Look at the following table.

Table of operators in Java

Operator	Description	Syntax	Example
Arithmetic	Perform mathematical calculations	+, -, *, /, %	int result = 10 + 5;
Assignment	Assign a value to a variable	= += -= *= /= %=	x = 10; x += 5;
Comparison	Compare two values for equality or order	== != < > <= >=	if (x > y)
Logical	Perform logical operations	&& `
Bitwise	Perform operations at the bit level	& `	^ ~ << >> >>>`
Conditional	Execute different actions based on a condition	? :	int max = (x > y) ? x : y;
Increment/Decrement	Increase or decrease a value by 1	++ —	i++; j–;
Ternary	Short form of conditional statements	condition ? value1 : value2	int max = (x > y) ? x : y;
instanceof	Checks if an object belongs to a class	instanceof	if (obj instanceof MyClass)
Type casting	Convert a value from one type to another	(type) value	int x = (int) 3.14;

These are some of the commonly used operators in Java. Each operator has a specific purpose. We can use them to perform different operations on operands. By understanding and utilizing these operators effectively, you can manipulate data and perform calculations in your Java programs.

Separators:

In Java, separators are characters used to separate elements within the code. They help the compiler understand the structure and syntax of the program. Here are some commonly used separators in Java:-

Semicolon (;)

The semicolon is used to separate statements in Java. It indicates the end of a statement. Because of this, we can write multiple statements on one line.

Example:

Comma (,)

The comma is used to separate items in a list, such as arguments in a method call or elements in an array.

Example:

Dot (.) and Arrow (-)

These separators are used to access members of a class or object. The “dot (.)” operator is used for accessing fields, methods, and nested classes. The “arrow (->)” operator is used for accessing members of objects in lambda expressions.

Example:

Parentheses ( )

Parentheses are used for grouping expressions, passing arguments to methods, and defining method signatures.

Example:

These separators are essential for writing correct and readable Java code. Understanding their usage and proper placement is crucial for the compilation and execution of your programs.

Table of separators in Java

Separator	Description	Example
Semicolon (;)	Terminates statements.	int x = 10;
Comma (,)	Separates multiple values in a list.	int[] numbers = {10, 20, 30};
Dot (.)	Accesses the properties or methods of an object.	String str = “Hello, world!”; int length = str.length();
Colon (:)	Defines a block of code.	public void myFunction() { // body of the function }

How Java Tokens work

As we have seen earlier, Java tokens are the fundamental units of a Java program. They are the smallest elements that make up the source code. When you write a Java program, the compiler breaks it down in tokens. Then it analyzes and processes the program.

Here’s how Java tokens work:

Tokenization

The process starts with tokenization, where the compiler divides the source code into individual tokens. It scans the code character by character and identifies different types of tokens.

Types of Tokens

There are five main types of Java tokens:

Keywords: Reserved words in Java with predefined meanings. Examples: public, class, static.
Identifiers: Names used for variables, methods, classes, etc. Examples: myVariable, myMethod.
Literals: Constant values used in the code. Examples: 42 (integer literal), 3.14 (floating-point literal), “Hello” (string literal).
Operators: perform specific operations. Examples: +, -, *, /.
Separators: used to separate tokens. Examples: (, ), {, ;.

Syntax Analysis

After tokenization, the compiler performs a syntax analysis, also known as parsing. It examines the arrangement and structure of the tokens to ensure they follow the rules of the Java language.

Semantic Analysis

The compiler then performs semantic analysis, where it checks if the tokens and their combinations are meaningful and confirms the rules of Java. It verifies variable types, method signatures, and other semantic aspects.

Intermediate Representation

The compiler generates an intermediate representation, such as an Abstract Syntax Tree (AST), which represents the structure and relationships between the tokens in a more organized manner.

Code Generation

Finally, the compiler translates the processed tokens into executable machine code or “bytecode”. Then the JVM (Java Virtual Machine) can execute this bytecode.

By breaking down the source code into tokens and analyzing their structure and meaning, the compiler can understand the code and perform various checks and transformations to produce a runnable program.

Conclusion

In conclusion, Java tokens are like the LEGO pieces of a Java program. They come in different types like keywords, identifiers, literals, operators, and separators.

When we write code, the compiler examines these tokens to understand our instructions. It’s like a puzzle where the compiler puts the pieces together to make sense of our program.

By using the right tokens in the right way, we can create working and understandable Java programs.

Technogeeks is an excellent learning platform for Learning Core and Advanced Java. Enroll to kickstart your journey as a Java developer.

Checkout our courses on the Java programing below

👉https://technogeekscs.com/courses/core-java-training 👈

👉 https://technogeekscs.com/courses/advance-java-course 👈