Java gives you a small but powerful set of arithmetic operators. These work pretty much the way you’d expect:

• + → Addition

• - → Subtraction

• / → Division

• * → Multiplication

• % → Modulus (returns the remainder after division)

You can use these operators on all numeric data types (byte, short, int, long, float, double, char), but not on boolean(Java refuses to treat true and false like numbers).

Operator Precedence (Highest → Lowest)

When you combine multiple operators in one expression, Java follows a fixed precedence order:

So in an expression like:

int x = 10 + 6 * 2;

Java always evaluates the * first, then applies the +, giving you 22.

If you want to override the default order, parentheses still rule the world.

Java’s Type Promotion Rules (Why Your byte Suddenly Becomes an int)

One thing Java loves to do (usually without asking) is promote smaller data types during arithmetic. So even if you start with tiny types like byte or short, the moment you add or subtract them, Java lifts them into bigger types behind the scenes. It’s part of what Java calls numeric promotion.

• byte, short, and char all get promoted to int when used in an expression

  • byte + short → int

  • char + short → int

  • char + int → int

• If either operand is long, the whole expression becomes long

  • short + long → long

• If either side is a float, Java goes with float

  • int + float → float

  • long + float → float

• And if a double enters the chat, everything becomes double

  • float + double → double

  • long + double → double

The idea is basically: Java always promotes to the “safer” type so nothing important gets lost.

Increment and Decrement Operators

Java gives us four operators to increase or decrease a value by 1. The only thing is when the increment/decrement happens.

• Post-increment (i++) → use the value first, then increase it

• Post-decrement (i--) → use the value first, then decrease it

• Pre-increment (++i) → increase first, then use the value

• Pre-decrement (--i) → decrease first, then use the value

Quick examples:

int x = 5;
System.out.println(x++); // prints 5, x becomes 6
System.out.println(++x); // x becomes 7, prints 7

int y = 10;
System.out.println(y--); // prints 10, y becomes 9
System.out.println(--y); // y becomes 8, prints 8

Bitwise Operators in Java — AND, OR, XOR, NOT, Shifts

Bitwise operators work directly on the binary representation of numbers. They’re super fast and great for low-level tasks like masks, flags, and performance-critical logic.

Main Bitwise Operators

Truth Tables

AND (&)

OR (|)

XOR (^)

Bitwise Examples

int x = 10, y = 6, z;
Binary:

• x = 10 → 00001010

• y = 6 → 00000110

AND

  00001010
& 00000110
-----------
  00000010 → 2

OR

  00001010
| 00000110
-----------
  00001110 → 14

XOR

  00001010
^ 00000110
-----------
  00001100 → 12

Shift Operators

int x = 10; // 00001010
int z;

Left Shift (<<)

x   =   00001010
x << 1 = 00010100 → 20

General rule:
x << k → x * 2^k

Right Shift (>>) (keeps the sign bit)

x   =     00001010
x >> 1 = 00000101 → 5

General rule:
x >> k → x / 2^k

How Negative Numbers Are Stored (Two’s Complement)

Let’s store -10:

1. Start with +10
00001010

2. Flip all bits (1’s complement)
   11110101

3. Add 1 (2’s complement)
   11110110 → this represents -10 in binary

Since the first bit is 1, the number is negative.

Right Shift With Negative Numbers

x = -10 = 11110110
x >> 1  = 11111011  // sign bit stays 1
x >>> 1 = 01111011  // fills with 0 → 123

>>> always shifts in zero, even for negative numbers.

Bitwise NOT (~)

x = 00001010  // 10
~x= 11110101  // -11

The rule is:
~x = -(x + 1)

So:
~10 = -11

Bit Masking and Merging

Bit masking lets you check, set, or clear specific bits in an integer using bitwise operators. Think of it as controlling individual switches in a row of lights — you can flip only the ones you care about.

• Masking (checking a bit):

int flags = 0b1010;    // 4 bits: 1010
int mask  = 0b0010;    // check 2nd bit

boolean isSet = (flags & mask) != 0;  // true, 2nd bit is 1

• Merging (setting a bit):

int flags = 0b1000;
int mask  = 0b0010;

