1. What is a Variable

1.1 Definition

A variable is a container used to store data that can be used and modified during program execution.

1.2 Purpose of Variables

• Store values (numbers, text, etc.)
• Reuse data in programs
• Make programs dynamic and flexible

1.3 Memory Representation

When a variable is created, memory is allocated in the system to store its value.

1.4 Naming Rules

• Must start with a letter, _, or $
• Cannot start with a number
• Cannot use Java keywords
• Case-sensitive

1.5 Naming Conventions

• Use meaningful names
• Follow camelCase (e.g., studentName, totalMarks)

---

2. Primitive Data Types

2.1 Overview

Primitive data types are basic data types built into Java. They store simple values directly.

---

2.2 int

Used to store whole numbers.

int age = 25;

• Size: 4 bytes
• Range: -2,147,483,648 to 2,147,483,647

---

2.3 float

Used to store decimal numbers (single precision).

float price = 99.99f;

• Size: 4 bytes
• Requires f suffix

---

2.4 double

Used for decimal numbers with higher precision.

double pi = 3.14159;

• Size: 8 bytes
• More precise than float

---

2.5 char

Used to store a single character.

char grade = 'A';

• Size: 2 bytes
• Uses Unicode

---

2.6 boolean

Used to store true or false values.

boolean isActive = true;

---

2.7 byte

Used to store small integer values.

byte level = 10;

• Size: 1 byte
• Range: -128 to 127

---

2.8 short

Used for small integer values.

short year = 2025;

• Size: 2 bytes

---

2.9 long

Used for large integer values.

long population = 9000000000L;

• Size: 8 bytes
• Requires L suffix

---

3. Non-Primitive Data Types

3.1 Definition

Non-primitive data types store references to objects rather than actual values.

3.2 Differences

Primitive	Non-Primitive
Stores value	Stores reference
Fixed size	Variable size
No methods	Has methods

3.3 Common Types

• String
• Arrays
• Classes
• Objects

3.4 Memory Storage

• Primitive → Stack memory
• Non-Primitive → Heap memory

3.5 Example

String name = "Pooja";

---

4. Declaring and Initializing Variables

4.1 Declaration

Declaring a variable means specifying its type and name.

int number;

4.2 Initialization

Assigning a value to a variable.

number = 10;

4.3 Declaration + Initialization

int number = 10;

4.4 Multiple Variables

int a = 1, b = 2, c = 3;

4.5 Constants

Use final keyword.

final double PI = 3.14;

---

5. Type Casting

5.1 Introduction

Type casting is the process of converting one data type into another.

---

5.2 Implicit Casting (Widening)

Definition

Automatic conversion from smaller type to larger type.

Example

int num = 10;
double value = num;

• No data loss
• Done automatically

---

5.3 Explicit Casting (Narrowing)

Definition

Manual conversion from larger type to smaller type.

Example

double num = 10.5;
int value = (int) num;

• May cause data loss
• Requires casting operator

---

Common Type Conversion Order

byte → short → int → long → float → double

---

Conclusion

Variables and data types are the building blocks of Java programming. Once you understand how to store data, choose the right type, and convert between types, you can start building meaningful programs. These concepts will be used in almost every Java application you create.

1. Basic Structure of a Java Program

1.1 Overview of Java Program Components

A Java program typically consists of:

• Package declaration (optional)
• Import statements (optional)
• Class definition
• Methods and variables inside the class

1.2 Class Declaration and Syntax

Every Java program must have at least one class. The class acts as a blueprint.

class MyClass {
    // code goes here
}

1.3 Understanding Class Keywords and Naming

• class keyword is used to declare a class
• Class names should start with a capital letter
• Example: Student, Car, HelloWorld

1.4 Structure of a Simple Java Program

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

1.5 Order of Elements in a Java File

1. Package declaration
2. Import statements
3. Class declaration
4. Variables and methods

1.6 Example Explanation

• public class HelloWorld → Class name
• main() → Entry point
• System.out.println() → Prints output

---

2. The main() Method

2.1 What is the main() Method

The main() method is the starting point of every Java program.

2.2 Importance of main()

• JVM starts execution from this method
• Without it, the program will not run

2.3 Syntax of main()

public static void main(String[] args)

2.4 Understanding Parameters

• String[] args → Command-line arguments
• Allows input while running the program

2.5 Execution Flow

1. Program starts
2. JVM looks for main()
3. Executes statements inside it

2.6 Common Mistakes

• Missing static keyword
• Wrong method signature
• Typo in method name

---

3. Packages and Imports

3.1 What is a Package

A package is a namespace that organizes related classes.

3.2 Types of Packages

• Built-in packages (e.g., java.util)
• User-defined packages

3.3 Creating a Package

package mypackage;

3.4 What are Import Statements

Imports allow you to use classes from other packages.

3.5 Importing Specific Classes

import java.util.Scanner;

3.6 Importing Entire Package

import java.util.*;

3.7 Static Imports

import static java.lang.Math.*;

3.8 Naming Conventions

• Use lowercase
• Example: com.myapp.project

---

4. Comments in Java

4.1 What are Comments

Comments are non-executable lines used to explain code.

4.2 Importance

• Improves readability
• Helps others understand code

4.3 Single-line Comments

// This is a single-line comment

4.4 Multi-line Comments

/* This is
   a multi-line comment */

4.5 Documentation Comments (Javadoc)

