DEV Community: Jayashree

Java File Handling Examples – Logging, File Copy, and Finding Maximum Marks

Jayashree — Wed, 08 Apr 2026 13:14:50 +0000

In this blog, we’ll look at three simple and useful Java programs related to file handling:

Writing logs into separate files (error & log)
Copying content from one file to another
Finding the student with the maximum mark and storing it in a file

These examples are beginner-friendly and help understand how Java works with files.

1. Writing Logs into Separate Files

This program demonstrates how to store messages in different files based on their type.
For example:

Error messages go into error.txt
Normal logs go into log.txt

Key Idea:

We check the message type and decide the file path accordingly.

Code:

public static void logExample(String type, String message) {
    String filename = "";

    if (type.equalsIgnoreCase("error")) {
        filename = "error.txt";
    } else if (type.equalsIgnoreCase("log")) {
        filename = "log.txt";
    }

    try (BufferedWriter br = new BufferedWriter(new FileWriter(filename, true))) {
        br.write(message);
        br.newLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:

error.txt → stores error messages
log.txt → stores normal logs

2. Copying Data from One File to Another

This program reads content from one file and writes it into another file.

Key Idea:

Use BufferedReader to read
Use BufferedWriter to write

Code:

File inputfile = new File("file1.txt");
File outputfile = new File("file2.txt");

try {
    BufferedReader br = new BufferedReader(new FileReader(inputfile));
    BufferedWriter bw = new BufferedWriter(new FileWriter(outputfile));

    String line;

    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
    }

    br.close();
    bw.close();

    System.out.println("File copied successfully...");
} catch (IOException ioe) {
    ioe.printStackTrace();
}

Output:

Content from file1.txt will be copied into file2.txt.

3. Finding Maximum Mark and Writing to File

This program takes student details (id, name, mark), finds the student with the highest mark, and stores the result in a file.

Key Idea:

Store student data in an array
Compare marks to find the maximum
Write result to file

Code:

Student maxStudent = students[0];

for (Student s : students) {
    if (s.mark > maxStudent.mark) {
        maxStudent = s;
    }
}

try (BufferedWriter writer = new BufferedWriter(new FileWriter("max.txt"))) {
    writer.write("Topper Details:\n");
    writer.write("ID: " + maxStudent.id + "\n");
    writer.write("Name: " + maxStudent.name + "\n");
    writer.write("Mark: " + maxStudent.mark + "\n");
} catch (IOException e) {
    e.printStackTrace();
}

Output:

The file max.txt will contain the details of the student with the highest mark.

Conclusion

These three programs cover important concepts in Java:

File writing and appending
File reading and copying
Basic data processing and storing results

Understanding these basics will help you build more advanced applications like logging systems, report generators, and data processing tools.

Understanding File Handling in Java (FileReader, FileWriter, BufferedReader & More)

Jayashree — Tue, 07 Apr 2026 10:50:22 +0000

Working with files is a basic but important part of Java programming. Whether you're storing data, reading logs, or processing text, Java provides several classes to make file handling simple and efficient.

In this post, let’s walk through some commonly used classes:

File
FileReader
FileWriter
BufferedReader
BufferedWriter

1. File Class

The File class is used to represent a file or directory path. It doesn’t actually read or write data — it just gives information about the file.

Example:

import java.io.File;
public class FileExample {
    public static void main(String[] args) {
        File file = new File("example.txt");

        if (file.exists()) {
            System.out.println("File exists");
            System.out.println("File name: " + file.getName());
            System.out.println("Path: " + file.getAbsolutePath());
        } else {
            System.out.println("File does not exist");
        }
    }
}

2. FileReader

FileReader is used to read data from a file character by character. It’s simple but not the most efficient for large files.

Example:

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader("example.txt");
        int ch;

        while ((ch = reader.read()) != -1) {
            System.out.print((char) ch);
        }

        reader.close();
    }
}

3. FileWriter

FileWriter is used to write text into a file. If the file doesn’t exist, it will be created automatically.

Example:

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) throws IOException {
        FileWriter writer = new FileWriter("example.txt");

        writer.write("Hello, this is a file writing example.");
        writer.close();
    }
}

4. BufferedReader

BufferedReader is used along with FileReader to read text efficiently. It reads larger chunks(a group of characters) instead of one character at a time.