flags = flags | mask;   // set the 2nd bit
// flags = 1010

With just & and |, you can read and write bits efficiently, which is crucial in low-level programming, graphics, and flags handling.

Question: How to store 2 numbers in 1 byte?

A single byte is 8 bits, so if both numbers are small enough (≤ 4 bits each, i.e., 0–15), you can pack them together using bitwise operations.

Step 1: Define the numbers

byte a = 9;  // 4 bits max: 1001
byte b = 6;  // 4 bits max: 0110

Step 2: Pack them into 1 byte

byte packed = (byte) ((a << 4) | b);

• a << 4 → move a to the higher 4 bits

• | b → merge b into the lower 4 bits

a = 1001 → 10010000
b = 0110 → 00000110
packed = 10010110 → 150 (decimal)

Step 3: Unpack the numbers

byte a2 = (byte) ((packed >> 4) & 0x0F);  // high 4 bits
byte b2 = (byte) (packed & 0x0F);         // low 4 bits

System.out.println(a2 + " " + b2);  // 9 6

• >> 4 shifts high bits to low position

• & 0x0F masks out unwanted bits

This way, you store two 4-bit numbers in a single byte and retrieve them later.

Widening and Narrowing (Type Casting)

Widening / Upcasting

• Converts smaller type → bigger type automatically.

• Safe, no data loss.

byte b = 10;
int i = b;  // byte → int (widening)

Narrowing / Downcasting

• Converts bigger type → smaller type.

• Must be explicit; can lose data.

int i = 130;
byte b = (byte) i;  // narrowing, b = -126

Question: How to swap two numbers without a Temp variable?

Bitwise XOR lets you swap numbers:

int a = 5, b = 9;

a = a ^ b;  // Step 1
b = a ^ b;  // Step 2
a = a ^ b;  // Step 3

System.out.println(a + " " + b);  // 9 5

No extra memory needed.

In Java, data types define the type of data that a variable can hold. They also determine the amount of memory allocated to the variable and the range of values it can store.

1. Categories of Data Types

Java data types are broadly classified into two categories:

1. Primitive Data Types

2. Non-Primitive (Reference) Data Types

This section focuses on primitive data types.

2. Primitive Data Types

Java has eight primitive data types, which are divided into four groups based on the kind of values they store:

A. Integral Types

Used to store whole numbers (integers).

• byte

• short

• int

• long

B. Floating-Point Types

Used to store numbers with decimal points.

• float

• double

C. Character Type

Used to store a single Unicode character.

• char

D. Boolean Type

Used to store logical values.

• boolean

3. Primitive Data Type Details

What are Variables ?

A variable is a name given to a memory location that stores a value. In Java, variables are used to store data that can be used and modified during program execution.

Each variable has:

1. A data type — which defines the kind of value it can store (e.g., integer, float, character, etc.)

2. A name — which identifies the variable in the program

3. A value — which represents the actual data stored

The general syntax for declaring a variable is:

dataType variableName = value;

int i = 175; ⬜ ⬜ ⬜ ⬜

float f = 25.3f; ⬜ ⬜ ⬜ ⬜

char c = ‘A’; ⬜ ⬜

byte b = 5; ⬜

Rules for Variable Names

In Java, variable names (also called identifiers) must follow specific rules to ensure that the code is valid and readable. The following are the key rules and best practices for naming variables:

1. Case Sensitivity

Variable names in Java are case-sensitive.
This means age, Age, and AGE are considered three different variables.

2. Allowed Characters

A variable name can contain:

• Alphabets (A–Z, a–z)

• Digits (0–9)

• The underscore (_)

• The dollar sign ($)

3. Starting Character

A variable name must start with:

• A letter (A–Z or a–z)

• An underscore (_)

• Or a dollar sign ($)

It cannot start with a digit.

4. Not a Keyword

A variable name cannot be a Java keyword (like class, int, if, return, etc.).

5. Avoid Class Names in Use

If a class with a certain name already exists, avoid using that same name for a variable to prevent confusion and ambiguity.

6. No Length Limit

There is no limit to the length of a variable name.
However, names should be kept meaningful and concise for readability.

7. Use Camel Case Convention

