DEV Community: SILAMBARASAN A

File handling in java

SILAMBARASAN A — Fri, 05 Jun 2026 13:01:47 +0000

in java, file handling means working with files like create, read, write, update, deleting them.

it helps to store program informations, if needed it can access after program executed also.

why file handling needed?

to store data permanently instead of keeping only on the memory.
to read and write files from/to for later use.
to share data between different program or system.
to organize and manage large data efficiently.

to support file handling, java provides The File class in the java.io Package.

file handling class File, FileReader, FileWriter, BufferedReader, BufferedWriter.

1. File class
File class is used to represent a file or directory path in java.

The File class can:

Create file and directories
check whether a file exists
Get file information(name, size, path, etc)
delete file and directories

note: File class does not contains read or write.

import java.io.File;

public class Practice {
    public static void main(String[] args) {
        File file = new File("sample.txt");
        file.createNewFile();
    }
}

common File class methods :

createNewFile()
exists()
delete()
isFile()
getName()
getPath()
list()
getAbsolutePath()
getCanonicalPath()

getAbsolutePath() → Returns full path as it is.
getCanonicalPath() → Returns simplified real path by removing . and .. .

2. FileWriter Class

in java, filewriter is a stream class. it is used to write text data for file.

Why File Writer?

write data in text file
update existing file
create new file and write

Constructor
1. Write Mode

FileWriter fw = new FileWriter("sample.txt");

Delete existing data and write new data.

2. Append Mode

FileWriter fw = new FileWriter("sample.txt", true);

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

class Main {
    public static void main(String[] args) throws IOException {

        FileWriter fw = new FileWriter("sample.txt");

        fw.write("Hello Java");

        fw.close();

        System.out.println("Data Written");
    }
}

old data will can't delete and new data will add on the end of the old data.

Methods
write(String s) => used to write string
write(int c) => write single character
flush() => buffers data send yo file
close() => close the file

3. BufferedWriter Class

in java , BufferedWriter first data store in buffer then one times write in file.

Advantage

Faster then FileWriter
good for write Large amount of data
is there newLine() method

import java.io.*;

class Main {
    public static void main(String[] args) throws Exception {

        BufferedWriter bw =
            new BufferedWriter(new FileWriter("sample.txt"));

        bw.write("Hello Java");
        bw.newLine();
        bw.write("Welcome");

        bw.close();

        System.out.println("Data Written");
    }
}

4. FileReader Class

FileReader is a character stream class. it is used to read characters from the text file.

why FileReader?

read data from text file
read character by character
it is commonly used for read text files (.txt)

Constructor

FileReader fr = new FileReader("sample.txt");

sample.txt file open in read mode.

important methods
read() => read one character
close() => file will close

import java.io.FileReader;

class Main {
    public static void main(String[] args) throws Exception {

        FileReader fr = new FileReader("sample.txt");

        int ch = fr.read();

        System.out.println((char) ch);

        fr.close();
    }
}

How read() Works

int ch = fr.read();

if read find the character return that ASCII/Unicode value.
if finds the end, return -1.

5. BufferedReader Class

BufferedReader is used to read text fastly from the text file.

Why BufferedReader?

File read line by line.
speed better then FileReader.
better for read large file.
is there readLine() method.

Important Methods

read() => read one character
readline => read one line
close() => close the Stream

import java.io.*;

class Main {
    public static void main(String[] args) throws Exception {

        BufferedReader br =
            new BufferedReader(new FileReader("sample.txt"));

        String line=br.readLine();

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

        br.close();
    }
}

why object is passed as arguments in java, throws in java,

SILAMBARASAN A — Fri, 29 May 2026 08:13:03 +0000

objects are passed as arguments to allow methods to access and manipulate data that belongs to those objects. While Java is technically always "pass-by-value," when you pass an object, you are actually passing a copy of the reference (the memory address) to that object.

throws in java

throws is a keyword in Java used in a method declaration to specify the exceptions that the method may throw, allowing the caller to handle those exceptions. The caller to these methods has to handle the exception using a try-catch block.

Declares possible exceptions.
Mainly used with checked exceptions.

Scanner class methods in java

Scanner class is used for get data from the user using console.

*the package *

import java.util.Scanner;

creating scanner class object

Scanner sc = new Scanner(System.in);

Scanner → Class name
sc → Object name
System.in → Standard input stream (keyboard)