Example:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("example.txt"));
        String line;

        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        br.close();
    }
}

5. BufferedWriter

BufferedWriter is used with FileWriter to write data efficiently. It reduces the number of write operations.

Example:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("example.txt"));

        bw.write("Hello, this is written using BufferedWriter.");
        bw.newLine();
        bw.write("Writing another line.");

        bw.close();
    }
}

Why Use Buffered Classes?

Without buffering:

Data is read/written one character at a time → slow

With buffering:

Data is handled in chunks(A fixed-size block of data) → faster and more efficient

Final Thoughts

Use File to manage file paths and properties
Use FileReader and FileWriter for basic operations
Use BufferedReader and BufferedWriter for better performance

In real-world applications, buffered classes are preferred because they improve speed and reduce system load.

Java File Handling Made Easy: Learn File Class Methods Step by Step

Jayashree — Mon, 06 Apr 2026 06:06:03 +0000

File handling is a crucial part of Java programming, especially when working with external data. The File class in Java (from java.io package) provides several useful methods to create, read, write, and manage files and directories.

In this blog, we’ll explore important file handling methods like createNewFile(), compareTo(), canRead(), canWrite(), and more—with clear explanations and examples.

1. createNewFile()

This method is used to create a new file.

Syntax:

File file = new File("example.txt");
file.createNewFile();

Key Points:

Returns true if file is created successfully
Returns false if file already exists
Throws IOException

2. compareTo(File pathname)

Compares two file paths lexicographically.

Example:

File f1 = new File("a.txt");
File f2 = new File("b.txt");

System.out.println(f1.compareTo(f2));

Key Points:

Returns 0 → if both paths are equal
Returns negative → if first < second
Returns positive → if first > second

3. canRead()

Checks whether the file is readable.

file.canRead();

Returns:

true → if readable
false → if not

4. canWrite()

Checks whether the file is writable.

file.canWrite();

5. getAbsolutePath()

Returns the absolute path of the file.

System.out.println(file.getAbsolutePath());

Example Output:

C:\Users\YourName\example.txt

6. getCanonicalPath()

Returns the canonical (normalized) path.

file.getCanonicalPath();

Difference:

Removes redundant elements like . and ..
Resolves symbolic links

7. exists()

Checks if the file exists.

file.exists();

8. isDirectory()

Checks whether the path is a directory.

file.isDirectory();

9. getName()

Returns the name of the file or directory.

file.getName();

10. getParent()

Returns the parent directory path.

file.getParent();

11. isFile()

Checks whether it is a file (not a directory).

file.isFile();

12. isHidden()

Checks whether the file is hidden.

file.isHidden();

13. lastModified()

Returns the last modified time.

file.lastModified();

Output:

Returns time in milliseconds
Convert to readable format:
new Date(file.lastModified());

14. mkdir()

Creates a directory.

File dir = new File("newFolder");
dir.mkdir();

Key Points:

Returns true if directory created
Use mkdirs() to create nested directories

Example Program (All Methods Together)

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class FileDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("example.txt");

        file.createNewFile();

        System.out.println("Exists: " + file.exists());
        System.out.println("Readable: " + file.canRead());
        System.out.println("Writable: " + file.canWrite());
        System.out.println("Name: " + file.getName());
        System.out.println("Path: " + file.getAbsolutePath());
        System.out.println("Canonical Path: " + file.getCanonicalPath());
        System.out.println("Parent: " + file.getParent());
        System.out.println("Is File: " + file.isFile());
        System.out.println("Is Hidden: " + file.isHidden());
        System.out.println("Last Modified: " + new Date(file.lastModified()));

        File dir = new File("testDir");
        dir.mkdir();

        System.out.println("Is Directory: " + dir.isDirectory());
    }
}

Conclusion

Java file handling might look simple at first, but these methods give you strong control over how your program interacts with the file system. From creating files to checking permissions and retrieving file details, each method plays an important role in building reliable applications.

Instead of memorizing everything, focus on understanding when and why to use each method. With practice, you’ll naturally get comfortable handling files, directories, and paths in real-world programs.

File Handling in Java – Complete Guide

Jayashree — Sun, 05 Apr 2026 09:27:59 +0000

File Handling in Java

File handling in Java allows us to create, read, write, and delete files. It is an essential concept when working with data storage outside the program.

What is File Handling?

File handling means performing operations on files such as:

Creating a file
Writing data to a file
Reading data from a file
Deleting a file

Java provides classes in the java.io package to perform these operations.

Important Classes in Java File Handling

File → Represents a file or directory
FileWriter → Writes data to a file
FileReader → Reads data from a file
BufferedReader → Reads text efficiently
BufferedWriter → Writes text efficiently

1. Creating a File

import java.io.File;
import java.io.IOException;

public class CreateFileExample {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists");
            }
        } catch (IOException e) {
            System.out.println("An error occurred");
        }
    }
}

2. Writing to a File

import java.io.FileWriter;
import java.io.IOException;

public class WriteFileExample {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("example.txt");
            writer.write("Hello, this is Java file handling!");
            writer.close();
            System.out.println("Successfully written to file.");
        } catch (IOException e) {
            System.out.println("Error writing file");
        }
    }
}

3. Reading from a File

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;

public class ReadFileExample {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }

            reader.close();
        } catch (IOException e) {
            System.out.println("Error reading file");
        }
    }
}

FileReader vs BufferedReader

Feature	FileReader	BufferedReader
Reading Style	Character by character	Line by line
Speed	Slower	Faster
Efficiency	Low (no buffering)	High (uses buffer)
Use Case	Small files	Large files
Memory Usage	Less	Slightly more (buffer used)

4. Deleting a File

import java.io.File;

public class DeleteFileExample {
    public static void main(String[] args) {
        File file = new File("example.txt");

        if (file.delete()) {
            System.out.println("File deleted successfully");
        } else {
            System.out.println("Failed to delete file");
        }
    }
}

Exception Handling in File Handling

File operations may cause errors such as:

File not found
Permission issues
I/O errors

So we use try-catch blocks to handle exceptions like IOException.

Advantages of File Handling

Stores data permanently
Helps in data sharing
Useful for logs, reports, and configuration files

Conclusion

File handling in Java is a powerful feature that allows programs to interact with external files. By using classes like File, FileWriter, and BufferedReader, we can easily manage file operations efficiently.

Common Runtime Exceptions in Java (With Examples & Handling)

Jayashree — Sat, 04 Apr 2026 04:53:09 +0000

In Java, Runtime Exceptions are errors that occur during the execution of a program. These are also called unchecked exceptions, meaning the compiler does not force you to handle them.
They usually happen due to programming mistakes.
In this blog, we will look at some of the most common runtime exceptions and also learn how to handle them properly:

ArrayIndexOutOfBoundsException
NullPointerException
NegativeArraySizeException
ArithmeticException

What is a Runtime Exception?

A Runtime Exception is an exception that occurs while the program is running.

These exceptions belong to the RuntimeException class. RuntimeException is a one of the subclass of Exception class.
Handling is optional, but avoiding them is the best practice

1. ArrayIndexOutOfBoundsException

Definition:
Occurs when accessing an invalid array index.

Example:

int[] arr = {1, 2, 3};
System.out.println(arr[5]);

How to Handle:

try {
    System.out.println(arr[5]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Invalid index!");
}

Best Practice: Always check array length before accessing

2. NullPointerException

Definition:
Occurs when using a null object reference.

Example:

String str = null;
System.out.println(str.length());

How to Handle:

try {
    System.out.println(str.length());
} catch (NullPointerException e) {
    System.out.println("Object is null!");
}

Best Practice: Check for null before using object

if (str != null) {
    System.out.println(str.length());
}

3. NegativeArraySizeException

Definition:
Occurs when creating an array with negative size.

Example:

int[] arr = new int[-5];

How to Handle:

try {
    int size = -5;
    int[] arr = new int[size];
} catch (NegativeArraySizeException e) {
    System.out.println("Array size cannot be negative!");
}

Best Practice: Validate input before creating array

4. ArithmeticException

Definition:
Occurs during invalid arithmetic operations.

Example:
int result = 10 / 0;

How to Handle:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
}

Best Practice: Always check divisor before division

if (b != 0) {
    int result = a / b;
}

General Ways to Handle Runtime Exceptions

1. Using try-catch

try {
    // risky code
} catch (Exception e) {
    System.out.println(e.getMessage());
}

2. Using multiple catch blocks

try {
    int[] arr = new int[2];
    arr[5] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index issue");
} catch (Exception e) {
    System.out.println("General error");
}

3. Using finally block