Java developers commonly follow the camelCase naming convention for variables:

• The first word starts with a lowercase letter.

• Each subsequent word begins with an uppercase letter.

What are Literals

A literal is a constant value that is directly written in the code. It represents a fixed value that does not change during program execution. In Java, literals are used to assign values to variables of various data types.

1. Integer Literals

Integer literals represent whole numbers (without a fractional part). For example:

z = 2 x + 17 y;

Here, 2 and 17 are integer literals.
Variables of type byte, short, and int can be initialized using integer literals (of type int), as long as the value fits within the range of the target type.

A long variable is initialized using a long literal by appending L or l at the end of the number:

long distance = 4124L;

2. Floating-Point Literals

Floating-point literals represent real numbers that contain a decimal point.
A float literal is written with an f or F suffix:

float rate = 2.34f;

A double literal can be written either with or without a d or D suffix:

double price = 456.41;

double tax = 2.34D;

3. Character Literals

A character literal represents a single character enclosed within single quotes:

char c = 'A';

4. String Literals

A string literal represents a sequence of characters enclosed within double quotes:

String s = "Java";

5. Boolean Literals

A boolean literal has only two possible values: true or false.

boolean isActive = true;

boolean isComplete = false;

6. Number System Literals

Java supports several types of number system literals:

• Binary literals (prefix 0b or 0B):
  int binaryNum = 0b1010; // equivalent to 10 in decimal

• Octal literals (prefix 0):
  int octalNum = 012; // equivalent to 10 in decimal

• Hexadecimal literals (prefix 0x or 0X):
  int hexNum = 0xA; // equivalent to 10 in decimal

Integral Data Type

When Java was first introduced, 32-bit systems were the standard in computing. Because of this, Java designed the int data type to occupy 4 bytes (32 bits).
If integers had been stored in only 2 bytes (16 bits), it would have underutilized the processor’s capabilities, leading to slower performance.
Hence, int in Java is always 32 bits, regardless of the underlying machine architecture, ensuring platform independence.

Understanding How Integers Are Stored

To understand how integral data types (like byte, short, int, long) store numbers, we need to look at binary representation.

Let’s take the example of the byte data type.

• A byte is 1 byte = 8 bits.

• It can store values from –128 to 127.

• The most significant bit (MSB) — the 7th bit (counting from 0 to 7, right to left) — is used as the sign bit.

  • 0 → positive number

  • 1 → negative number

Example: Representing 127
01111111

• The first bit (0) indicates it’s positive.

• The remaining 7 bits represent the value 1111111, which equals 127 in decimal.

Example: Representing -5

To store a negative number like -5, Java (and most programming languages) uses a system called Two’s Complement representation.

Here’s how it works step by step:

1. Find the binary of 5:
   00000101

2. Find the One’s Complement:
   (Invert all bits: 0 → 1 and 1 → 0)
   11111010

3. Find the Two’s Complement:
   (Add 1 to the One’s Complement)
   11111010 + 1 = 11111011

4. Result:
   11111011 → represents -5

Float Data Type

In Java, floating-point data types are used to represent numbers that have a fractional part — that is, numbers with decimal points. Examples include 3.14, 0.001, or -98.6.

Java provides two floating-point types:

• float (4 bytes, single precision)

• double (8 bytes, double precision)

Both types follow the IEEE 754 standard for representing floating-point numbers in binary form.

Understanding Floating-Point Representation

A floating-point number is represented internally using scientific notation.
In this format, a number is expressed as:

Number = Mantissa × 10^(Exponent)

• The mantissa (or significand) represents the actual digits of the number.

• The exponent represents the power of 10 (or 2 in binary form) that determines where the decimal point is placed.

This allows very large or very small numbers to be stored efficiently.

Example: Representing 163.52

Let’s understand how 163.52 can be expressed in floating-point form.

163.52 = 16352 / 100 = 16352 × 10^−2

• Mantissa: 16352

• Exponent: -2

This can be written as: 16352E-2

In Java notation, the letter E (or e) is used to represent “×10 to the power of”.
So, 16352E-2 means: 163.52

How Float Is Stored Internally

