In this chapter, we’ll learn how Java stores and manages data using variables, data types, and how we can manipulate that data using operators. This chapter forms the backbone of every Java program.

Tokens are the smallest individual units in a Java program. There are five types:
1. Keywords – Reserved words with special meaning (e.g., int, class, return)
2. Identifiers – Names for variables, classes, methods, etc.
3. Literals – Constant values directly used in code (e.g., 5, 'A', 3.14)
4. Operators – Symbols that perform operations (+, -, *)
5. Separators – Characters like {}, ;, ,, []

A variable is a container used to store data. It must be declared with a type before use.

📌 Syntax:
dataType variableName = value;
✅ Example:
int age = 20;
String name = "Aman";

🔒 Rules for Naming Variables:
● Can include letters, digits, underscores, and dollar signs.
● Must begin with a letter or underscore.
● Cannot use Java keywords like class, int, etc.
● Java is case-sensitive (Age and age are different).

Java has two categories of data types:
🔹 A. Primitive Data Types
Data Type Size Example Description
byte 1 byte byte b = 10; Small integer values
short 2 bytes short s = 100; Medium range integer values
int 4 bytes int i = 200; Default for integers
long 8 bytes long l = 10000; Large integer values
float 4 bytes float f = 5.5f; Decimal with single precision
double 8 bytes double d = 6.89; High precision decimal
char 2 bytes char c = 'A'; Single character
boolean 1 bit boolean b = true; True or false only
💡 Always add f to float values: float f = 4.3f;
🔹 B. Non-Primitive Data Types
● Strings, Arrays, Classes, Interfaces, etc.
● Created by the programmer, unlike primitive types.
Example:
String name = "Anjali";
int[] numbers = {1, 2, 3};

👉 Implicit (Widening) Casting:
● Small data type → Big data type
● Happens automatically.
int a = 10;
double d = a; // Automatically converts int to double

👉 Explicit (Narrowing) Casting:
● Big data type → Small data type
● Must be done manually.
double d = 9.7;
int i = (int) d; // Converts double to int (loses decimal part)

Use the final keyword to create constants (values that don’t change).
final double PI = 3.14159;
Trying to change PI later in the program will give an error.

Operators are used to perform operations on variables and values. Java provides several categories:
🔹 A. Arithmetic Operators
Operator Use Example
+ Addition a + b
- Subtraction a - b
* Multiplication a * b
/ Division a / b
% Modulus a % b (remainder)
int a = 10, b = 3;
System.out.println(a + b); // 13
System.out.println(a / b); // 3
System.out.println(a % b); // 1
🔹 B. Relational (Comparison) Operators
Operator Meaning Example
== Equal to a == b
!= Not equal to a != b

      Greater than      a > b

< Less than a < b
= Greater than or a >= b
equal
<= Less than or a <= b
equal
int x = 5, y = 10;
System.out.println(x > y); // false
🔹 C. Logical Operators
Used to combine multiple conditions.
Operator Meaning Example
&& Logical AND a > 0 && b > 0
! Logical NOT !(a > 0)

Sometimes multiple operators are used in a single expression. Java follows a precedence rule.
For example:
int a = 10 + 5 * 2; // Multiplication happens first
System.out.println(a); // 20
To control order, use parentheses:
int a = (10 + 5) * 2; // 30