try {
    int a = 10 / 0;
} catch (Exception e) {
    System.out.println("Error occurred");
} finally {
    System.out.println("Always executes");
}

Conclusion
Runtime exceptions occur during execution
They are unchecked exceptions
You can handle them using try-catch
But best practice is to prevent them with proper coding.

Exception Handling in Java: 5 Important Keywords (With Examples)

Jayashree — Fri, 03 Apr 2026 16:08:10 +0000

Exception Handling is one of the core concepts in Java that helps you manage runtime errors and maintain the normal flow of your program.

Java provides 5 important keywords to handle exceptions effectively:

try
catch
finally
throw
throws

In this blog, we’ll understand each keyword with clear definitions,Uses and examples.

1. try

Definition:

The try block is used to enclose code that might throw an exception.
It must be followed by either catch or finally.

Uses of try:

To wrap risky code like file operations, network calls, or arithmetic operations.
To prevent the program from crashing by allowing exception handling.
Works with catch or finally blocks.

Example:

try {
    int result = 10 / 0;
}

2. catch

Definition:

The catch block is used to handle the exception thrown in the try block.

Uses of catch:

To handle runtime errors gracefully.
To avoid program termination.
Can have multiple catch blocks to handle different exceptions.

Example:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

Multiple catch Example:

try {
int result = 10 / 0;
String str = null;
System.out.println(str.length());
} catch (ArithmeticException e) {
System.out.println("Math error");
} catch (NullPointerException e) {
System.out.println("Null object used");
}

3. finally

Definition:

The finally block is used to execute important code regardless of exception occurrence.
It always executes (except JVM crash).

Uses of finally:

To release resources (files, DB connections).
To execute mandatory cleanup code even if an exception occurs.
Can be used without catch (optional).

Example:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error occurred");
} finally {
    System.out.println("Cleanup code");
}

4. throw

Definition:

The throw keyword is used to explicitly throw an exception.
It is used when you want to manually create and throw an exception.

Syntax:

throw new ExceptionType("message");

Example:

public class Demo {
    public static void main(String[] args) {
        int age = 16;

        if (age < 18) {
            throw new ArithmeticException("Not eligible to vote");
        }

        System.out.println("Eligible to vote");
    }
}

Uses of `throw`

1. Input Validation

if (amount < 0) {
    throw new IllegalArgumentException("Amount cannot be negative");
}

2. Business Logic Validation

if (balance < withdrawAmount) {
    throw new ArithmeticException("Insufficient balance");
}

3. Custom Error Handling

You can create and throw your own exceptions

throw new RuntimeException("Something went wrong");

5. throws

Definition:

The throws keyword is used in a method declaration to declare exceptions that a method might throw.
It tells the caller: “Hey, this method may cause an exception — you handle it!”

Syntax:

returnType methodName() throws ExceptionType {
}

Example:

import java.io.*;

public class Demo {
    public static void readFile() throws IOException {
        FileReader file = new FileReader("test.txt");
    }

    public static void main(String[] args) {
        try {
            readFile();
        } catch (IOException e) {
            System.out.println("File error");
        }
    }
}

Uses of `throws`

1. Delegating Exception Handling

Instead of handling inside method, pass it to caller

public void process() throws IOException {
    // risky code
}

2. Cleaner Code

Keeps method clean without try-catch

3. Required for Checked Exceptions

Compiler forces you to handle or declare

Key Differences Between throw and throws

Feature	throw	throws
Purpose	Actually throws exception	Declares exception
Usage	Inside method/block	Method signature
Number	One exception at a time	Can declare multiple
Example	throw new Exception()	throws IOException
Control	Immediate	Delegates to caller

Real-Time Example

Banking Scenario:

public class Bank {

    public static void withdraw(int balance, int amount) {
        if (amount > balance) {
            throw new ArithmeticException("Insufficient balance");
        }
        System.out.println("Withdrawal successful");
    }

    public static void main(String[] args) {
        withdraw(1000, 2000);
    }
}

File Handling Scenario:

public void readData() throws IOException {
    FileReader file = new FileReader("data.txt");
}

throw → Used to explicitly throw an exception
throws → Used to declare exceptions in method
throw is for creating errors, throws is for passing responsibility

Both are essential for writing clean and maintainable Java code.

Quick Summary Table

