Data Types, Keywords and Variables:

Variables are memory locations to store values. When a user creates a variable, a memory space is reserved for that the variable. Based on the type of the variable, the operating system allocatesmemory and decides what can be stored in that reserved space. A user can store integers, decimals, character, etc. by assigning different data types to the variables. Data type is a keyword used to allocate sufficient memory space for the data. Pictorial representation of data types and its classifications are given below:

1. Primitive Data Types

These are the basic, built-in data types in Java. They are not objects and directly store values. There are 8 primitive data types, and these are Byte, Short, int, Long, Float, Double, Char, and boolean:

Integers: 

In Java, an integer is a data type used to store whole numbers (numbers without decimal points). It can be positive, negative, or zero. Integers are mainly represented by the primitive data types byte, short, int, and long, depending on the size of the number. Among these, int is the most commonly used data type for integers.

• byte → small integers (–128 to 127)
• short → medium integers (–32,768 to 32,767)
• int → standard integers (–2,147,483,648 to 2,147,483,647)
• long → very large integers (–9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)

 Byte
The smallest integer type is byte. This is a signed 8-bit type that has a range from -128 to 127. Variables of type byte are especially useful when you’re working with a stream of data from a network or file. It can be represented as: Byte b, c;

 Short
Short is a signed 16-bit type. It has a range from –32,768 to 32,767. It is probably the least-used
Java type. Here are some examples of short variable declarations:
short s;
short t;

 Int
The most commonly used integer type is int. It is a signed 32-bit type that has a range from –2,147,483,648 to 2,147,483,647.22 In addition to other uses, variables of type int are commonly employed to control loops and to index arrays.

Long
Long is a signed 64-bit type and is useful for those occasions where an int type is not large enough to hold the desired value. The range of a long is quite large. This makes it useful when big, whole numbers are needed

Float Types :

Float is specified as a single-precision value that uses 32 bits of storage. Single precision is faster and takes half as much space as double precision, but it will become imprecise when the values are either very large or very small.Here are some example float variable declarations:

float hightemp, lowtemp;

Double
Double is denoted by the keyword ‘double’, which is used to store a value of 64 bits. It is faster than single precision on modern processors that have been optimised for high-speed mathematical calculations. Some importance of double are All transcendental math functions, such as :

• sin( )
•  cos( )
•  sqrt( )

Characters
Char in Java is not the same as char in C or C++. Java uses Unicode to represent characters. Unicode defines a fully international character set that can represent all of the characters found in all human languages. It is a unification of dozens of character sets, such as

• Latin
• Greek
• Arabic
• Cyrillic
• Hebrew

In Java, char is 16 bit and ranges from 0 to 65,536. There are no negative chars. The standard set of characters known as ASCII still ranges from 0 to 127 as always and the extended 8-bit character set, ISO-Latin-1, ranges from 0 to 255.

Here is a program that demonstrates char variables:
class CharDemo
{
public static void main(String args[])
{
char ch1, ch2;
ch1 = 88; // code for X
ch2 = 'Y';
System.out.println("ch1 and ch2: ");
System.out.println(ch1 + " " + ch2);
}
}

Boolean: In Java, a boolean is a primitive data type that can store only two possible values: true or false

Table summary

2. Non-Primitive (Reference) Data Types

These are derived from classes and store references (addresses) to objects, not the actual value. Examples include:

• String → Stores sequences of characters.
• Arrays → Stores multiple values of the same type.
• Classes, Objects, Interfaces → User-defined data types.

Example:

public class DataTypesExample {
public static void main(String[] args) {
// Primitive data types
int age = 25;
double price = 99.99;
char grade = 'A';
boolean isJavaFun = true;// Non-primitive data type
String name = "Basant";
System.out.println("Age: " + age);
System.out.println("Price: " + price);
System.out.println("Grade: " + grade);
System.out.println("Is Java Fun? " + isJavaFun);
System.out.println("Name: " + name);
}
}
out put: 
Age: 25
Price: 99.99
Grade: A
Is Java Fun? true
Name: Basant

Identifiers in Java:

An identifier is the name given to a variable, class, method, or object in a Java program. It is used to identify (recognize) different elements in the code. For example, when you create a variable or method, the name you assign to it is called an identifier.

Rules for Identifiers