/**
 * This is a documentation comment
 */

4.6 Best Practices

• Keep comments meaningful
• Avoid unnecessary comments
• Update comments with code

---

5. Coding Conventions

5.1 Importance

Coding conventions make code readable and maintainable.

5.2 Naming Conventions for Classes

• Use PascalCase
• Example: BankAccount, StudentRecord

5.3 Naming for Variables and Methods

• Use camelCase
• Example: totalMarks, calculateSum()

5.4 Indentation and Formatting

• Use proper spacing
• Keep consistent indentation

5.5 Code Readability

• Use meaningful names
• Avoid long and complex methods

5.6 Best Practices

• Write simple and clean code
• Follow standard structure
• Use proper comments

5.7 Common Beginner Mistakes

• Poor naming
• No indentation
• Writing all code in one method
• Ignoring conventions

Conclusion

Understanding Java program structure is the first step toward becoming a good Java developer. Once you know how to organize your code, use the main method, manage packages, and follow coding standards, writing Java programs becomes much easier and more efficient.

1. Installing the Java Development Kit (JDK)

1.1 What is JDK

JDK (Java Development Kit) is a software package that provides tools required to develop Java applications. It includes the compiler (javac), libraries, and runtime environment.

1.2 Choosing the Right JDK Version

• Beginners should use the latest LTS (Long-Term Support) version
• Common choices: Java 17 or Java 21

1.3 Downloading JDK

Download JDK from official sources like:

• Oracle JDK
• OpenJDK

1.4 Installation on Windows

• Download the .exe file
• Run the installer
• Follow setup instructions
• Note installation path

1.5 Installation on macOS

• Download .dmg file
• Install like a normal app
• Verify using terminal

1.6 Installation on Linux

• Use package manager (apt, yum)
• Example: sudo apt install openjdk-17-jdk

1.7 Verifying Installation

Open terminal/command prompt and run:

java -version
javac -version

---

2. Understanding JDK, JRE, and JVM

2.1 Java Architecture Overview

Java works using a layered system:

• Source code → Bytecode → Execution

2.2 What is JVM

JVM (Java Virtual Machine) executes Java bytecode. It makes Java platform-independent.

2.3 What is JRE

JRE (Java Runtime Environment) provides libraries and JVM to run Java programs.

2.4 What is JDK

JDK includes:

• JRE
• Compiler (javac)
• Development tools

2.5 Differences

Component	Purpose
JVM	Runs bytecode
JRE	Provides runtime environment
JDK	Full development kit

2.6 How They Work Together

• Write code → Compile with JDK → Run using JVM (via JRE)

---

3. Setting Environment Variables

3.1 What are Environment Variables

These are system variables that help your OS locate software like Java.

3.2 Why PATH is Important

PATH allows you to run Java commands from anywhere in the terminal.

3.3 Setting JAVA_HOME

JAVA_HOME points to your JDK installation directory.

3.4 Configuring PATH

Add JDK’s bin folder to PATH.

3.5 On Windows

• Open System Properties
• Go to Environment Variables
• Add:
  • JAVA_HOME = JDK path
  • PATH = %JAVA_HOME%\bin

3.6 On macOS/Linux

Edit .bashrc or .zshrc:

export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

3.7 Verification

Run:

echo %JAVA_HOME%   (Windows)
echo $JAVA_HOME   (Mac/Linux)

---

4. Installing an IDE

4.1 What is an IDE

An IDE (Integrated Development Environment) helps write, run, and debug code easily.

4.2 Popular IDEs

• IntelliJ IDEA
• Eclipse
• VS Code

4.3 Installing IntelliJ IDEA

• Download Community Edition
• Install and launch
• Create a new Java project

4.4 Installing Eclipse

• Download Eclipse Installer
• Choose “Eclipse IDE for Java Developers”

4.5 Installing VS Code

• Install VS Code
• Add Java Extension Pack

4.6 Configuring IDE

• Set JDK path
• Configure project SDK

4.7 Creating First Project

• Click “New Project”
• Select Java
• Choose JDK
• Create class file

---

5. Writing and Running Your First Java Program

5.1 Structure of a Java Program

Basic structure:

• Class
• Main method

5.2 Main Method

Entry point of Java program:

public static void main(String[] args)

5.3 Hello World Program

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

5.4 Saving File

• Save as HelloWorld.java

5.5 Compiling

javac HelloWorld.java

5.6 Running

java HelloWorld

5.7 Running in IDE

• Click Run button
• Output appears in console

---

6. Understanding the Compilation Process

6.1 Compilation Overview

Java uses a two-step process:

1. Compile
2. Execute

6.2 Source to Bytecode

• .java → .class

6.3 Role of javac

The compiler converts code into bytecode.

6.4 What is Bytecode

• Intermediate code
• Platform-independent

6.5 Role of JVM

JVM converts bytecode into machine code.

6.6 Platform Independence

“Write Once, Run Anywhere”
Java runs on any system with JVM.

6.7 Common Errors

• Syntax errors
• Missing semicolon
• Wrong file name
• Class name mismatch

---

Conclusion

Setting up the Java environment may seem technical at first, but once completed, it becomes the foundation of your programming journey. With JDK installed, environment variables configured, and an IDE ready, you are fully prepared to start learning Java and building applications.

Welcome to WordPress. This is your first post. Edit or delete it, then start writing!