Keyword	Purpose
try	Wrap risky code
catch	Handle exception
finally	Always execute block
throw	Manually throw exception
throws	Declare exception

Conclusion

Exception Handling keywords help you:

Prevent program crashes
Handle errors gracefully
Maintain smooth execution

Mastering these 5 keywords is essential for writing robust and production-ready Java code.

Practice these concepts with real programs to become confident in exception handling!

What is Throwable in Java? A Complete Guide

Jayashree — Thu, 02 Apr 2026 05:05:53 +0000

When learning Java, one of the most important topics is Exception Handling. At the core of this concept lies the Throwable class.

In this blog, we’ll break down what Throwable is, its hierarchy, and how it works in a simple and clear way.

What is Throwable?

In Java, Throwable is the root class of all errors and exceptions.
In simple terms, anything that can be thrown using the throw keyword must be a subclass of Throwable.

1. Error (Serious Problems)

Error represents serious issues at the JVM level.

These are usually not recoverable and should not be handled in normal applications.

Examples:

OutOfMemoryError
StackOverflowError

Note: Catching Errors is generally not recommended.

2. Exception (Recoverable Issues)

Exception represents problems that can occur in your program and can be handled.

Types of Exceptions:

1.Checked Exceptions

Checked at compile-time
Must be handled using try-catch or throws

Examples:

IOException
SQLException

2.Unchecked Exceptions (Runtime Exceptions)
Occur at runtime
Handling is optional

Examples:

NullPointerException
ArithmeticException

Example Code

public class Test {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (Exception e) {
            System.out.println("Error occurred: " + e.getMessage());
        }
    }
}

throw vs throws
throw

Used to explicitly throw an exception

throw new IllegalArgumentException("Invalid value");

throws

Used in method declarations to specify exceptions

public void readFile() throws IOException {
}

Real-Life Analogy

Think of an application:

System crash → Error
Invalid user input → Exception

Conclusion
Throwable→ Root class
Error → Serious, unrecoverable issues
Exception → Recoverable issues
Exceptions → Checked and Unchecked

To become a strong Java developer, understanding Exception Handling is essential—and Throwable is the foundation of it.

Exception Handling in Java – Complete Guide for Beginners

Jayashree — Wed, 01 Apr 2026 13:33:29 +0000

Exception handling

Exception handling is one of the most important concepts in Java. It helps developers manage runtime errors gracefully without crashing the program.

What is an Exception?

An exception is an unexpected event that occurs during program execution and disrupts the normal flow.

Example:

int a = 10;
int b = 0;
int result = a / b; // ArithmeticException

Why Exception Handling?

Without exception handling:

Program will terminate abruptly
User experience becomes poor

With exception handling:

Program continues execution
Errors can be handled properly

Types of Exceptions in Java

1. Checked Exceptions

Checked at compile-time
Must be handled using try-catch or declared using throws

Examples:

IOException
SQLException

2. Unchecked Exceptions

Occur at runtime
Not mandatory to handle

Examples:

ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException

Exception Handling Keywords

1. try

Wrap the code that may cause an exception.

2. catch

Handles the exception.

3. finally

Always executes (used for cleanup).

4. throw

Used to explicitly throw an exception.

5. throws

Declares exceptions in method signature.

Basic Syntax

try {
    // risky code
} catch (Exception e) {
    // handling code
} finally {
    // cleanup code
}

Example Program

class Example {
    public static void main(String[] args) {
        try {
            int num = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        } finally {
            System.out.println("Execution completed");
        }
    }
}

Multiple Catch Blocks

try {
    int arr[] = new int[5];
    arr[10] = 50;
} catch (ArithmeticException e) {
    System.out.println("Arithmetic Error");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Array Index Error");
}

throw Keyword Example

throw new ArithmeticException("Manual Exception");

throws Keyword Example

void readFile() throws IOException {
    // code
}

Conclusion

Exception handling in Java ensures that your program runs smoothly even when errors occur. Mastering this concept is essential for building robust and reliable applications.

👉 In short:
Exception handling = Handling errors without stopping the program

Types of Exceptions in Programming

Jayashree — Tue, 31 Mar 2026 06:12:51 +0000

Types of Exceptions in Programming

Exception handling is an important concept in programming that helps manage errors during program execution. Instead of crashing, a program can respond to problems in a controlled way. Understanding the types of exceptions makes it easier to write reliable and maintainable code.