scanner class have different methods for taking data in different data type.

boolean => nextBoolean()
byte => nextByte()
double => nextDouble()
float => nextFloat()
int => nextInt()
long => nextLong()
short => nextShort()
String => nextLine()

exception in Java

SILAMBARASAN A — Thu, 21 May 2026 18:34:34 +0000

In Java, an exception is an unexpected event that occurs during program execution and interrupts the normal flow of the program.

When an exception occurs, Java creates an object that contains information about the error. This object is called an Exception Object.

Instead of terminating the program immediately, Java provides a mechanism called Exception Handling to manage these situations gracefully.

public class Main {
    public static void main(String[] args) {

        int a = 10;
        int b = 0;

        int result = a / b;

        System.out.println(result);
    }
}

Output
Exception in thread "main" java.lang.ArithmeticException: / by zero

try and catch

The risky code is written inside the try block, and the exception is handled inside the catch block.

public class Main {
    public static void main(String[] args) {

        int a = 10;
        int b = 0;

        try {
            int result = a / b;
            System.out.println(result);
        }

        catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program continues...");
    }
}

Output

Cannot divide by zero Program continues...

String In Java

SILAMBARASAN A — Wed, 20 May 2026 09:53:56 +0000

String:
A String in java is a object to store a sequence of characters,
enclosed in double quotes. String is class in java.

String is immutable in Java.

Why : in Java Create once, can't modified.

can't modified means. String age = 19; once age assigned 19. java create memory for that data 19. age reference pointing 19. if you change age = 20; . java doesn't not show error. because, immutable means java create new memory for data 20. now age reference pointing new memory 20. exactly immutable means can't modify existing memory, whenever change value String, that's create new memory.

String in java package Java.lang.

package => package is group of multiple related classes.

In java you can create string in two ways :

1. using String literal
if string create using literal, those datas will store in scp (String constant pool) memory.

String name="Silambarasan";

using new keyword

if string create using new keyword those datas will store in heap memory.


String obj1 = new String();

the heap and String constant pool are two different memory in java.

Heap

A heap in Java is a memory area used to store objects and instance variables during program execution.
It is created when the Java Virtual Machine (JVM) starts.
It is shared among all threads and managed automatically by the Java Garbage Collector.
Heap is a memory area in Java where object created using the new keyword are stored.

Example

new Student()
new Car()
new String()

Java usually creates the object in heap memory.

Then What Stores in Stack?

Stack stores:

local variables
method calls
reference variables

Example

int a = 10;

a directly stores value in stack because it is a primitive datatype.

String constant pool

It is a special memory area inside the heap where Java stores string literals to save memory.

Why SCP is Used

Reduces memory usage
Improves performance
Avoids creating duplicate string objects.

How it works (scp) :

If String create using Literals String name1 = "simbu"; , java will create memory for "simbu" in scp. name1 pointing "simbu" in scp. now we create name2 = "simbu", java did't create memory for that, because if same ("simbu") data already in scp, that reference (name2) pointing the existing memory.

Interface in Java

SILAMBARASAN A — Thu, 14 May 2026 12:09:36 +0000

An interface in Java is a blueprint of a class.

It contains:

method declarations
constants

But usually it does not contain full method implementation.

Interface tells:

What to do
not
How to do

Syntax

interface Animal {

    void sound();

}

Here:

Animal is interface
sound() has no body

Implementing Interface

class Dog implements Animal {

    public void sound() {
        System.out.println("Bark");
    }

}

implements keyword is used.

Why use Interface?

1. Achieve Abstraction

Hide internal details.

void sound();

Only rule is given.

2. Multiple Inheritance

Java does not support:

class A extends B, C

But interface allows multiple inheritance.

interface A {}
interface B {}

class Test implements A, B {}

Variables in interface are:

Automatically:

public static final

Example:

interface Test {

    int x = 10;

}

Same as:

public static final int x = 10;

Methods are automatically:

public abstract

Abstract In Java

SILAMBARASAN A — Wed, 13 May 2026 18:12:30 +0000

In Java, abstract means incomplete.

It is used when a class or method is not fully finished and child classes must complete it.

Abstract Class

A class declared with abstract keyword is called an abstract class.

abstract class Animal {
}

Cannot create object directly
Mostly used as parent class

Animal a = new Animal(); // ❌ Error

Abstract Method

An abstract method has:

only declaration
no body

abstract void sound();