A float in Java is a 32-bit (4-byte) value and is divided into three parts as per the IEEE 754 single-precision format:

So, a 32-bit float looks like this: [ Sign (1 bit) ][ Exponent (8 bits) ][ Mantissa (23 bits) ]

For a deeper look at how these bits actually represent floating-point numbers in memory (with binary breakdowns and examples), check out this detailed explanation:

👉 Understanding IEEE 754 Floating-Point Representation (external link)

👉 How float or double values are stored in memory? (external link)

1991 → Project started by James Gosling and team at Sun Microsystems
Initially named "Oak" after a tree near Gosling's office
Later renamed "Green" and finally "Java" after Java coffee

1995 → First public release of Java 1.0
Known for "Write Once, Run Anywhere" (WORA) — platform independence

1997 → Java Community Process (JCP) started for collaboration & standardization
JDK 1.1 released with major features like JavaBeans and JDBC
JVM standardized to ensure platform-independent execution

1998 → Release of Java 2 (J2SE 1.2), a major milestone
Introduced different editions: J2SE (Standard), J2EE (Enterprise), J2ME (Mobile)

2006 onwards → Naming changed to Java SE (Standard Edition), Java EE (Enterprise), Java ME (Mobile)

JDK, JVM, and JRE

• JVM (Java Virtual Machine): The core runtime component that interprets compiled Java bytecode and translates it into machine-specific instructions. It manages memory, security, garbage collection, and provides a platform-independent execution environment.

• JRE (Java Runtime Environment): Includes the JVM along with standard libraries and classes required to run Java applications. It does not include development tools like a compiler or debugger. JRE is for executing Java programs only.

• JDK (Java Development Kit): This package includes the JRE plus development tools such as the Java compiler (javac), debugger, and other utilities required for writing, compiling, and debugging Java applications.

How a Java Program is Run

Running a Java program involves several steps:

1. Writing the Source Code: Create a .java file with Java source code.

2. Compilation: The javac compiler converts the source code into bytecode, a platform-independent intermediate format, stored in .class files.

3. Loading: The JVM loads the bytecode into memory.

4. Verification: JVM verifies the bytecode to ensure it is valid and secure.

5. Execution: The JVM interprets or just-in-time compiles the bytecode into native machine code and runs the program.

Skeleton of a Java Program

import java.lang.*; // It will automatically be imported even if we don't import it
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

• public: Access modifier, means the class/method is accessible from anywhere.

• class: Defines a class named HelloWorld.

• static: Means the method belongs to the class, not a specific instance. To use main method without creating an object of the class we use static here.

• void: The method returns no value.

• main: Entry point of any standalone Java application.

• String[] args: An array of command-line arguments.

• System.out.println: Prints text to the console.

  • System is a built-in class in the Java standard library (java.lang package).

  • out is a static variable inside the System class which points to an object of type PrintStream.

  • println is a method that belongs to the PrintStream class

Reading from Keyboard

The Scanner class in java.util package is used to read user inputs from various sources, including the keyboard.

Example

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in); // Create Scanner object
        System.out.print("Enter your name: ");
        String name = input.nextLine(); // Reads a line of text
        System.out.println("Hello, " + name);

        input.close(); // Close the scanner
    }
}

Scanner input = new Scanner(System.in); creates a Scanner object to read input from the keyboard

Methods:

• next(): Reads and returns the next single token (word) as a String.

• nextLine(): Reads and returns an entire line of input as a String.

• nextInt(): Reads the next token as an int value.

• nextDouble(): Reads the next token as a double value.

• nextFloat(): Reads the next token as a float value.

• nextLong(): Reads the next token as a long value.

• nextShort(): Reads the next token as a short value.

• nextByte(): Reads the next token as a byte value.

• nextBoolean(): Reads the next token as a boolean value.

• hasNext(): Checks if there is another token available.

• hasNextLine(): Checks if there is another line available.

• Similarly hasNextInt(), hasNextFloat(), etc.

• useRadix(int radix):Sets the default number base (radix) the scanner uses to interpret numeric input (e.g., decimal, hexadecimal). If radix = 2 then the input will be taken in Binary.

• close(): Closes the Scanner object, freeing resources.