What is an Exception?

An exception is an abnormal condition that occurs during the execution of a program. It interrupts the normal flow of instructions and must be handled properly to avoid program failure.

Types of Exceptions

1. Checked Exceptions

Checked exceptions are those that are detected at compile time. These are mainly used in languages like Java. The programmer is required to handle these exceptions, either using try-catch blocks or by declaring them with the throws keyword.

Examples:

FileNotFoundException
IOException

If these exceptions are not handled, the program will not compile.

2. Unchecked Exceptions

Unchecked exceptions occur at runtime and are not checked during compilation. These usually happen due to logical errors in the program.

Examples:

ArithmeticException (divide by zero)
NullPointerException
ArrayIndexOutOfBoundsException

These exceptions can be handled, but it is not mandatory.

3. Built-in Exceptions

Built-in exceptions are predefined exceptions provided by programming languages. They cover common error scenarios and make error handling easier.

Examples (Python):

ValueError
TypeError
IndexError
ZeroDivisionError
FileNotFoundError

4. User-defined Exceptions

User-defined exceptions are custom exceptions created by programmers to handle specific situations in their applications. This improves code clarity and allows better control over errors.

Example (Python):

class MyException(Exception):
    pass

raise MyException("Custom error occurred")

Conclusion

Exceptions are an essential part of modern programming. By understanding the different types of exceptions—checked, unchecked, built-in, and user-defined—developers can write programs that are more robust and less prone to unexpected crashes. Proper exception handling ensures smooth execution and better user experience.

what is Exception?

Jayashree — Sat, 28 Mar 2026 06:16:32 +0000

Exception

The term Exception is shorthand for the phase "Exceptional event"(Unexcepted event).
An Exception is an Event. Which occurs during the execution of a program that disrupt the normal flow of the programs instructions.
Exceptions are done at runtime.

int a = 10;
int b = 0;
int c = a / b;  // Exception occurs here

Output:
ArithmeticException: / by zero

Common Types of Exceptions

ArithmeticException → divide by zero
NullPointerException → accessing null object
ArrayIndexOutOfBoundsException → invalid array index
NumberFormatException → invalid number format

Static vs Non-Static Variables in Java – Complete Guide (With Example)

Jayashree — Wed, 11 Feb 2026 09:16:05 +0000

One of the most common confusions for Java beginners is understanding the difference between static and non-static variables.

In this blog, we’ll cover:

Types of variables in Java
What is a static variable?
What is a non-static variable?
A real-time example
Memory behavior
Interview-ready explanation

Let’s get started

Types of Variables in Java

Java mainly has three types of variables:

Local Variable

Declared inside a method, constructor, or block
Accessible only within that method
Destroyed once the method execution ends

Example:

public void display() {
    int x = 10;   // Local variable
}

Static Variable (Class Variable)

Declared using the static keyword
Belongs to the class, not the object
Only one copy is shared among all objects

Non-Static Variable (Instance Variable or Object Variable)

Declared inside a class but outside any method
Belongs to an object
A separate copy is created for each object

Example Program

public class Institute {

    static String name = "Payilagam"; // static variables
    static String address = "Velachery";

    String course_name; // Non-static variables
    int course_fees;
    String class_duration;

    public static void main(String args[]) {

        System.out.println(Institute.name);
        System.out.println(Institute.address);
        System.out.println();

        Institute java = new Institute();
        java.course_name = "Java";
        java.course_fees = 23000;
        java.class_duration = "3 Months";

        Institute python = new Institute();
        python.course_name = "Python";
        python.course_fees = 22000;
        python.class_duration = "2 Months";

        System.out.println("Course Name: " + java.course_name);
        System.out.println("Course Fees: " + java.course_fees);
        System.out.println("Course Duration: " + java.class_duration);

        System.out.println();

        System.out.println("Course Name: " + python.course_name);
        System.out.println("Course Fees: " + python.course_fees);
        System.out.println("Course Duration: " + python.class_duration);
    }
}

Static Variable Explained

static String name = "Payilagam";
static String address = "Velachery";

Key Points:

Belongs to the class
Only one copy exists in memory
Shared by all objects
No need to create an object to access it

Accessing Static Variables:

Inside the same class, a static variable can be accessed in two ways:

System.out.println(name);           // Works
System.out.println(Institute.name); // Also works