Child class must implement it.

Example

abstract class Animal {
    abstract void sound();
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

Here:

Animal gives only idea
Dog completes the method

Simple Real-Life Example

Think about a “Vehicle”.

All vehicles move, but:

Car moves differently
Bike moves differently

So parent class says:

abstract void move();

Child classes define how they move.

final keyword in java?

SILAMBARASAN A — Wed, 13 May 2026 05:28:58 +0000

In Java, the final keyword is used to stop changes.
It can be used with variables, methods, and classes.

If a variable is final, its value cannot be changed.
If a method is final, it cannot be overridden.
If a class is final, it cannot be inherited.

1. Final Variable

A final variable can only be assigned once.

final int x = 10;
x = 20; //  Error: cannot change value

Acts like a constant
Must be initialized once (either at declaration or in constructor)

2. Final Method

A final method cannot be overridden by subclasses.

class Parent {
    final void show() {
        System.out.println("Final method");
    }
}

class Child extends Parent {
    void show() { //  Error
        System.out.println("Cannot override");
    }
}

3. Final Class

A final class cannot be inherited (extended).

final class Animal {}

class Dog extends Animal { //  Error
}

Example:

String class in Java is final

Pojo in Java

SILAMBARASAN A — Tue, 12 May 2026 07:19:51 +0000

POJO in Java – What and Why?

In Java, POJO stands for Plain Old Java Object.

A POJO is a simple Java class that is not dependent on any special framework, API, or technology.

It is mainly used to store and manage data in a clean and organized way.

What is a POJO?

A POJO class usually contains:

Private variables (fields)
Getter and Setter methods
Constructors
Optional business methods

Example of a POJO Class

public class Student {

    private int id;
    private String name;

    // Default Constructor
    public Student() {
    }

    // Parameterized Constructor
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getter
    public int getId() {
        return id;
    }

    // Setter
    public void setId(int id) {
        this.id = id;
    }

    // Getter
    public String getName() {
        return name;
    }

    // Setter
    public void setName(String name) {
        this.name = name;
    }
}

This is called a POJO class because:

It is a normal Java object
No framework dependency
Used mainly for storing data

Why Do We Use POJO?

1. To Store Data Properly

Instead of using many separate variables:

int id = 1;
String name = "Silambu";

We group them into one object:

Student s = new Student();

This makes code cleaner and easier to manage.

2. Improves Code Readability

POJO helps organize related data together.

Without POJO:

id, name, age, address

With POJO:

Student object

Easy to understand.

3. Reusability

One POJO class can be reused in:

Controllers
Services
Database operations
APIs
JSON conversion

4. Easy Database Mapping

Frameworks like:

Hibernate
JPA
Spring Boot

use POJO classes to map database tables into Java objects.

Example:

Database Column	POJO Field
student_id	id
student_name	name

5. Easy JSON Conversion

POJO objects can easily convert to:

JSON
XML

Example:

{
  "id": 1,
  "name": "Silambu"
}

Real-Life Example

Think of a POJO like a student form.

A form contains:

Name
Age
Roll Number

Similarly, a POJO stores related data together inside one class.

Important Characteristics of POJO

A POJO:

Does not extend special classes
Does not implement unnecessary interfaces
Has private fields
Uses getters/setters
Is simple and independent

POJO vs Normal Variable

Normal Variables

String name;
int age;

Data is separate.

POJO

Student s;

All related data is grouped together.

Method Overriding in Java

SILAMBARASAN A — Tue, 05 May 2026 18:58:23 +0000

Overriding is a feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its super-classes or parent classes.
When a method in a subclass has the same name, same parameters or signature, and same return type(or sub-type) as a method in its super-class, then the method in the subclass is said to override the method in the super-class.
Method overriding is one of the way by which java achieve Run Time Polymorphism.

Usage of Java Method Overriding

Method overriding is used to provide the specific implementation of a method which is already provided by its superclass.
Method overriding is used for runtime polymorphism.

Rules for Java Method Overriding

The method must have the same name as in the parent class.
The method must have the same parameter as in the parent class.
There must be an IS-A relationship (inheritance).

What Cannot Be Overridden?

Static Methods: You cannot override static methods; defining a same-named static method in a subclass is called "method hiding".
Final Methods: Methods declared with the final keyword cannot be overridden.
Private Methods: Since private methods are not inherited, they cannot be overridden.
Constructors: Constructors are unique to their own class and cannot be overridden.

class Animal {
   protected void displayInfo() {
      System.out.println("I am an animal.");
   }
}

class Dog extends Animal {
   public void displayInfo() {
      System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
      Dog d1 = new Dog();
      d1.displayInfo();
   }
}

Java Inheritance

SILAMBARASAN A — Sat, 02 May 2026 05:29:21 +0000

In Java, it is possible to inherit attributes and methods from one class to another. We group the "inheritance concept" into two categories:

subclass (child) - the class that inherits from another class
superclass (parent) - the class being inherited from

To inherit from a class, use the extends keyword.

In the example below, the Car class (subclass) inherits the attributes and methods from the Vehicle class (superclass):

Superclass (Parent): The class whose features are inherited
Subclass (Child): The class that inherits features

class Parent {
    void show() {
        System.out.println("This is parent class");
    }
}

class Child extends Parent {
    void display() {
        System.out.println("This is child class");
    }
}

public class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show();    // inherited method
        obj.display(); // own method
    }
}