1. Identifiers can contain letters (A–Z, a–z), digits (0–9), underscore (_), and dollar sign ($).
2. The first character cannot be a digit (e.g., 123abc is invalid.
3. Identifiers are case-sensitive (Name and name are different.
4. Java keywords cannot be used as identifiers (e.g., class, int, while).
5. Identifiers should not contain spaces (e.g., my variable is invalid.

Examples

Valid Identifiers
age
studentName
_rollNo
$salary
Invalid Valid Identifiers
123age //cannot start with a digit
student name //cannot contain space
int //cannot use keyword

Variable in Java:

A variable in Java is a named memory location that stores data. It acts like a container where we can keep values, and the value can change (vary) during program execution. For example:
int age = 20;

Here, age is a variable of type int that stores the value 20.

Types of Variables in Java: 

Local Variable: Declared inside a method, constructor, or block. It is created when the method is called and destroyed after it finishes.Example

void show() {
int number = 10; // local variable
System.out.println(number);
}

2. Instance Variable – Declared inside a class but outside any method. Each object of the class has its own copy.Example

class Student {
String name; // instance variable
}

3. Static Variable – Declared with the keyword Static. It belongs to the class, not to individual objects, and all objects share the same value.Example

class Student {
static String school = "ABC School"; // static variable
}

Example:

public class VariableExample {
int rollNo = 101; // instance variable
static String college = "XYZ College"; // static variable

void display() {
String name = "Basant"; // local variable
System.out.println(rollNo + " - " + name + " - " + college);
}
public static void main(String[] args) {
VariableExample obj = new VariableExample();
obj.display();
}
}

Constant in Java:

A constant in Java is a value that does not change during the execution of the program. Unlike variables, once a constant is assigned a value, it cannot be modified. Constants make programs more reliable and easier to understand.n Java, constants are usually declared using the final keyword.

Example: 

final int AGE = 18; // AGE is a constant
final double PI = 3.14159; // PI is a constant
final String COUNTRY = "Nepal"; // COUNTRY is a constant

Here, the values of AGE, PI, and COUNTRY cannot be changed later in the program. Example program:

public class ConstantExample {
public static void main(String[] args) {
final double PI = 3.14159; // constant
final int DAYS_IN_WEEK = 7;
System.out.println("Value of PI: " + PI);
System.out.println("Days in a Week: " + DAYS_IN_WEEK);
// PI = 3.15; //  Error: cannot change the value of a constant
}
}

Difference Between Variables and Constants in Java

class Person {
private String name = "Basant"; // private
protected int age = 25; // protected
public String country = "Nepal"; // public
private void showName() {
System.out.println("Name: " + name);
}
protected void showAge() {
System.out.println("Age: " + age);
}
public void showCountry() {
System.out.println("Country: " + country);
}
public void displayAll() {
showName(); // private accessible inside class
showAge(); // protected accessible
showCountry();// public accessible
}
}
public class AccessExample {
public static void main(String[] args) {
Person p = new Person();
// public access
p.showCountry();
// private access (not allowed directly)
// p.showName(); ❌ Error
// protected access (not allowed directly outside class/package)
// p.showAge(); ❌ Error
// But accessible through public method
p.displayAll();
}
}

Example: 

public class EscapeExample {
public static void main(String[] args) {
System.out.println("Hello\nWorld"); // New line
System.out.println("Java\tProgramming"); // Tab space
System.out.println("He said: \"Hello\""); // Double quotes
System.out.println("Path: C:\\Program"); // Backslash
}
}
Output:
Hello
World
Java Programming
He said: "Hello"
Path: C:\Program

Example: 
public class CommentExample {
public static void main(String[] args) {
int a = 10; // This is a single-line comment
/*
This is a multi-line comment
explaining the next line of code
*/
int b = 20;
/** 
* This is a documentation comment
* It describes the addition of two numbers
*/
int sum = a + b; 
System.out.println("Sum: " + sum); // Prints the sum
}
}

public class ArithmeticExample {
public static void main(String[] args) {
int a = 10, b = 3;
System.out.println("Addition: " + (a + b));
System.out.println("Subtraction: " + (a - b));
System.out.println("Multiplication: " + (a * b));
System.out.println("Division: " + (a / b));
System.out.println("Modulus: " + (a % b));
}
}
out put:
Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3
Modulus: 1

public class RelationalExample {
public static void main(String[] args) {
int a = 5, b = 10;
System.out.println("a == b: " + (a == b));
System.out.println("a != b: " + (a != b));
System.out.println("a > b: " + (a > b));
System.out.println("a < b: " + (a < b));
System.out.println("a >= b: " + (a >= b));
System.out.println("a <= b: " + (a <= b));
}
}
out put:
a == b: false
a != b: true
a > b: false
a < b: true
a >= b: false
a <= b: true

public class LogicalExample {
public static void main(String[] args) {
boolean x = true, y = false;
System.out.println("x && y: " + (x && y));
System.out.println("x || y: " + (x || y));
System.out.println("!x: " + (!x));
}
}
out put: 
x && y: false
x || y: true
!x: false

public class AssignmentExample {
public static void main(String[] args) {
int a = 10;
a += 5;
System.out.println("After += : " + a);
a -= 3;
System.out.println("After -= : " + a);
a *= 2;
System.out.println("After *= : " + a);
a /= 4;
System.out.println("After /= : " + a);
a %= 3;
System.out.println("After %= : " + a);
}
}
out put:
After += : 15
After -= : 12
After *= : 24
After /= : 6
After %= : 0

public class UnaryExample {
public static void main(String[] args) {
int a = 5;
System.out.println("Original: " + a);
System.out.println("++a: " + (++a)); // pre-increment
System.out.println("a++: " + (a++)); // post-increment
System.out.println("After post-increment: " + a);
System.out.println("--a: " + (--a)); // pre-decrement
System.out.println("a--: " + (a--)); // post-decrement
System.out.println("After post-decrement: " + a);
}
}
out put:
Original: 5
++a: 6
a++: 6
After post-increment: 7
--a: 6
a--: 6
After post-decrement: 5