Both are valid. However, using the class name is considered a good practice.

Why?

It clearly shows that the variable belongs to the class, not to an object.
It improves code readability.
It avoids confusion with local or instance variables.
It follows Java coding standards.

Best Practice:

Always access static variables using:

ClassName.variableName

Even though both ways work, using the class name makes your code cleaner and more professional.

Non-Static Variable Explained

String course_name;
int course_fees;
String class_duration;

Key Points:

Belongs to the object
Each object has its own copy
Requires object creation to access

Example:

Institute java = new Institute();
java.course_name = "Java";

Memory Concept (Important for Interviews)

Static Variables:

Loaded into memory when the class is loaded
Only one copy exists

Non-Static Variables:

Loaded into memory when an object is created
Each object has its own copy

Real-Life Analogy

Institute Name → Common for all courses → Static
Course Details → Different for each course → Non-Static

If data is common → Use static
If data is unique per object → Use non-static

Interview One-Line Answer

A static variable belongs to the class and is shared by all objects, while a non-static variable belongs to an object and each object has its own separate copy.

Conclusion

Use static variables when the data is common across all objects.
Use non-static variables when the data should be unique for each object.

Understanding this concept clearly will strengthen your foundation in Java and OOPS.

Understanding Data Types in Java: A Complete Guide

Jayashree — Sat, 07 Feb 2026 10:00:56 +0000

Java is a strongly-typed programming language, which means every variable must have a data type.

What is Datatype?

In Simple, Data types are the types of data.
Data types tell the compiler what kind of value a variable can hold and how much memory it will consume.

Syntax:

datatype variable_name = data;

Example:

int number = 10;
float decimal = 14.7f;

In Java, data types are mainly divided into two categories: Primitive and Non-Primitive (Reference).

1. Primitive Data Types

Primitive data types are the basic building blocks in Java. There are 8 primitive types:

Primitive data types store actual values and are fast in execution.

2. Non-Primitive (Reference) Data Types

Non-primitive data types are also called reference types because they store the memory address of an object instead of the actual value.

Common non-primitive types:

String: Text data

String name = "Hello Java";

Arrays: Store multiple values of same type

int arr[] = {1, 2, 3};

Classes and Objects: Store complex data

Student s = new Student();

etc..

Reference types can be null and size depends on the object.

Simple analogy:

Primitive → The box contains the candy directly.

Non-Primitive → The box contains a map/address; you follow it to get the candy.

DEV Community: Jayashree

Java File Handling Examples – Logging, File Copy, and Finding Maximum Marks

1. Writing Logs into Separate Files

Key Idea:

Code:

Output:

2. Copying Data from One File to Another

Key Idea:

Code:

Output:

3. Finding Maximum Mark and Writing to File

Key Idea:

Code:

Output:

Conclusion

Understanding File Handling in Java (FileReader, FileWriter, BufferedReader & More)

Java File Handling Made Easy: Learn File Class Methods Step by Step

File Handling in Java – Complete Guide

What is File Handling?

Important Classes in Java File Handling

1. Creating a File

2. Writing to a File

3. Reading from a File

4. Deleting a File

Exception Handling in File Handling

Advantages of File Handling

Conclusion

Common Runtime Exceptions in Java (With Examples & Handling)

Exception Handling in Java: 5 Important Keywords (With Examples)

1. try

Definition:

Example:

2. catch

Definition:

Example:

3. finally

Definition:

Example:

4. throw

Definition:

Syntax:

Example:

Uses of throw

1. Input Validation

2. Business Logic Validation

3. Custom Error Handling

5. throws

Definition:

Syntax:

Example:

Uses of throws

1. Delegating Exception Handling

2. Cleaner Code

3. Required for Checked Exceptions

Real-Time Example

Banking Scenario:

File Handling Scenario:

Quick Summary Table

Conclusion

What is Throwable in Java? A Complete Guide

Exception Handling in Java – Complete Guide for Beginners

What is an Exception?

Example:

Why Exception Handling?

Types of Exceptions in Java

1. Checked Exceptions

2. Unchecked Exceptions

Exception Handling Keywords

1. try

2. catch

3. finally

4. throw

5. throws

Basic Syntax

Example Program

Multiple Catch Blocks

throw Keyword Example

throws Keyword Example

Conclusion

Types of Exceptions in Programming

Uses of `throw`

Uses of `throws`