Types of Inheritance in Java

Java supports these types:

1. Single Inheritance

One class inherits from one class

class A {}
class B extends A {}

2. Multilevel Inheritance

A chain of inheritance

class A {}
class B extends A {}
class C extends B {}

3. Hierarchical Inheritance

Multiple classes inherit from one parent

class A {}
class B extends A {}
class C extends A {}

Java Packages

SILAMBARASAN A — Tue, 21 Apr 2026 06:32:08 +0000

A package in Java is used to group related classes. Think of it as a folder in a file directory. We use packages to avoid name conflicts, and to write a better maintainable code. Packages are divided into two categories.

Built-in Packages (packages from the Java API)
User-defined Packages (create your own packages) The Java API is a library of prewritten classes, that are free to use, included in the Java Development Environment.

Built-in Packages

The library contains components for managing input, database programming, and much much more. The complete list can be found at Oracles website: https://docs.oracle.com/javase/8/docs/api/.

User-defined Packages

To create your own package, you need to understand that Java uses a file system directory to store them. Just like folders on your computer.

java.lang: This package holds the foundational classes.
java.io: It handles all sorts of input and output operations.
java.awt: This package provides the basic building blocks for creating graphical user interfaces (GUIs).
javax.swing: It is best for more advanced and richer desktop application GUIs due to its comprehensive toolkit.
java.net: It contains classes essential for developing network-aware applications.
java.util: It is a versatile package filled with utility classes, including the powerful Collections Framework.
java.applet: This package includes classes for building applets, which are small applications designed to run in web browsers (though less common now).
java.sql: Here you will find the classes for interacting with databases and processing relational data. above the all to be discussed.

User-defined packages

User-defined packages in Java are not readily available, as their name suggests. These are created by developers to define interfaces and classes according to the application requirements. It is defined using a unique syntax as shown below:


package packageName;

You can see the package keyword in its syntax, it defines the package name. It is important to declare the package just before any import statements of a Java class. It is also important to ensure that all the classes are public so that you can access them from both inside and outside the package.

Java basic program

SILAMBARASAN A — Mon, 20 Apr 2026 03:02:38 +0000

this program helps me to understand Object, method, constructor.

class Dmart{ 

String product_name;
int product_price;
int product_discountpercentage;
int product_discountprice;
int finalprice;


public Dmart(String name ,int price ,int discountpercentage){

this.product_name=name;
this.product_price=price;
this.product_discountpercentage=discountpercentage;
}


public static void main(String[] args){

Dmart product1=new Dmart("shop" , 50 , 8);
Dmart product2=new Dmart("chips" , 30 , 5);
Dmart product3=new Dmart("Choclate" , 200 , 2);
Dmart product4=new Dmart("Biscut"  ,  15 , 7);
Dmart product5=new Dmart("HotChips" , 25 , 12);

product1.buy();
product2.buy();
product3.buy();
product4.buy();
product5.buy();

}
public void buy(){

this.product_discountprice = (this.product_price * this.product_discountpercentage) / 100;
this.finalprice=this.product_price-this.product_discountprice;

System.out.println("productname => "+ this.product_name);
System.out.println("proprice => " + this.product_price);
System.out.println("prodiscountpercentage => " + this.product_discountpercentage);
System.out.println("discountprice => " + this.product_discountprice);
System.out.println("finalprice => " + this.finalprice);

}

}