DEV Community: Kathirvel S

Interface in Java - Just like Abstract or What?

Kathirvel S — Mon, 15 Jun 2026 13:53:50 +0000

Welcome back!

in Today's class at my institute

starting of the class

I asked an one question

which is

"why abstract and when to use them in realtime?"

Then my trainer answered for this

with clean explaination

so let's see what my trainer answered for that

Answer from trainer - Why abstraction

Trainer started with one question

"which databases can we connect with the java"

every trainee's answer comes with the different answer

me and my trainees are almost covered all the databases we know

"PostgreSql, MySql , MongoDb, Oracle Db"

then the trainer answered with

Yes, we can connect with java with these database

but the for these database can differ from there behaviour right?

but java is sets one common protocol for databse conectivity

you have to difinetly write some essential methods

which is not written by java

but you have to definetly write these methods (override)

to connect with java for these databases

for these reasons abstraction is useful

from this i have got clear idea about why abstraction

Let's begin - Interface in java

An interface in Java is a blueprint that defines a set of methods a class must implement without providing full implementation details.

It helps achieve abstraction by focusing on what a class should do rather than how it does it.

Interfaces also support multiple inheritance in Java.

A class must implement all abstract methods of an interface.
All variables in an interface are public, static, and final by default.
Interfaces can have default, static, and private methods (Java 8+ and 9+).

Example:

Defines constants and abstract methods, which are implemented by a class.

public interface Company{

    int number=10;

    public void takeLeave(){

    }

    public void getSalary(){

    }
}

output:

so here proved that

interface abstract methods

sholdn't have method body

now let's remove method body

public interface Company{

    int number=10;

    public void takeLeave();

    public void getSalary();


}

now compiles without any error

ok, now try to access these methods and override them

in abstraction class

we simple used extends keyword to acces methods and override them

but in the interface

going to use the implements keywords

both are doing the same thing in high level

let's use it

public class Employee implements Company{


    public void takeLeave(){
        System.out.println("8 days");
    }

    public void getSalary(){
        System.out.println("20,000");
    }

    public static void main(String[] args){
        Employee emp=new Employee();



        emp.takeLeave();


    }
}

output:

8 days

now the output is showing with the method execution

ok now can check that the variable is defaultly with the final and static keyword

public interface Company{

    int number=10;

    public void takeLeave();

    public void getSalary();




}

public class Employee implements Company{



    public static void main(String[] args){
        Employee emp=new Employee();



        emp.number=20;

        System.out.println(number);
    }
}

here we are tried to change that variable in interface

output

but the output is clearly says that

we can't assign a value to static final variable

hence here proved that the

interface defaultly give a variable to a

final and static keyword

now the one question comeup

it's like abstract class

in abstract we can give all the things explicitly

is the interface and abstract both are same ?

let's clear that

in abstract class we can't create object

but by using inherit

we can create a object for child class

like that

we can create object for interface

but by using implements keyword

in child the objects can act as object for the interface too

but while creating object

one thing automatically generated

you

guessed it

right?

yes it's constructor

constructor creation is possible in subclass of interface

but in abstract class it's not possible

hope u got clear

Takeaways

Abstraction is used to define a common contract that different classes must follow.
Real-world examples include database connectivity, where different databases such as PostgreSQL, MySQL, Oracle, and MongoDB provide their own implementations while following a common Java contract.
An interface specifies what a class should do rather than how it should do it.
Methods declared in an interface without a body are abstract methods and must be implemented by the class that implements the interface.
A class uses the implements keyword to inherit the contract defined by an interface.
Interface variables are public static final by default, making them constants.
Since Java 8, interfaces can contain default and static methods.
Since Java 9, interfaces can also contain private methods.
Interfaces help achieve abstraction, loose coupling, and code flexibility.
A class can implement multiple interfaces, which provides a form of multiple inheritance in Java.
Interfaces and abstract classes both support abstraction, but:
- An interface focuses on defining behavior (contract).
- An abstract class can define both behavior and partial implementation.
You cannot create an object directly from an interface, but you can create an object of a class that implements the interface and store it in an interface reference.

Simple Rule to Remember

Use an interface when you want to define a common contract that multiple classes must follow.
Use an abstract class when you want to share common code and behavior among related classes.

This is the core reason interfaces are heavily used in frameworks, database drivers, APIs, and enterprise Java applications.

hope u catchup a topic i covered in this blog

see you on next blog

thank you !

Reference:

interface in java:

https://www.geeksforgeeks.org/java/interfaces-in-java/

OOPS: Abstraction in Java

Kathirvel S — Fri, 12 Jun 2026 13:19:35 +0000

Today we are going to explore

the concept of oops in java

"abstraction"

by the end of this blog U have a clear idea about this concept

let's begin

Before dive in to

before directly jumping into abstraction concept

We have set some essential fuondation for it

so let's know about the

"final" --- keyword

The final keyword in java

In Java, the final keyword is used to restrict changes and make code more secure and predictable.

It can be applied to variables, methods, and classes to prevent modification, overriding, or inheritance.

This helps in creating constant values, stable methods, and immutable classes.

Final variable cannot be changed once assigned
Final method cannot be overridden
Final class cannot be inherited (we can't create child class)

look at this

here we are reassigning variable final

class Parent {
    static final int CAPACITY = 4;

    public static void main(String[] args) {
        CAPACITY = 5; 
    }
}

Output:

it throws a compile time error

we cant change it again when intialization is done already

Local Final Variable

A local final variable must be assigned once.


class Geeks {
    public static void main(String[] args) {
        final int i;
        i = 20;
        System.out.println(i);
    }
}

Output

here we got 20 bcz the variable with final keywrod must be intialized once

Final class

A class declared as final cannot be extended.

A final class cannot be inherited, meaning no other class can extend it.

This is commonly used for security or when the implementation should remain unchanged, such as in core classes like String.

Prevents inheritance, ensuring the class behavior cannot be modified
Commonly used for immutable and secure classes

final class A {
    // fields and methods
}

// Illegal
class B extends A { }

Here the final class A can't be extended

Final classes are useful when creating immutable classes such as String or wrapper classes.

Final Method:

When a method is declared with final keyword, it is called a final method in Java.

A final method, on the other hand, can be inherited but cannot be overridden by subclasses, ensuring that the original implementation remains intact.

Cannot be overridden in subclasses
Helps maintain consistent behavior across all derived classes

class A {
    final void m1() {
        System.out.println("Final method");
    }
}

class B extends A {
    void m1() { } // compile-time error
}

OUtput:

here m1() method can't be overriden

Advantages of final Keyword

Supports immutability by preventing reassignment
Helps compiler and JVM optimize code in some scenarios
Makes behavior predictable since values or methods stay unchanged
Prevents accidental or unauthorized modification of critical logic
Preserves API contracts by avoiding unwanted overriding

Hope u got a clear vision about the "final" keyword

Gettin to Abstraction concept:

Abstraction in Java is the process of hiding internal implementation details and showing only essential functionality to the user.

It focuses on what an object does rather than how it does it.

It hides the complex details and shows only essential features.
Abstract classes may have methods without implementation and must be implemented by subclasses.
By abstracting functionality, changes in the implementation do not affect the code that depends on the abstraction

We can achieve abstraction in java

in two way

One is by using interface

and

another one is by using abstract

in this blog

i am going to achieve this by Abstract class

let see example for this

public class Parent{

    public void study();

    public static void main(String[] args){

        Parent parent=new Parent();
        parent.study();
        System.out.println();
    }

}

when we compile this

the output will be

it clearly says missing method body

declare a method as a abstract

So now let give as abstract for the method

public class Parent{

    public abstract void study();

    public static void main(String[] args){

        Parent parent=new Parent();
        parent.study();
        System.out.println();
    }

}

here again one more error

let's read it properly

now it's too clearly says that

if the class have a one abstract method

the same class must have written as abstract

So let's declare the class with abstract keyword

public abstract class Parent{

    public abstract void study();

    public static void main(String[] args){

        Parent parent=new Parent();
        parent.study();
        System.out.println();
    }

}

output:

in this too

the error clearly says

if the class is abstract

the class shouldn't have the object
(cannot be instantiated)

in the same class only the object creation is not possible right?

so let's inherit from another class

now create a child class to access study()

Parent.java file

public abstract class Parent{

    public abstract void study();

    public void spending(){
        System.out.println("parent spending ");
    }

    public static void main(String[] args){



        System.out.println();
    }

}

Child.java file

public class Child extends Parent{
    public static  void main(String[] args){
        Child child = new Child();
        child.spending();
        System.out.println();
    }
}

output

now error says that

in Child class you are accesing the abstract method from the parent class

to access it u must declare your class as an abstract

it simply says

-> u must change your class to abstract

ok let's change our class with the abstract

public abstract class Child extends Parent{
    public static  void main(String[] args){
        Child child = new Child();
        child.study();
        System.out.println();
    }
}

now again same error occurs

it say like before

for the abstract class shouldn't have a object

without object we can't access the static method from another class

i think the java is kidding with we

Fun time

the code is continously playing with we

so now let's play with this

we have learnt about final keyword right

let's implement it now

the question comesup can we declare final and abstract keyword together is this possible

public abstract class Parent{

    public final abstract void study();

    public void spending(){
        System.out.println("parent spending ");
    }

    public static void main(String[] args){



        System.out.println();
    }

}

output:

here the error

says

these two combinations of modifiers cannot be declared same time

here the when i saw illegal combination in the error

it directly remember one movie dialouge

IN singam movie when the danny is getting arrest

surya says that dialogue to danny

"ILLEGAL ENTRY"

https://www.youtube.com/shorts/QW4tmQYowsE?t=107&feature=share

Sudden stuck

And i stucked in this

why these two keywords cannot declared in same

i asked to intelligence

for clarification

Clarification

the intelligence said that

more thing about it

In Java, final and abstract cannot be used together on the same method because they mean opposite things.

What abstract means

An abstract method:

public abstract void study();

Has no implementation.
Must be overridden by a subclass.

What final means

A final method:


public final void study() {
    System.out.println("Studying");
}

Has an implementation.
Cannot be overridden by subclasses.

Why they conflict

abstract says:

"Subclasses must override this method."

final says:

"Subclasses cannot override this method."

These requirements contradict each other.

It's like saying:

"This door must be opened."

"This door must never be opened."

So Java reports an error.

Rule to remember

abstract = must override / must implement
final = cannot override / cannot change

Only way

By declaring a study() method

in the Child class

The parent class is just abstracted that method

but the Child method can Override it

if didn't know about method override

u can check my blog

link --->

https://dev.to/kathirvel-s/from-super-to-runtime-polymorphism-a-beginners-guide-to-java-inheritance-4lgk

Code:

public class Child extends Parent{

    public void study(){
        System.out.println("Studying Info Tech");
    }
    public static  void main(String[] args){
        Child child = new Child();
        child.study();
        System.out.println();
    }
}

Output:

so the finaly we achieved this by using method overriding

however we've made so many error in this

by reading the error we achieved it

Takeaway:

The simple to remember the concept of abstraction is

by creating any using abstract

we can't access it in same class

but

we can access it from another class using inherit

and by method overriding

so before know about abstraction

we must know about inheritance , method overriding, static and non static and more basic concepts

References:

Final keyword :

https://www.geeksforgeeks.org/java/final-keyword-in-java/

Abstraction in java:

https://www.geeksforgeeks.org/java/abstraction-in-java-2/

OOPS:Encapsulation in Java

Kathirvel S — Fri, 12 Jun 2026 06:21:26 +0000

I apreciate your interest to know about

"Encapsulation in java"

so you clicked this blog to know something about it

I sure that ,at the end of this blog you have some idea about this

without getting delay

let's start

Before Know about This

Before Dive into Encapsulation you have to Know about

Access Modifiers in java

You Go through it on Other resources

(or )

Kindly check out my previous blog for better understand

Here's the link --->

https://dev.to/kathirvel-s/access-modifiers-in-java-the-protection-powerhouse-103m

Let's BreakDown the Name of it

Let's break the word

En Capsule ation

Now Some people got a idea behind by this breakdown

if u not got

let understand clearly

I have searched about it on internet

i have got these paras

The term "encapsulation" comes from the Latin word capsula (meaning "a small box" or "container"),
combined with the prefix en- (meaning "in"). Literally, it means "to put something inside a capsule"

Ref link

Let's Start To Encapsulation In Java

Definition:

Encapsulation in Java is an object-oriented principle that binds data and methods into a single unit, typically a class. It restricts direct access to data by hiding implementation details. This ensures controlled interaction with the data through defined methods.

Achieved using access modifiers like private, protected, and public.
Improves data security by allowing validation through getters and setters.
Enhances code maintainability by isolating changes within the class.

look at this image:

think of it like a setting methods and data inside the capsule

How Encapsulation is Achieved in Java:

Encapsulation in Java is achieved using:

Private data members
Public getter and setter methods

Key Rules:

Declare data as private: Hide the class data so it cannot be accessed directly from outside the class.
Use getters and setters: Keep variables private and provide public getter and setter methods for controlled access and safe modification, often with validation.
Apply proper access modifiers: Use private for data hiding and public for methods that provide access.

class Programmer {

    private String name;

    // Getter method used to get the data
    public String getName() { return name; }

    // Setter method is used to set or modify the data
    public void setName(String name) {

        this.name = name;
    }
}


public class Another {

    public static void main(String[] args){

        Programmer p = new Programmer();
        p.setName("Kathir");
        System.out.println("Name=> " + p.getName());
    }
}

Output

Name=> Kathir

Explanation:

In the above example, we use the encapsulation and use getter (getName) and setter (setName) method which are used to show and modify the private data. This encapsulation mechanism protects the internal state of the Programmer object and allows for better control and flexibility in how the name attribute is accessed and modified.

Advantages of Encapsulation

The advantages of encapsulation are listed below:

Data Hiding: Encapsulation restricts direct access to class variables, protecting sensitive data from unauthorized access.
Improved Maintainability: Changes to internal implementation can be made without affecting external code that uses the class.
Enhanced Security: Encapsulation allows validation and control over data, preventing invalid or harmful values from being set.
Code Reusability: Encapsulated classes can be reused in different programs without exposing internal logic.
Better Modularity: Encapsulation promotes organized, modular code by keeping data and methods together within a class.

Disadvantages of Encapsulation

The disadvantages of encapsulation are listed below:

Increased Code Complexity: Writing getter and setter methods for every variable can make the code longer and slightly more complex.
Performance Overhead: Accessing data through methods instead of directly can introduce a minor performance cost, especially in performance-critical applications.
Less Flexibility in Some Cases: Over-restricting access to class members may limit the ability of other classes to extend or use the class efficiently.

Data Hiding vs Encapsulation

to make more clear idea about data hiding vs encapsulation

See this table

For clarity:

Try to answer these questions

1. What is encapsulation in Java?

A Wrapping data and methods into a single unit

B Allowing multiple forms of a method

C Inheriting properties from a parent class

D Overriding methods from an interface

2. Which benefit does encapsulation provide in Java?

A Increased code reusability

B Improved performance

C Improved code readability

D Improved data security and integrity

3. What is the key difference between Encapsulation and Abstraction in Java?

A Encapsulation is about hiding the details, Abstraction is about showing only essential features.

B Encapsulation is about showing only essential features, Abstraction is about hiding the details.

C Encapsulation uses classes, Abstraction uses interfaces

D There is no difference between Encapsulation and Abstraction.

4. Which of the following best represents encapsulation?

A Inheriting methods from a parent class

B Wrapping data and methods together and restricting direct access

C Using super to call parent methods

D Overriding methods in a child class

Takeaways:

Hope u got a clear idea about this concept

Think a encapsulation like a Sharing the data in capsule like a box or container

and authorized people can modifing data

and some datas never change

Reference:

Encapsulation word breakdown:

https://www.youtube.com/watch?v=s1-j3RKDvzg

Encapsualtion in java:

https://www.geeksforgeeks.org/java/encapsulation-in-java/

for better in depth understanding refer this blog:

https://www.scoutapm.com/blog/what-is-encapsulation

thank you for reading this blog

Practice these

and

Code repeat

Access Modifiers in Java -The Protection PowerHouse

Kathirvel S — Thu, 11 Jun 2026 17:14:10 +0000

Today we are going explore the topic

"Access modifier in java"

let's start now without getting any delay

I have searched in geeksforgeeks site for reference about it

here is the ref link :

https://www.geeksforgeeks.org/java/access-modifiers-java/

Before directly get in to ask why ?

Why Access Modifiers Are Used in Java?

Access modifiers are used to control who can access your data and methods. They help protect the internal details of a class and prevent unintended usage.

Imagine a class as a house:

private ->Only the owner can enter certain rooms.

default -> Only people from the same neighborhood (package) can enter.

protected -> Neighborhood people and family members (subclasses) can enter.

public -> Anyone can enter.

Main Reasons for Using Access Modifiers

1. Encapsulation (Data Hiding)

They hide internal data from direct access.

2. Security

Sensitive data should not be accessible everywhere.

3. Better Control

You decide how data is accessed and modified.

4. Reduce Complexity

Other developers only see what they need to use.

5. Maintainability

You can change internal code without affecting other classes.

here mentioned below was i got answer for that:

Access modifiers in Java are used to control the visibility and accessibility of classes, methods, and variables. They help enforce encapsulation by restricting access to different parts of a program. Java provides four types of access modifiers to define scope and protection levels.

Public modifier: It is accessible from anywhere in the program

Protected modifier: It is accessible within the same package and by subclasses

Private modifier: It is accessible only within the same class

**Default modifier: **It is accessible only within the same package

Private Access Modifier:

The private access modifier is specified using the keyword private.
The methods or data members declared as private are accessible only within the class in which they are declared.


class Person {

    // private variable
    private String name;

    public void setName(String name)  {

        this.name = name; // accessible within class
    }

    public String getName() { return name; }
}

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

        Person p = new Person();
        p.setName("Kathir");

        // System.out.println(p.name); // Error: 'name'
        // has private access
        System.out.println(p.getName());
    }
}

Output:

Kathir

Explanation:

Direct access to name is not allowed outside Person, enforcing encapsulation.

Default Access Modifier

If no access modifier is specified, the member has default (package-private) access and can only be accessed within the same package.This means only classes within the same package can access it.


class Car {
    String model; // default access
}

public class Main {

    public static void main(String[] args){

        Car c = new Car();
        c.model = "Tesla"; // accessible within the same package
        System.out.println(c.model);
    }
}

Output:

Tesla

Explanation:
Members with default access cannot be accessed from classes in a different package.

**Test.java: **Default class within the same package

// default access modifier 
package p1; 

// Class Test is having 
// Default access modifier 
class Geek 
{ 
    void display() 
    { 
        System.out.println("Hello World!"); 
    } 
}

TestNew.java: Default class from a different package (for contrast)

// package with default modifier 
package p2; 
import p1.*;    // importing package p1

// This class is having 
// default access modifier 
class GeekNew { 
    public static void main(String args[]) { 

        // Accessing class Geek from package p1 
        Geek o = new Geek(); 

        o.display(); 
    } 
}

Explanation:

In this example, the program will show the compile-time error when we try to access a default modifier class from a different package.

Protected Access Modifier

The protected access modifier is specified using the keyword protected. The methods or data members declared as protected are accessible within the same package or subclasses in different packages.

// File: Vehicle.java in package p1
package p1;
public class Vehicle {
    protected int speed;
}

// File: Bike.java in package p2
package p2;
import p1.Vehicle;
public class Bike extends Vehicle {
    void showSpeed() {
        speed = 100; // allowed: subclass in different package
        System.out.println(speed);
    }
}

// File: Test.java in package p2
package p2;
import p1.Vehicle;
public class Test {
    public static void main(String[] args) {
        Bike b = new Bike();
        b.showSpeed(); // prints 100

        Vehicle v = new Vehicle();
        // System.out.println(v.speed); // ERROR: cannot access protected outside package & non-subclass
    }
}

Output

Access via subclass method: 100
0

*Explanation: *

speed is accessible via subclass methods and other classes in the same package, but direct access from a different package (non-subclass) would fail.

Public Access Modifier

The public access modifier is specified using the keyword public.
Public members are accessible from everywhere in the program. There is no restriction on the scope of public data members.



class MathUtils { 

    public static int add(int a, int b) {
        return a + b;
    }
}

public class Main {

    public static void main(String[] args) {

        System.out.println(MathUtils.add(5, 10)); // accessible anywhere
    }
}

Output

Explanation:
add() is globally accessible due to the public modifier.

Top-level classes or interfaces can not be declared as private because, private means "only visible within the enclosing class".

Comparison Table of Access Modifiers in Java:

When to Use Access Modifier in Real-World Projects

Private: The idea should be use as restrictive access as possible, so private should be used as much as possible.

Default (Package-Private): Often used in package-scoped utilities or helper classes.

Protected: Commonly used in inheritance-based designs like framework extensions.

Public: This is used for API endpoints, service classes, or utility methods shared across different parts of an application.

Before leave look this and Answer:

Once u answer it claerly u can confirm that u have a clear idea about access modifiers

so try these question to answer

1. Which of the following statements about access modifiers in Java is true?

A
Access modifiers can be used to control the visibility of a class, method, or variable.

B
Access modifiers can only be used with variables.

C
Access modifiers can only be used with methods.

D
Access modifiers can only be used with classes

2. Which access modifiers can be used in Java to control access to class members?

A
public, private, protected, default

B
public, protected, package-private

C
private, protected, package-private

D
public, final, static

3. Which access modifier provides the highest level of access?

A
public

B
private

C
protected

D
default

4. Which access modifier allows access only within the same package?

A
public

B
protected

C
private

D
default (no modifier)

Takeaways:

Hope u got a clear vision about acces modifiers in java

To remember this topic forever look at this

From most restrictive -> least restrictive:

private -> default -> protected -> public

Think:

private = Only Me
default = My Package
protected = My Package + My Children (subclasses)
public = Everyone

References:

Access modifiers in java:

https://www.geeksforgeeks.org/java/access-modifiers-java/

From super() to Runtime Polymorphism: A Beginner's Guide to Java Inheritance

Kathirvel S — Sun, 07 Jun 2026 15:00:48 +0000

Understanding Inheritance in Java

Inheritance is one of the fundamental concepts of Object-Oriented Programming (OOP). It allows one class to inherit properties and behaviors from another class.

According to Oracle's Java documentation, inheritance is a mechanism by which one object acquires the properties and behaviors of a parent object.

In simpler terms, inheritance allows code reuse.

Instead of writing the same methods again and again in multiple classes, we can place common functionality inside a parent class and allow child classes to inherit those features.

Think about mobile phones.

Every smartphone has some common features:

Calling
Internet
Contacts
Messaging

If Samsung, OnePlus, Vivo, and Pixel all need these features, it would be inefficient to rewrite them in every class.

Instead, we create a common parent class called Mobile.

Then individual brands can extend that class and inherit all common functionality automatically.

This reduces code duplication, improves maintainability, and makes applications easier to scale as new subclasses are added.

Visually:

Mobile
   ↑
Samsung

This relationship means:

Samsung IS-A Mobile.

The IS-A relationship is one of the easiest ways to identify inheritance in Java.

Since a Samsung phone is a type of Mobile, it can inherit everything available inside the Mobile class.

What Happens When We Create a Samsung Object?

Consider this statement:

Samsung samsung = new Samsung("Galaxy");

Many beginners assume Java immediately starts executing the Samsung constructor because we are creating a Samsung object.

However, that is not what actually happens internally.

Object creation in Java follows a specific sequence.

Java cannot directly initialize Samsung-specific data because Samsung depends on Mobile.

Since Samsung inherits from Mobile, Java must first ensure that the Mobile portion of the object is properly initialized.

Think about constructing a building.

You cannot start with the roof.

You need:

Foundation
   ↓
Walls
   ↓
Roof

Similarly, Java follows:

Parent Class
   ↓
Child Class

The parent acts as the foundation for the child.

Without initializing the parent, the child object would be incomplete.

This is why Java always starts with the parent constructor before executing the child constructor.

Why Does the Parent Constructor Execute First?

This is one of the most common interview questions.

When a Samsung object is created, the object actually contains two logical parts:

Samsung Object
 ├── Mobile Part
 └── Samsung Part

The Mobile part comes from inheritance.

Because that parent portion exists inside the object, Java must initialize it first.

Imagine buying a Samsung phone.

Before Samsung-specific features can work, the phone must first have the basic mobile functionality available.

The same principle applies during object creation.

Java first prepares everything inherited from the parent class and then initializes child-specific members.

This process is called Constructor Chaining.

Constructor chaining refers to the sequence in which constructors are called during object creation.

In an inheritance hierarchy, constructor execution always proceeds from parent to child.

This ensures that objects are created in a valid and predictable state.

Understanding the super Keyword

The super keyword is one of the most important concepts in inheritance.

Many beginners memorize that:

super(name);

calls the parent constructor.

While that statement is correct, it is important to understand what is actually happening behind the scenes.

The super keyword refers to the immediate parent class.

When Java encounters:

super(name);

it temporarily transfers control to the parent constructor.

In our example:

public Samsung(String name){
    super(name);
    System.out.println("samsung-constructor");
}

Java performs the following steps:

Step 1:
Enter Samsung constructor

Step 2:
Encounter super(name)

Step 3:
Move to Mobile constructor

Step 4:
Execute Mobile constructor

Step 5:
Return to Samsung constructor

Step 6:
Execute remaining statements

Because of this sequence, the output becomes:

mobile-constructor Galaxy
samsung-constructor

instead of:

samsung-constructor
mobile-constructor

The parent constructor always finishes first.

What Happens If We Don't Write super()?

Many developers are surprised to learn that Java automatically inserts super() when it is missing.

For example:

public Samsung(String name){
    System.out.println("samsung-constructor");
}

Java internally converts it to:

public Samsung(String name){
    super();
    System.out.println("samsung-constructor");
}

This is called an implicit constructor invocation.

The compiler automatically inserts a call to the parent constructor because Java wants to ensure the parent portion of the object is initialized.

This behavior happens even if you don't explicitly write super() yourself.

Many beginners assume the parent constructor runs magically.

The truth is that Java inserts the constructor call on your behalf.

Why Must super() Be the First Statement?

Java enforces a strict rule:

super(...)

must always be the first statement inside a constructor.

Valid:

public Samsung(String name){
    super(name);
    System.out.println("hello");
}

Invalid:

public Samsung(String name){

    System.out.println("hello");

    super(name);
}

Compilation error.

But why is Java so strict?

The reason is object consistency.

Before the child constructor executes any logic, Java must ensure that the parent class has completed initialization.

If Java allowed statements before super(), the child constructor might access data that depends on the parent being initialized.

This could lead to partially constructed objects and unpredictable behavior.

To avoid such issues, Java enforces a rule that parent constructor invocation must happen first.

This guarantees that the inheritance hierarchy is initialized from top to bottom.

What Can We Pass Inside super()?

The values passed to super() must match a constructor available in the parent class.

Example:

Parent:

public Mobile(String name){
}

Child:

super(name);

Java searches for:

Mobile(String name)

and invokes it.

If the parent constructor expects multiple parameters:

public Mobile(String name,int price){
}

then:

super(name,price);

must be used.

A common beginner mistake is passing arguments that do not match any parent constructor.

When this happens, Java throws a compilation error because it cannot determine which constructor should be called.

Always think of super() as:

"Call a constructor from my parent class."

Method Overriding

Now let's examine these methods:

Inside Mobile:

public void internet(){
    System.out.println("internet mobile class");
}

Inside Samsung:

public void internet(){
    System.out.println("internet samsung class");
}

Notice that both methods have:

Same name
Same parameter list
Compatible return type

This is called Method Overriding.

Method overriding allows a subclass to provide its own implementation of a method already defined in its superclass.

The parent method still exists.

The child simply replaces the inherited behavior with a more specific version.

Think about internet connectivity.

Every mobile phone supports internet access.

However, Samsung may implement that functionality differently from another manufacturer.

The capability remains the same, but the implementation changes.

That is exactly what method overriding achieves.

Why Does Samsung's Method Execute?

Consider:

Samsung samsung = new Samsung("Galaxy");

samsung.internet();

Java checks the object type.

The object is:

Samsung

Therefore Java executes:

Samsung.internet()

Output:

internet samsung class

Even though the method originally existed inside Mobile, Samsung has provided a newer implementation.

Java always prefers the most specific implementation available.

Runtime Polymorphism Explained

One of the most powerful features of Java is runtime polymorphism.

The word comes from Greek:

Poly = Many
Morph = Forms

Meaning:

One Interface
Many Behaviors

Consider:

Mobile phone = new Samsung("Galaxy");

phone.internet();

Many beginners think:

Reference Type = Mobile

Therefore:

Mobile.internet()

should run.

But that is incorrect.

Java checks:

Actual Object Type

which is:

Samsung

Because the actual object is Samsung, Java executes:

Samsung.internet()

This decision happens while the program is running.

That is why it is called Runtime Polymorphism.

Dynamic Method Dispatch

The technical name used in Java documentation is:

Dynamic Method Dispatch

This is the mechanism through which Java determines which overridden method should execute.

At compile time Java only verifies that:

phone.internet();

is a valid method call.

The actual implementation is selected later during runtime.

This dynamic selection enables flexible and extensible application design.

Frameworks such as Spring, Hibernate, and Android rely heavily on runtime polymorphism.

What Actually Happens in Memory?

Let's analyze:

Mobile phone = new Samsung("Galaxy");

Behind the scenes:

Step 1

Memory is allocated on the heap for a Samsung object.

Step 2

Space is reserved for:

Mobile fields
Samsung fields
Internal object metadata

Step 3

Java begins constructor execution.

Step 4

Parent constructor executes.

Step 5

Child constructor executes.

Step 6

Reference variable receives the object reference.

Visually:

phone
  │
  ▼
Samsung Object
 ├── Mobile Data
 └── Samsung Data

When:

phone.internet();

is executed, Java inspects the actual object in memory.

Since the object is Samsung, Samsung's overridden method is selected.

This entire decision happens dynamically during runtime.

Can We Change the Return Type While Overriding?

Generally, no.

Example:

Parent:

public void internet(){
}

Child:

public int internet(){
}

Compilation error.

The method signature becomes incompatible.

However, Java supports something called a Covariant Return Type.

Example:

public Mobile getPhone(){
}

Child:

public Samsung getPhone(){
}

This is allowed because Samsung is a subtype of Mobile.

Covariant return types provide flexibility while still preserving type safety.

Final Takeaway

Whenever you create:

Samsung samsung = new Samsung("Galaxy");

Java follows this sequence:

1. Allocate memory
2. Initialize parent class
3. Execute parent constructor
4. Execute child constructor
5. Finish object creation
6. Execute methods
7. Use runtime polymorphism for overridden methods

The easiest way to remember everything is:

Constructors move from Parent → Child, while overridden methods are chosen based on the Actual Object at Runtime.

Once this concept clicks, inheritance, constructor chaining, super(), method overriding, dynamic method dispatch, and runtime polymorphism become much easier to understand and debug in real-world Java applications.

Printing a Mixed Sequence Using a Single Loop: 1 3 5 7 9 2 4 6 8 10

Kathirvel S — Fri, 05 Jun 2026 03:17:06 +0000

Introduction

While working through basic programming exercises, I encountered a problem that initially looked straightforward but turned out to be a good exercise in logical decomposition:

Print the sequence
1 3 5 7 9 2 4 6 8 10
using a single loop.

At first, the problem seems trivial. However, the constraint of using a single loop introduces an important requirement: we cannot separately iterate over odd and even numbers using two loops. Instead, we need to identify a unified logic that produces both sequences in a controlled manner.

This is where the actual thinking begins.

Understanding the Pattern

Before writing any code, I focused on understanding the structure of the output.

If we rewrite the sequence visually:

1 3 5 7 9 | 2 4 6 8 10

We can clearly observe two distinct parts:

The first half consists of odd numbers from 1 to 9.
The second half consists of even numbers from 2 to 10.

This suggests that a single loop must be responsible for generating two different sequences depending on the iteration range.

So instead of thinking in terms of numbers directly, we think in terms of positions in a loop.

Let us assume we iterate from 1 to 10.

Iteration Range	Output Pattern
1 to 5	Odd numbers
6 to 10	Even numbers

This observation becomes the foundation of the solution.

Deriving the Odd Number Formula

We first focus on generating:

1, 3, 5, 7, 9

Let us map loop values to output values:

i	Output
1	1
2	3
3	5
4	7
5	9

Now we look for a mathematical relationship.

A consistent pattern emerges:

Multiply the index by 2
Subtract 1

This gives the formula:

2*i - 1

Verification:

i = 1 → 1
i = 2 → 3
i = 3 → 5
i = 4 → 7
i = 5 → 9

This confirms that the formula correctly generates the odd sequence.

Deriving the Even Number Formula

Next, we focus on:

2, 4, 6, 8, 10

These correspond to iterations 6 to 10.

To simplify, we shift the index so that it starts from zero:

i	i - 5
6	1
7	2
8	3
9	4
10	5

Now we observe a familiar pattern again: multiples of 2.

So the formula becomes:

2 * (i - 5)

Verification:

i = 6 → 2
i = 7 → 4
i = 8 → 6
i = 9 → 8
i = 10 → 10

This successfully generates the even sequence.

Combining Both Conditions in a Single Loop

Now that both formulas are derived, the next step is to combine them using conditional logic.

The key idea is:

For the first half of the loop (1 to 5), generate odd numbers.
For the second half (6 to 10), generate even numbers.

This leads to the condition:

If i <= 5, use odd number formula.
Otherwise, use even number formula.

Final Implementation

i = 1

while i <= 10:
    if i <= 5:
        print(2*i - 1)
    else:
        print(2*(i - 5))

    i = i + 1

above mentioned code ouput will be

1
3
5
7
9
2
4
6
8
10

like this

but to get a exact output
we have to modify it like below mentioned

Code :

Output :

Flow of Execution

The logic can be understood in terms of decision flow:

Start with i = 1
Check if i is less than or equal to 5
If true, generate odd number using 2*i - 1
If false, generate even number using 2*(i - 5)
Print the result
Increment i
Repeat until i exceeds 10

This ensures that a single loop is responsible for producing two distinct sequences.

Flowchart Representation

Flowchart showing how a single loop splits into odd and even number generation logic.

Key Learnings

This problem is not about loops alone. It is fundamentally about pattern recognition and decomposition.

The key takeaways include:

1. Break the problem into segments

Instead of trying to solve the full sequence at once, divide it into smaller logical parts.

2. Identify index-to-value mapping

Every output number is a transformation of the loop variable.

3. Use conditional logic carefully

A single loop can simulate multiple patterns if conditions are properly defined.

4. Avoid premature coding

Attempting to code without understanding the pattern leads to confusion and inefficiency.

Conclusion

Although this problem appears simple, it demonstrates an important principle in programming: complex output patterns can often be reduced to simple mathematical relationships when broken down properly.

The challenge is not writing the loop itself, but understanding how to transform a single variable into multiple sequences through logic.

Accessing Methods from Another Class in Java – From Tambaram to Velachery: Understanding Method Access and Inheritance in Java

Kathirvel S — Thu, 04 Jun 2026 14:31:22 +0000

Today my trainer taught a Java concept that genuinely stayed with me.

Sometimes in Java, you write a method in one class and then wonder:

"How can I use that method inside another class?"

At first, it feels confusing.

Later, when you understand objects, imports, inheritance, and the extends keyword, everything starts making sense.

In this article, I'll explain the exact flow my trainer taught today—from accessing methods using objects, to why inheritance exists, to how static methods work.

Let's start from the beginning.

Step 1: A Simple Home Class

Suppose we have a package called tambaram.

package tambaram;

public class Home {

    public static void main(String[] args){
        Home person = new Home();
        person.study();
    }

    public void study(){
        System.out.println("learning java");
    }
}

Output

learning java

Here what happens?

Java starts execution from main().
We create an object called person.
Using that object, we call the method study().
The method executes and prints the output.

Think of it like this:

Home is the blueprint.
person is the actual object created from that blueprint.
Methods belong to the object.

So Java understands:

person.study();

"Hey object person, execute your study() method."

Step 2: Another Class in Another Package

Now let's create a completely different class.

package velachery;

public class Theatre {

    public static void main(String [] args ){
        Theatre person = new Theatre();
        person.watch();
    }

    public void watch(){
        System.out.println("watch blast movie");
    }
}

Output

watch blast movie

This class has its own object and its own method.

Notice something interesting:

study() belongs to Home.

watch() belongs to Theatre.

They are completely separate classes.

A Small Story Before We Continue...

Let's imagine a person named Arun.

Arun lives in Tambaram.

Every morning, he sits in his room, opens his laptop, and spends time learning Java. He practices programs, writes code, fixes errors, and slowly improves his programming skills.

So when Arun is at home, we can think of him like this:

person.study();

because his current activity is studying.

Now imagine it is the weekend.

After spending hours learning Java, Arun feels like he deserves a small break.

He checks the latest movie releases and hears that a great movie is playing in a theatre at Velachery.

So he travels from Tambaram to Velachery to watch the movie.

At that moment, his activity changes from:

person.study();

person.watch();

Now think carefully.

Is Arun a different person?

No.

It is still the same Arun.

The only difference is the place and the behavior he wants to perform.

When he is in Tambaram, he studies.

When he is in Velachery, he watches movies.

As humans, we can naturally perform both actions because we move between places and use different facilities.

But Java classes don't work that way.

A method belongs to the class in which it is defined.

The study() method belongs to Home.

The watch() method belongs to Theatre.

So when our Home person wants to watch a movie, Java cannot automatically understand where the watch() method exists.

Java needs a proper connection.

It needs to know:

"Where is this method defined?"

"Which class owns this behavior?"

"How can I access it?"

That is exactly why we import the Theatre class and create an object of it.

By doing that, we are telling Java:

"Our Tambaram person also wants to use the facilities available in Velachery."

And that leads us to the next step, where the Home class accesses the Theatre class and calls:

samePerson.watch();

This may look like a simple line of code, but it introduces one of the most important ideas in Java:

A class can access behaviors from another class when we create the proper relationship between them.

Let's see how that works.

The Big Question

Now suppose the person in Home wants to watch a movie.

How can Home access the method inside Theatre?

This is where Java gives us a solution.

Step 3: Importing Another Class

import velachery.Theatre;

public class Home {

    public static void main(String[] args){

        Home person = new Home();

        Theatre samePerson = new Theatre();

        samePerson.watch();

        person.study();
    }

    public void study(){
        System.out.println("learning java");
    }
}

Output

watch blast movie
learning java

How Does This Work?

Let's break it down carefully.

First

import velachery.Theatre;

This tells Java:

"I want to use the Theatre class that exists inside the velachery package."

Without importing, Java doesn't know where Theatre exists.

Second

Theatre samePerson = new Theatre();

Here we create an object of Theatre.

Think of it as:

Home Person  ---> Studies

Theatre Person ---> Watches Movie

Now we have access to Theatre's methods.

Third

samePerson.watch();

Java looks inside the Theatre object.

It finds:

public void watch()

and executes it.

Visual Understanding

Think about a real person.

Person:
   Study at Home
   Watch Movie at Theatre

Similarly:

Home person = new Home();

Theatre samePerson = new Theatre();

One object accesses Home behaviors.

Another object accesses Theatre behaviors.

Both objects represent different class instances.

But There Is a Problem...

This works.

But imagine a project with:

Home
Theatre
School
Office
Library
College
Bank
Hospital

For every class:

ClassName obj = new ClassName();

must be created.

Example:

School school = new School();
Office office = new Office();
Library library = new Library();

Again and again.

Lots of object creation.

Lots of repetitive code.

This becomes boilerplate code.

Java gives us a better approach.

That approach is called:

Inheritance

Understanding Why Inheritance Exists

Consider this class.

public class Mobile{

    public static void main(String[] args){

        Mobile mobile = new Mobile();

        mobile.calling();
        mobile.message();

        System.out.println("Hellooo ");
    }

    public void calling(){
        System.out.println("calling feature");
    }

    public void message(){
        System.out.println("message feature");
    }
}

Output

calling feature
message feature
Hellooo

Now think carefully.

Every mobile phone has:

Calling
Messaging

Whether it is:

Samsung
Vivo
Oppo
Nokia
Motorola

all phones share these common features.

Creating Samsung Class

public class Samsung{

    public static void main(String[] args){

        Samsung samsung = new Samsung();

        samsung.calling();
        samsung.message();
    }
}

Java gives an error.

Why?

Because Samsung class doesn't contain:

calling()
message()

methods.

Java looks inside Samsung and says:

"I can't find these methods."

Hence compilation error.

Enter the extends Keyword

Now let's modify the class.

public class Samsung extends Mobile{

    public static void main(String[] args){

        Samsung samsung = new Samsung();

        samsung.calling();
        samsung.message();
    }
}

Now it works perfectly.

What Exactly Does extends Mean?

The Oracle Java documentation defines inheritance as a mechanism where one class acquires the properties and behaviors of another class.

In simple words:

One class can reuse the methods and variables of another class.

The keyword used is:

extends

Parent and Child Relationship

Mobile
   ↑
Samsung

Mobile is called:

Parent Class
Super Class
Base Class

Samsung is called:

Child Class
Sub Class
Derived Class

What Happens Internally?

When Java sees:

class Samsung extends Mobile

it understands:

Samsung should inherit everything available inside Mobile.

So Samsung automatically gets:

calling()

message()

without rewriting them.

That is the real power of inheritance.

Real World Example

Imagine a room with four AC units.

AC 1
AC 2
AC 3
AC 4

Do we need four remotes?

No.

One remote can control all ACs because they share common functionality.

Inheritance works similarly.

The parent class contains common behavior.

Child classes reuse it.

Instead of rewriting code everywhere, one common source is shared.

This is exactly the idea behind inheritance.

Why Developers Love Inheritance

Without inheritance:

calling()
message()

must be written in:

Samsung
Vivo
Oppo
Nokia
Realme
Motorola

again and again.

With inheritance:

Mobile

contains the common methods.

Every mobile brand simply extends it.

Benefits:

Code Reusability

Write once.

Use everywhere.

Less Boilerplate

Less repeated code.

Easier Maintenance

Fix one method.

All child classes get the update.

Better Design

Common behavior stays in one place.

Accessing Static Methods

Until now we discussed instance methods.

Example:

public void calling()

requires an object.

But static methods belong to the class itself.

Example:

public class Mobile{

    public static void companyName(){
        System.out.println("Mobile World");
    }
}

Call it like:

Mobile.companyName();

Notice:

new Mobile()

is not needed.

Why?

Because static methods belong to the class, not the object.

Static Method Analogy

Imagine again our room with four ACs.

AC1
AC2
AC3
AC4

Each AC is an object.

But there is only one remote.

That remote is shared.

Similarly:

static

means one common thing shared by all objects.

Every object can use it.

But Java stores only one copy.

Classes Without main() Method

Many beginners think every class must contain:

public static void main(String[] args)

Actually, no.

Consider:

public class Mobile{

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

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

This compiles perfectly.

No error.

Why Doesn't It Run?

Because Java starts execution from:

main()

If there is no main method:

Java has nothing to execute.

So:

Compiles?

✅ Yes

Runs?

❌ No

Then Why Create Such Classes?

Because many classes exist only to provide:

Methods
Variables
Common functionality

Example:

Mobile

doesn't need to run directly.

Its purpose is:

Provide common features

for:

Samsung
Vivo
Oppo
Realme

and other child classes.

This is extremely common in real-world projects.

Many classes are never executed directly.

They simply provide reusable functionality.

The Journey We Learned Today

We started with:

person.study();

Then moved to:

samePerson.watch();

using imported classes.

Then understood the limitation of creating objects everywhere.

Finally we discovered:

extends

which allows one class to inherit methods from another class.

This is one of the most important pillars of Object-Oriented Programming (OOP).

Once inheritance clicks, many advanced concepts become easier:

Method Overriding
Polymorphism
Abstract Classes
Interfaces
Framework Development
Spring Boot Development

Everything starts from understanding inheritance properly.

And honestly, this was one of those concepts that instantly felt practical when connected to real-world examples like mobile phones and AC remotes.

If you're learning Java, spend time experimenting with:

extends

because you'll see it everywhere in professional Java applications.

A single keyword can save hundreds or even thousands of lines of repeated code.

That is the power of inheritance.

References

Oracle Java Tutorials – Inheritance
Oracle Java Language Specification
Oracle Java Documentation – Classes and Objects
Oracle Java Documentation – Static Methods and Fields
Oracle Java Tutorials – Object-Oriented Programming Concepts

Official Oracle Java Documentation:

Oracle Java Documentation

Oracle Java OOP Concepts

Oracle Classes and Objects Guide

Happy Coding!

Types of Constructors in Java and Packages in Java – Stop Confusing Default and No-Arg Constructors! - Java Constructor & Package

Kathirvel S — Wed, 03 Jun 2026 15:15:59 +0000

Introduction

When beginners start learning Java, two topics often create confusion:

Constructors
Packages

Many students ask:

What is a constructor?
How many types of constructors exist?
Is a default constructor the same as a no-argument constructor?
How does Java automatically create constructors?
Why do we need packages?
How do packages work?
How do we compile and run package-based programs?

This guide explains everything from scratch in a beginner-friendly way.

Part 1: Constructors in Java

Official Definition (Oracle Java Documentation)

According to Oracle Java Tutorials:

"A class contains constructors that are invoked to create objects from the class blueprint." ¹

In simple words:

A constructor is a special block of code that runs automatically whenever an object is created.

Think of a constructor as the "setup process" of an object.

Real-Life Example

Imagine buying a new mobile phone.

When the phone is turned on for the first time:

Memory is allocated
Default settings are loaded
Language is selected
System gets initialized

Similarly, when an object is created in Java:

Student s1 = new Student();

Java allocates memory and calls the constructor to initialize the object.

Characteristics of Constructors

A constructor:

✔ Has the same name as the class

✔ Has no return type

✔ Runs automatically when an object is created

✔ Can accept parameters

✔ Can be overloaded

✔ Cannot be static

✔ Cannot be abstract (TBD)

✔ Cannot be final (TBD)

Example

class Student {

    Student() {
        System.out.println("Constructor Called");
    }

    public static void main(String[] args) {

        Student s = new Student();

    }
}

Output:

Constructor Called

Notice:

Student()

has the same name as the class.

Why Do We Need Constructors?

Without constructors:

Student s = new Student();

s.name = "John";
s.age = 20;

You would need to initialize everything manually.

Constructors allow initialization during object creation itself.

Student s = new Student("John",20);

Much cleaner.

Types of Constructors in Java

Most beginner courses discuss:

Default Constructor
No-Argument Constructor
Parameterized Constructor

Additionally, constructor overloading is an important concept.

Let's study each deeply.

1. Default Constructor

This is one of the most misunderstood topics in Java.

Official Definition

Oracle documentation explains that if a class contains no constructors, the compiler automatically provides one. ¹

What is a Default Constructor?

A default constructor is a constructor automatically created by the Java compiler when you do not write any constructor.

Example:

class Student {

}

You wrote:

class Student {

}

But Java internally behaves like:

class Student {

    Student() {

    }

}

The compiler secretly creates it.

Why Does Java Create It?

Imagine this code:

Student s = new Student();

Java needs some constructor to execute.

Since you didn't provide one, Java generates one automatically.

What Does the Default Constructor Do?

The generated constructor:

Calls parent constructor using super()
Initializes object fields with default values

Example:

class Student {

    int id;
    String name;

}

Object creation:

Student s = new Student();

Values become:

id = 0
name = null

These are Java's default field values.

Internal View

Compiler-generated constructor roughly looks like:

Student() {
    super();
}

Important Rule

Java generates a default constructor ONLY IF NO CONSTRUCTOR EXISTS.

Example:

class Student {

    Student(int id){

    }

}

Now:

Student s = new Student();

Error!

Why?

Because Java sees that you already created a constructor.

Therefore it does not generate the default constructor.

2. No-Argument Constructor

Now comes the most confusing interview question.

What is a No-Argument Constructor?

A constructor that accepts zero parameters.

Example:

class Student {

    Student() {
        System.out.println("No Arg Constructor");
    }

}

No parameters.

Hence:

Student()

is a no-argument constructor.

Is Default Constructor Equal to No-Argument Constructor?

Short Answer:

NO.

They are related but not identical.

Difference Table

Feature	Default Constructor	No-Argument Constructor
Created By	Java Compiler	Programmer
Parameters	None	None
Written by User	No	Yes
Automatic	Yes	No

Example 1: Default Constructor

class Student {

}

Compiler creates:

Student() {

}

This is a DEFAULT constructor.

Example 2: No-Argument Constructor

class Student {

    Student() {
        System.out.println("Created");
    }

}

This is a NO-ARGUMENT constructor.

Easy Rule to Remember

Every default constructor is a no-argument constructor.

BUT

Not every no-argument constructor is a default constructor.

Why?

Because default constructors are compiler-generated.

No-arg constructors are programmer-written.

Interview Question

Question:

Is default constructor same as no-arg constructor?

Best Answer:

No.

A default constructor is automatically provided by the Java compiler when no constructor exists in the class.

A no-argument constructor is explicitly written by the programmer and takes no parameters.

3. Parameterized Constructor

Official Definition

W3Schools states that constructors can take parameters that initialize object attributes. ²

What is a Parameterized Constructor?

A constructor that receives values while creating objects.

Example:

class Student {

    String name;
    int age;

    Student(String name,int age){

        this.name = name;
        this.age = age;

    }

}

Object Creation

Student s1 = new Student("John",20);

Values become:

name = John
age = 20

Why Use Parameterized Constructors?

Without constructor:

Student s = new Student();

s.name="John";
s.age=20;

With constructor:

Student s = new Student("John",20);

Cleaner and safer.

Constructor Overloading

Java allows multiple constructors.

Example:

class Student {

    Student() {

    }

    Student(String name) {

    }

    Student(String name,int age) {

    }

}

Java selects constructor based on arguments.

new Student();
new Student("John");
new Student("John",20);

This is constructor overloading.

Constructor Chaining (TBD)

One constructor can call another constructor.

Example:

class Student {

    Student() {

        this("Unknown");

    }

    Student(String name){

        System.out.println(name);

    }

}

Output:

Unknown

This improves code reuse.

Summary of Constructors

Constructor initializes objects.
Constructor name must match class name.
No return type.
Runs automatically.
Default constructor is compiler-generated.
No-arg constructor is programmer-written.
Parameterized constructor accepts values.
Constructors can be overloaded.

Part 2: Packages in Java

Now let's move to another important topic.

What is a Package?

Official Definition

According to Oracle:

"A package is a namespace that organizes a set of related classes and interfaces." ³

Beginner-Friendly Definition

A package is a folder-like structure used to organize Java classes.

Think about your computer.

Without folders:

1000 files in one place

Very messy.

Folders solve this problem.

Packages do the same in Java.

Why Do We Need Packages?

Imagine a company with:

5000 Java classes

Without packages:

Student.java
Employee.java
Manager.java
Account.java
Admin.java

Everything mixed together.

Hard to manage.

Packages provide organization.

Advantages of Packages

1. Organization

Classes stay grouped.

Example:

com.company.student
com.company.employee
com.company.finance

2. Avoid Name Conflicts

Two developers may create:

Student

class.

Packages allow:

college.Student

and

school.Student

Both can exist.

3. Access Control

Packages help control visibility.

Keywords:

public
protected
default
private

work together with packages.

Package Syntax

package mypackage;

Must be the first statement.

Example:

package mypackage;

public class Student {

}

Creating Your First Package

Folder structure:

project
|
|-- mypackage
      |
      Student.java

Student.java

package mypackage;

public class Student {

    public void show(){

        System.out.println("Hello Package");

    }

}

Using Package Class

import mypackage.Student;

public class Main {

    public static void main(String[] args){

        Student s = new Student();

        s.show();

    }

}

Import Keyword (TBD)

Used to access classes from other packages.

Syntax:

import packageName.ClassName;

Example:

import mypackage.Student;

Import All Classes

import java.util.*;

The * means all classes.

Example:

ArrayList
Scanner
HashMap

can be used.

Common Java Packages

java.lang

Imported automatically.

Contains:

String
System
Math
Object

java.util

Contains:

ArrayList
Scanner
HashMap
Collections

java.io

Contains:

File
BufferedReader
PrintWriter

How Java Stores Packages

Package:

package com.company.student;

creates structure:

com
 |
 company
   |
 student

Java expects folder names to match package names.

Compiling Packages

This is where beginners get confused.

Suppose:

package mypackage;

public class Student {

}

File:

Student.java

Compile:

javac -d . Student.java

What Does -d Mean?

-d means destination directory.

javac -d . Student.java

means:

"Create package folders in current directory."

Output:

mypackage
 |
 Student.class

Running Package Programs

Compile:

javac -d . Student.java

Run:

java mypackage.Student

Notice:

java Student

❌ Wrong

java mypackage.Student

✅ Correct

Example

File:

package mypackage;

public class Student {

    public static void main(String[] args){

        System.out.println("Hello Package");

    }

}

Compile:

javac -d . Student.java

Run:

java mypackage.Student

Output:

Hello Package

Package Naming Convention

Usually:

com.company.project

Examples:

com.google
com.microsoft
com.amazon
org.apache

Reverse domain naming prevents conflicts.

Real Industry Example

Spring Framework:

org.springframework

Hibernate:

org.hibernate

JUnit:

org.junit

Large projects may contain hundreds of packages.

Final Summary

Constructors:

Special methods used for initialization.
Run automatically during object creation.
Types:
- Default Constructor
- No-Argument Constructor
- Parameterized Constructor
- Constructor Overloading

Important:

Default constructor is generated by compiler.
No-arg constructor is written by programmer.
Every default constructor is a no-arg constructor.
Not every no-arg constructor is a default constructor.

Packages:

Organize Java classes.
Prevent naming conflicts.
Improve maintainability.
Support access control.
Created using package keyword.
Accessed using import keyword.

Compile package:

javac -d . Student.java

Run package:

java mypackage.Student

References

Oracle Java Tutorials – Constructors:
https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html
W3Schools – Java Constructors:
https://www.w3schools.com/java/java_constructors.asp
Oracle Java Tutorials – Packages:
https://docs.oracle.com/javase/tutorial/java/package/index.html
W3Schools – Java Packages:
https://www.w3schools.com/java/java_packages.asp
Java Language Specification (JLS):
https://docs.oracle.com/javase/specs/
Oracle Java Documentation:
https://docs.oracle.com/en/java/

Constructors in Java: Why Do We Need Them?

Kathirvel S — Tue, 02 Jun 2026 14:42:13 +0000

Introduction

Imagine you are building a supermarket management system in Java.

You create a class called SuperMarket to represent products.

Let's say every product has:

A name
A price

At first, everything seems easy.

SuperMarket product1 = new SuperMarket();

product1.name = "Rice";
product1.price = 200;

No problem.

Now let's create another product.

SuperMarket product2 = new SuperMarket();

product2.name = "Sugar";
product2.price = 150;

Still looks fine.

But wait...

What if your supermarket has 2,000 products?

SuperMarket product1 = new SuperMarket();
product1.name = "Rice";
product1.price = 200;

SuperMarket product2 = new SuperMarket();
product2.name = "Sugar";
product2.price = 150;

SuperMarket product3 = new SuperMarket();
product3.name = "Milk";
product3.price = 60;

SuperMarket product4 = new SuperMarket();
product4.name = "Tea";
product4.price = 120;

// ... imagine doing this 2000 times

Looks exhausting, right?

For every object:

Create object
Set name
Set price

Again and again.

This is repetitive.

This is error-prone.

This is exactly the problem that constructors solve.

The Better Way

Instead of creating an object first and then assigning values manually, Java allows us to provide values during object creation itself.

SuperMarket product1 = new SuperMarket("product1's name", 200);

Now think about it.

In one line:

Object is created
Name is assigned
Price is assigned

Much cleaner.

Much faster.

Much safer.

But when beginners see this line, they often ask:

"Wait... where did those values go?"

SuperMarket product1 = new SuperMarket("product1's name", 200);

How does Java know where to store:

"product1's name"

and

The answer is:

Constructor

What Is a Constructor?

Official Definition

A constructor is a special member of a class that is automatically called when an object is created and is used to initialize objects.

Reference

Oracle Java Documentation describes constructors as special members of a class that are used to initialize objects and are automatically invoked when an object is created.

Source:
https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

Beginner-Friendly Definition

A constructor is a special method that runs automatically when we create an object and helps us give initial values to that object.

Think of it like this:

When a new employee joins a company, some information must be collected immediately:

Name
Employee ID
Department

Similarly, when a new object is created, some values may be required immediately.

A constructor helps us provide those values at the time of object creation.

The Problem You'll Face

Suppose your class looks like this:

class SuperMarket {

    String name;
    int price;

}

Now you write:

SuperMarket product1 =
        new SuperMarket("product1's name", 200);

Java immediately gets confused.

It starts searching for a constructor that accepts:

(String, int)

But your class doesn't have one.

So Java throws an error.

Error

constructor SuperMarket in class SuperMarket
cannot be applied to given types;

required: no arguments
found: String,int
reason: actual and formal argument lists differ in length

Why?

Because Java only knows how to create:

new SuperMarket();

not

new SuperMarket("product1's name", 200);

Solving the Error Using a Constructor

Let's create a constructor.

class SuperMarket {

    String name;
    int price;

    public SuperMarket(String name, int price) {

        name = name;
        price = price;

    }
}

Now the error disappears.

You can create:

SuperMarket product1 =
        new SuperMarket("product1's name", 200);

But wait...

A new problem appears.

The Silent Bug

Many beginners think this code is correct.

public SuperMarket(String name, int price) {

    name = name;
    price = price;

}

Looks correct.

No compilation error.

No red underline.

No warning.

But it DOES NOT work.

Let's understand why.

Why `name = name` Does Not Work

Inside the constructor:

public SuperMarket(String name, int price)

Java creates local variables:

name
price

These belong only to the constructor.

Now look at:

name = name;

Java sees:

localName = localName;

Similarly:

price = price;

becomes:

localPrice = localPrice;

You're assigning a variable to itself.

Nothing gets stored inside the object.

Reference

The this keyword refers to the current object. It is commonly used when constructor parameters have the same names as instance variables, allowing Java to distinguish between them.

Source:
https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

Proof

class SuperMarket {

    String name;
    int price;

    public SuperMarket(String name, int price) {

        name = name;
        price = price;

    }
}

Now:

SuperMarket product1 =
        new SuperMarket("Rice", 200);

System.out.println(product1.name);
System.out.println(product1.price);

Output:

null
0

Expected:

Rice
200

Actual:

null
0

Why?

Because object variables never received the values.

The Correct Solution

Use this.

public SuperMarket(String name, int price) {

    this.name = name;
    this.price = price;

}

Now:

SuperMarket product1 =
        new SuperMarket("Rice", 200);

Java does:

this.name = "Rice";
this.price = 200;

Now values are stored properly.

Output After Fixing

System.out.println(product1.name);
System.out.println(product1.price);

Output:

Rice
200

Perfect.

Constructor Rule #1

Constructor Name Must Be Same As Class Name

Class:

class SuperMarket

Constructor:

public SuperMarket()
{
}

Notice both names are identical.

Wrong

public Market()
{
}

Error:

invalid method declaration;
return type required

Why?

Java thinks this is a normal method.

Since methods require a return type, Java complains.

Correct

public SuperMarket()
{
}

Constructor name matches class name.

No error.

Constructor Rule #2

No Return Type Required

Methods require return types.

Example:

public void display()
{
}

But constructors are different.

Correct

public SuperMarket()
{
}

No return type.

Wrong

public void SuperMarket()
{
}

This is NOT a constructor.

This becomes a normal method.

Java will not call it automatically.

Many beginners accidentally make this mistake.

Constructor Rule #3

Constructor Is Called Automatically

Look at:

SuperMarket product1 =
        new SuperMarket();

The moment Java sees:

new SuperMarket()

it automatically executes the constructor.

You don't need:

product1.SuperMarket();

In fact, that's impossible.

Java automatically calls the constructor during object creation.

Proof

class SuperMarket {

    public SuperMarket() {

        System.out.println("Constructor Executed");

    }
}

Object creation:

SuperMarket product1 =
        new SuperMarket();

Output:

Constructor Executed

See?

We never called it manually.

Java called it automatically.

Constructor Rule #4

Used For Initializing Objects With Specific Values

Suppose every product should have:

Name
Price

immediately after creation.

Constructor makes this possible.

SuperMarket product1 =
        new SuperMarket("Rice", 200);

SuperMarket product2 =
        new SuperMarket("Sugar", 150);

SuperMarket product3 =
        new SuperMarket("Milk", 60);

Each object gets different values instantly.

That's called object initialization.

What Happens When We Write This?

SuperMarket product1 =
        new SuperMarket();

Interesting question.

Does Java create a constructor automatically?

The answer is:

YES... but only in certain situations.

Default Constructor

Suppose your class is:

class SuperMarket {

    String name;
    int price;

}

Notice:

No constructor is written.

Now:

SuperMarket product1 =
        new SuperMarket();

Works perfectly.

Why?

Because Java secretly creates a constructor for you.

Something like:

public SuperMarket()
{
}

This is called the Default Constructor.

Reference

According to the Java Language Specification, if a class contains no constructor declarations, the Java compiler automatically provides a default constructor. Once a programmer explicitly defines a constructor, the compiler no longer generates the default constructor automatically.

Source:
https://docs.oracle.com/javase/specs/

Proof

This works:

class SuperMarket {

    String name;
    int price;

}

SuperMarket product1 =
        new SuperMarket();

No error.

Meaning Java generated a constructor behind the scenes.

Important Twist

Now write your own constructor.

class SuperMarket {

    String name;
    int price;

    public SuperMarket(String name, int price) {

        this.name = name;
        this.price = price;

    }
}

Now try:

SuperMarket product1 =
        new SuperMarket();

Error:

constructor SuperMarket in class SuperMarket
cannot be applied to given types;

required: String,int
found: no arguments

Why?

Because once you create your own constructor, Java stops generating the default constructor.

This surprises many beginners.

How To Fix This Error

Create your own no-argument constructor.

class SuperMarket {

    String name;
    int price;

    public SuperMarket() {

    }

    public SuperMarket(String name, int price) {

        this.name = name;
        this.price = price;

    }
}

Now both work:

new SuperMarket();

and

new SuperMarket("Rice", 200);

No errors.

Real-World Benefit of Constructors

Without constructor:

SuperMarket product =
        new SuperMarket();

product.name = "Rice";
product.price = 200;

With constructor:

SuperMarket product =
        new SuperMarket("Rice", 200);

Cleaner.

Shorter.

Less code.

Less mistakes.

More professional.

And when your project contains thousands of objects, constructors save a huge amount of time.

Conclusion

We started with manually assigning values to every object:

product1.name = "Rice";
product1.price = 200;

This works for a few objects but becomes difficult when dealing with hundreds or thousands of products.

To solve this problem, Java provides constructors.

A constructor:

Has the same name as the class
Does not need a return type
Runs automatically when an object is created
Helps initialize objects with specific values

We also learned:

Why name = name is a bug
Why this.name = name works
How constructors are automatically called
What a default constructor is
When Java creates a default constructor
Why the default constructor disappears after creating our own constructor
How to fix related errors

Once you understand constructors, object creation in Java becomes much more organized, cleaner, and easier to manage—especially in real-world applications where classes may create thousands of objects.

References

Oracle Java Tutorials – Constructors

https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

Oracle Java Tutorials – The this Keyword

https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

Oracle Java Tutorials – Classes and Objects

https://docs.oracle.com/javase/tutorial/java/javaOO/

Java Language Specification (JLS)

https://docs.oracle.com/javase/specs/

Oracle Java Documentation

https://docs.oracle.com/en/java/

From Java Methods to Method Overloading: A Complete Beginner's Guide to Compile-Time Polymorphism

Kathirvel S — Mon, 01 Jun 2026 16:28:01 +0000

Introduction

When most beginners start learning Java, they spend a lot of time understanding variables, data types, classes, and objects. While these concepts are important, there is another concept that gives life to an object: methods.

Imagine you have a mobile phone.

The phone contains data:

Brand
Model
Storage
Battery Percentage

But simply having data is not enough.

A phone can also perform actions:

Make a call
Send a message
Open an application
Take a picture

In Object-Oriented Programming (OOP), data is represented using variables, while actions are represented using methods.

Without methods, objects would simply hold information. They would not be able to perform any meaningful work.

According to Oracle's Java Documentation, a method is a collection of statements that perform a specific operation. In simple terms, a method is a reusable block of code that performs a particular task.

In this article, we will take a complete journey through:

Objects and non-static variables
Accessing methods through objects
Understanding what methods are
Learning every keyword used in method creation
Return types and the return keyword
Parameters and arguments
Common compile-time errors
Method Overloading
Compile-Time Polymorphism

By the end of this article, you will understand not only how methods work but also why Method Overloading is called Compile-Time Polymorphism.

Let's begin from the very beginning.

Objects Access Non-Static Variables

Before understanding methods, we must understand how objects interact with variables.

Consider the following class:

class Student {

    String name = "Rahul";

}

Here:

String name = "Rahul";

is called an instance variable or non-static variable.

Official Definition

According to Oracle Java Documentation, instance variables belong to an object instance. Every object created from a class gets its own copy of instance variables.

Beginner-Friendly Explanation

Think of a class as a blueprint and an object as the real thing created from that blueprint.

Example:

Class → Student
Object → Rahul, Priya, Arjun

Every student object can have its own name.

To access an instance variable, we need an object.

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

        System.out.println(s.name);

    }

}

Output:

Rahul

Notice:

s.name

This follows the pattern:

object.variable

The object s is being used to access the variable name.

Common Beginner Error

System.out.println(name);

Error:

cannot find symbol

Why?

Because name belongs to the object, not directly to the main method.

Fix:

System.out.println(s.name);

Key takeaway:

Non-static variables are accessed using object.variable.

Objects Can Also Access Methods

Objects do not only access variables.

They can also access methods.

Let's create a simple method.

class Student {

    void study() {

        System.out.println("Student is studying");

    }

}

Create an object:

Student s = new Student();

Call the method:

s.study();

Output:

Student is studying

This follows the pattern:

object.method();

Real-World Analogy

Imagine a TV remote.

When you press a button, an action happens.

Similarly:

s.study();

asks the object to perform the behavior called study().

Methods are often called the behavior of an object.

What Happens If the Method Does Not Exist?

Suppose we write:

Student s = new Student();

s.play();

But inside Student:

class Student {

    void study() {

    }

}

There is no play() method.

Error:

cannot find symbol
symbol: method play()
location: variable s of type Student

Why Does This Error Occur?

Java checks everything before running the program.

The compiler asks:

Does the class exist?
Does the object exist?
Does the method exist?

Since play() cannot be found, compilation fails.

Important Rule:

A method must be declared before it can be called.

What Exactly Is a Method?

Oracle Documentation defines a method as:

A collection of statements grouped together to perform an operation.

Beginner-Friendly Definition

A method is a reusable block of code that performs a specific task.

Examples:

Calculating salary
Printing information
Finding the largest number
Sending an email

Without methods:

System.out.println("Hello");
System.out.println("Hello");
System.out.println("Hello");

With methods:

greet();
greet();
greet();

Methods help achieve:

Reusability
Readability
Maintainability
Modularity

Creating Your First Method

Example:

public void printActivity() {

    System.out.println("Learning Java");

}

This method prints a message.

But what does each keyword mean?

Let's break it down.

Understanding Every Keyword in a Method

public

public

Official Meaning

An access modifier that makes a member accessible from anywhere.

Beginner-Friendly Meaning

Anyone can use this method.

Think of it as an open door.

Example:

public void printActivity()

means:

"This method can be accessed by other classes."

void

void

Official Meaning

The method returns no value.

Beginner-Friendly Meaning

The method performs work but gives nothing back.

Example:

void greet() {

    System.out.println("Hello");

}

It prints something but does not return any value.

printActivity

printActivity

This is the method name.

Java uses the method name to identify which method to execute.

Good method names should describe the action being performed.

Examples:

calculateSalary()
sendEmail()
printActivity()

Bad examples:

abc()
xyz()
doit()

Parentheses ()

()

Used to hold parameters.

Currently:

()

means no parameters.

Curly Braces {}

{
}

The method body.

The actual statements execute inside these braces.

Return Types in Java

Every method must specify what type of value it returns.

Example:

public int getAge() {

    return 25;

}

Here:

int

means the method returns an integer.

Why Does Java Need a Return Type?

Before compilation, Java must know:

"What kind of value will this method send back?"

That's why return types are mandatory.

Error: Missing Return Type

Wrong:

public getAge() {

    return 25;

}

Error:

invalid method declaration; return type required

Why?

Java does not know what type of value will be returned.

Fix:

public int getAge() {

    return 25;

}

Understanding the return Keyword

The keyword:

return

sends a value back to the caller.

Example:

public int getAge() {

    return 25;

}

Usage:

int age = getAge();

System.out.println(age);

Output:

Flow:

Method Call
    ↓
Method Executes
    ↓
return 25
    ↓
Caller Receives 25

Why Do We Use void?

Consider:

void greet() {

    System.out.println("Hello");

}

The method simply performs an action.

Nothing needs to be returned.

Therefore:

void

is used.

Rule:

Do work only → void

Return value → int, String, double, boolean, etc.

Parameters and Arguments

This is one of the most commonly confused topics.

Parameter

void greet(String name)

name is a parameter.

Argument

greet("Rahul");

"Rahul" is an argument.

Simple rule:

Method Definition → Parameters

Method Call → Arguments

Think of parameters as placeholders and arguments as actual values.

No-Argument Method

Method:

void greet() {

    System.out.println("Hello");

}

Call:

greet();

Output:

Hello

Error: Passing an Argument to a No-Argument Method

Method:

void greet() {

}

Call:

greet("Rahul");

Error:

method greet cannot be applied to given types

Fix:

void greet(String name)

One-Parameter Method

Method:

void greet(String name) {

    System.out.println("Hello " + name);

}

Call:

greet("Rahul");

Output:

Hello Rahul

Error: Missing Required Argument

Method:

void greet(String name)

Call:

greet();

Error:

method greet cannot be applied to given types

Why?

The method expects one argument but receives none.

Fix:

greet("Rahul");

Two-Parameter Method

Method:

void add(int a, int b) {

    System.out.println(a + b);

}

Call:

add(10, 20);

Output:

Error: Passing One Argument Instead of Two

Call:

add(10);

Error:

method add cannot be applied to given types

Fix:

add(10, 20);

String Parameters

Method:

void display(String name) {

    System.out.println(name);

}

Correct:

display("Java");

Output:

Java

Error: Passing Wrong Data Type

Method:

display(String name);

Call:

display(100);

Error:

incompatible types

Reason:

Method expects:

String

but receives:

int

Fix:

display("100");

Why Method Overloading Exists

Imagine a printing system.

Without overloading:

printInt()
printString()
printDouble()
printTwoNumbers()

Too many method names.

Difficult to remember.

Java provides a cleaner solution.

Method Overloading

Official Definition

Method Overloading is the ability to define multiple methods with the same name but different parameter lists.

Example:

class Printer {

    void print() {
        System.out.println("No Data");
    }

    void print(int num) {
        System.out.println(num);
    }

    void print(String text) {
        System.out.println(text);
    }

    void print(int a, int b) {
        System.out.println(a + b);
    }

}

Calls:

print();

print(10);

print("Java");

print(10, 20);

Output:

No Data
10
Java
30

Notice:

Same method name.

Different parameter lists.

That is Method Overloading.

Rules of Method Overloading

Valid:

print()
print(int)
print(String)
print(int, int)

Invalid:

int print()

String print()

Changing only the return type is not overloading.

The parameter list must be different.

What Is Compile-Time Polymorphism?

The word polymorphism comes from:

Poly = Many

Morph = Forms

Meaning:

One Name
Many Forms

Example:

print()
print(int)
print(String)
print(int, int)

All methods share the same name.

But each has a different form.

Why Is Method Overloading Called Compile-Time Polymorphism?

Consider:

print(10);

During compilation, Java checks:

void print(int num)

For:

print("Java");

Java checks:

void print(String text)

The decision happens before the program runs.

That means the compiler determines which method should execute.

Therefore:

Method Overloading
        ↓
Method Selected During Compilation
        ↓
Compile-Time Polymorphism

It is also called:

Static Polymorphism

because the method resolution happens during compile time rather than runtime.

Final Summary

In this article, we started with the fundamentals of objects and non-static variables. We learned how objects access data using the dot operator and how methods represent the behavior of an object.

We explored what methods are, why they exist, and how they help us write reusable and maintainable code. We broke down every component of a method, including public, void, method names, parentheses, and method bodies.

We then moved into return types and the return keyword, understanding how methods can send values back to the caller. After that, we learned the difference between parameters and arguments and examined common compile-time errors that beginners frequently encounter.

Finally, we reached Method Overloading. Instead of creating many methods with different names, Java allows us to use the same method name for multiple operations by changing the parameter list.

This feature is called Method Overloading, and because Java determines the correct method during compilation, it is known as Compile-Time Polymorphism.

The most important takeaway from this entire journey is:

Method Overloading allows one method name to have multiple forms, and Java selects the correct form during compilation. This ability is what makes Method Overloading an example of Compile-Time Polymorphism.

Understanding methods thoroughly is one of the strongest foundations you can build as a Java developer. Almost every Java application—from simple console programs to enterprise-level systems—relies heavily on methods. Mastering them today will make advanced topics such as inheritance, runtime polymorphism, interfaces, and design patterns much easier to understand in the future.

Happy Coding!

References

Oracle Java Tutorials – Methods
https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html
Oracle Java Tutorials – Objects
https://docs.oracle.com/javase/tutorial/java/javaOO/objects.html
Java Language Specification – Methods
https://docs.oracle.com/javase/specs/
Oracle Java Tutorials – Passing Information to a Method or Constructor
https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html

How to Find a Prime Number in Python — A Thinking Journey

Kathirvel S — Mon, 01 Jun 2026 03:20:38 +0000

Introduction

Understanding how to find prime numbers is one of the best ways to develop logical thinking in programming. It looks simple on the surface, but it teaches you how to break a problem into smaller steps, build a solution gradually, and then improve it into a clean and reusable structure.

In this blog, we will not jump directly into code. Instead, we will start from basic thinking, slowly convert that thinking into logic, and finally refine it into a proper Python program using functions and loops. The goal is not just to find prime numbers, but to understand how programming logic is actually built in real development.

1. Understanding the Problem First

Before writing anything in Python, we need to understand what a prime number actually means.

A prime number is a number that:

is greater than 1
has exactly two divisors: 1 and itself

So the real question becomes:

How do we check whether a number has any divisors other than 1 and itself?

That is the core problem we are trying to solve.

2. Thinking Like a Human Before Coding

Let’s take a number, for example 13.

To check if 13 is prime, we naturally try dividing it by smaller numbers:

2 → does not divide 13
3 → does not divide 13
4 → does not divide 13
5 → does not divide 13
and so on

If none of these numbers divide 13 completely, then 13 is prime.

So the logic is simple:

Try dividing the number by possible candidates and see if any divide it perfectly.

3. Turning Thinking into a Basic Algorithm

From the above idea, we can form a basic structure:

We need:

a number to test
a variable that moves through possible divisors
a way to detect whether a divisor exists

We start checking from 2 because every number is divisible by 1 anyway.

We also do not need to check beyond half of the number, because a number cannot have a divisor greater than half (except itself).

So the idea becomes:

Start divisor from 2
Go up to number // 2
If any number divides it evenly, it is not prime

4. First Working Logic (Direct Implementation)

Now we translate the idea into Python.

We introduce:

number: the value we are testing
divisor: the number we try dividing with
divisor_count: how many divisors we find

If divisor_count stays zero, the number is prime.

number = 13
divisor = 2
divisor_count = 0

while divisor <= number // 2:
    if number % divisor == 0:
        print("divisor found:", divisor)
        divisor_count += 1
    divisor += 1

if divisor_count == 0:
    print("Prime")
else:
    print("Not Prime")

Flow Chart:

Start
  ↓
Initialize number, divisor = 2, divisor_count = 0
  ↓
Check divisor <= number//2
  ↓
Is number divisible by divisor?
      ↓ Yes → increment divisor_count
      ↓ No  → continue
  ↓
Increase divisor
  ↓
Repeat loop
  ↓
If divisor_count == 0 → Prime
Else → Not Prime
  ↓
End

5. Understanding What Happens Here

This logic works like a manual test:

We are checking every possible divisor one by one.

If even one divisor divides the number completely, we mark it as non-prime.

Otherwise, it is prime.

So effectively:

No divisors found → Prime
At least one divisor found → Not Prime

6. The Problem With This Approach

Although this works, it has a major issue.

If we want to check multiple numbers, we would need to repeat the same logic again and again.

This leads to:

repeated code
harder maintenance
low reusability

So we need a better structure.

7. Introducing Functions in Python

A function is a reusable block of code that performs a specific task.

Instead of rewriting logic every time, we can define it once and reuse it whenever needed.

From the official Python documentation:

A function is a group of statements that performs a specific task.

Reference:
https://docs.python.org/3/tutorial/controlflow.html#defining-functions

8. Simple Example to Understand Functions

Before applying it to primes, let’s understand a simple function idea.

def buy_nonveg():
    return "chicken"

bag = buy_nonveg()
print(bag)

Flow Chart:

Call function buy_nonveg()
  ↓
Execute function body
  ↓
return "chicken"
  ↓
Store result in bag
  ↓
Print bag
  ↓
End

9. Understanding the return Keyword

The return statement is used to send a result back from a function.

From Python documentation:

The return statement exits a function and optionally passes back an expression.

Reference:
https://docs.python.org/3/reference/simple_stmts.html#the-return-statement

In simple terms:

A function processes something
return sends the result back
after return, the function stops executing

You can think of it as:

Input → Processing → Output

return is the output step.

10. Converting Prime Logic into a Function

Now we take our earlier logic and wrap it inside a function so it becomes reusable.

def find_prime(no):
    div = 2
    divisors_count = 0

    while div <= no // 2:
        if no % div == 0:
            divisors_count += 1
        div += 1

    if divisors_count == 0:
        return True
    else:
        return False

Flow Chart:

Start function find_prime(no)
  ↓
Initialize div = 2, divisors_count = 0
  ↓
Check div <= no//2
  ↓
Is no divisible by div?
      ↓ Yes → increment divisors_count
      ↓ No  → continue
  ↓
Increase div
  ↓
Repeat loop
  ↓
If divisors_count == 0
      ↓ Yes → return True
      ↓ No  → return False
  ↓
End function

11. Understanding This Function

This function does the following:

takes a number as input
checks all possible divisors
counts how many divisors exist
returns True if no divisors are found
returns False otherwise

So now instead of writing full logic every time, we simply call this function.

12. Using the Function (But Still Not Efficient)

Now we try to use this function to check multiple numbers.

no = 2

result = find_prime(no)
if result == True:
    print(no)

no += 1
result = find_prime(no)
if result == True:
    print(no)

no += 1
result = find_prime(no)
if result == True:
    print(no)

Flow Chart:

Start
  ↓
Set no = 2
  ↓
Call find_prime(no)
  ↓
If result == True → print no
  ↓
Increase no
  ↓
Repeat manually
  ↓
End

13. The Problem Again

Even though logic is now reusable, usage is still repetitive.

We are still manually:

increasing numbers
calling function again and again

This is not scalable.

So we need another improvement.

14. Using a Loop to Remove Repetition

Instead of repeating the same steps, we can automate the process using a loop.

def find_prime(no):
    div = 2
    divisors_count = 0

    while div <= no // 2:
        if no % div == 0:
            divisors_count += 1
        div += 1

    return divisors_count == 0


no = 2

while no <= 10:
    if find_prime(no):
        print(no)
    no += 1

Flow Chart:

Start
  ↓
Set no = 2
  ↓
Check no <= 10
  ↓
Call find_prime(no)
  ↓
If True → print no
  ↓
Increment no
  ↓
Repeat loop
  ↓
End when no > 10

15. What Changed Here

Now the structure is much cleaner:

Loop handles number progression
Function handles prime checking
Output is handled separately

This separation is important in programming design.

16. Final Improved Version (Cleaner Logic)

We can further improve the function by removing unnecessary counting.

We only need to know whether a divisor exists or not.

def is_prime(n):
    if n < 2:
        return False

    div = 2
    while div <= n // 2:
        if n % div == 0:
            return False
        div += 1

    return True

Flow Chart:

Start function is_prime(n)
  ↓
If n < 2 → return False
  ↓
Set div = 2
  ↓
Check div <= n//2
  ↓
If n % div == 0 → return False
  ↓
Increment div
  ↓
Repeat loop
  ↓
If no divisor found → return True
  ↓
End function

And usage becomes:

for num in range(2, 11):
    if is_prime(num):
        print(num)

Flow Chart:

Start
  ↓
Loop num from 2 to 10
  ↓
Call is_prime(num)
  ↓
If True → print num
  ↓
Repeat loop
  ↓
End

17. Final Understanding

At a high level, prime checking is simply:

Try dividing the number
If anything divides it evenly → not prime
If nothing divides it → prime

Everything else in code is just structuring this idea properly.

18. Key Learning Path

What we built step by step:

Manual reasoning
Basic loop logic
First implementation
Identifying repetition problem
Introducing functions
Understanding return
Refactoring into reusable design
Removing redundancy with loops
Final clean implementation

Conclusion

What looks like a simple “prime number program” is actually a complete demonstration of how programming logic evolves in real software development.

We started with raw human thinking, converted it into a working algorithm, noticed its limitations, introduced functions for reusability, and finally optimized it into a clean and scalable solution.

This is exactly how real developers think: not by writing perfect code at once, but by building, observing problems, and improving step by step.

If you understand this flow, you are not just learning prime numbers — you are learning how to think like a programmer.

Static vs Non-Static in Java: Understanding Class and Object Through a Shop Story

Kathirvel S — Sun, 31 May 2026 14:04:36 +0000

Imagine You're Standing Outside a Shop...

Have you ever noticed something interesting when you walk past a shop?

Even before entering, you can see the shop's name board.

"Fresh Mart"

You don't need to enter the shop to know its name. It's visible to everyone from outside.

But what about the products?

Can you see all the products from outside?

No.

To access products, you must enter the shop.

Now let's connect this simple real-world example to Java.

Meet Our Java Shop

Imagine this Java class:

public class Shop {

    static int age = 20;
    static String name = "Fresh Mart";

    String prod_name;
}

Think of it this way:

Shop Story	Java Concept
Shop building	Class
Shop name board	Static variable
Product inside shop	Non-static variable
Entering the shop	Creating an object

What Is a Class?

According to the Java documentation:

A class is a blueprint or template from which objects are created.

In simple words:

A class describes what something should look like.

For example:

public class Shop {
    static String name;
    String prod_name;
}

This does not create an actual shop.

It only describes:

A shop has a name.
A shop can contain products.

Think of it like an architect's building plan.

A plan is not the actual building.

Similarly:

A class is not an object.

It is only the blueprint.

Think of a class as:

Recipe
Template
Blueprint
Design
Instruction Sheet

Why Do We Need Classes?

Imagine a city with 10,000 shops.

Would you write separate code for every shop?

shop1
shop2
shop3
shop4
...

That would be a nightmare.

Instead, we create one blueprint:

class Shop

And then create many shop objects from it.

Benefits:

✅ Reusability

✅ Better organization

✅ Less code duplication

✅ Easier maintenance

What Is an Object?

If a class is the blueprint...

An object is the real thing created from that blueprint.

Example:

Blueprint:

House Design

Actual house:

House #1
House #2
House #3

Similarly:

Class:

Shop

Objects:

Shop s1 = new Shop();

Shop s2 = new Shop();

Now we have two real shop objects.

Each object gets its own storage.

Why Do We Need Objects?

Imagine there are 10,000 shops.

Would we create 10,000 classes?

Shop1
Shop2
Shop3
Shop4
...

❌ Impossible to maintain.

Instead:

class Shop

One class.

Many objects.

Shop s1 = new Shop();

Shop s2 = new Shop();

Shop s3 = new Shop();

Advantages:

✅ Reusable

✅ Organized

✅ Saves code

✅ Models real-world entities

The Most Important Line in Java

Look carefully:

Shop s1 = new Shop();

Most beginners see one line.

Java sees several steps.

Let's break it apart.

Step 1: `Shop`

Shop

This is the class type.

It tells Java:

"The variable I'm about to create will store a Shop object."

Similar to:

int age;
String name;

Here:

Shop s1;

means:

s1 can store a Shop reference.

Step 2: `s1`

Shop s1;

s1 is a reference variable.

Think of it as:

Address Holder
Pointer
Reference
Remote Control

Initially:

s1
 |
 v
null

No object exists yet.

Step 3: `new`

new

This is where the magic happens.

new tells Java:

"Allocate memory and create a brand new object."

Without new:

Shop s1;

No shop is created.

With new:

new Shop();

Java creates a fresh object in memory.

Step 4: `Shop()`

Shop()

This calls the constructor.

Think of it as:

Opening a new shop
Initializing the shop
Preparing the shop

Java creates memory and prepares all variables.

What Happens Internally?

When Java sees:

Shop s1 = new Shop();

Java roughly performs:

Create memory

Memory

+----------------+
| prod_name=null |
+----------------+

Then:

Store address in s1

s1
 |
 |-------> Object
           +----------------+
           | prod_name=null |
           +----------------+

Creating Another Object

Shop s2 = new Shop();

Now Java allocates another memory block.

s1
 |
 v
+----------------+
| prod_name=null |
+----------------+

s2
 |
 v
+----------------+
| prod_name=null |
+----------------+

Notice:

These are two separate objects.

Separate memory.

Separate data.

What Happens After Assignments?

s1.prod_name = "Rice";

s2.prod_name = "Milk";

Memory becomes:

s1
 |
 v
+----------------+
| prod_name=Rice |
+----------------+

s2
 |
 v
+----------------+
| prod_name=Milk |
+----------------+

Each object stores its own value.

Where Does Static Memory Live?

Consider:

public class Shop {

    static String name = "Fresh Mart";

    String prod_name;
}

Many beginners think:

Every object stores name.

Wrong.

Static variables are stored once per class.

Visual Memory Layout

CLASS AREA (Method Area)

Shop Class
+-----------------------+
| name = Fresh Mart     |
+-----------------------+



HEAP MEMORY

Object s1
+-----------------------+
| prod_name = Rice      |
+-----------------------+

Object s2
+-----------------------+
| prod_name = Milk      |
+-----------------------+

Only one copy of:

static String name

exists.

No matter how many objects you create.

Why Static Saves Memory

Imagine:

Shop s1
Shop s2
Shop s3
...
Shop s1000

If name were non-static:

Fresh Mart
Fresh Mart
Fresh Mart
Fresh Mart
...
1000 times

Huge waste.

Instead:

static String name

One copy.

All objects share it.

             Fresh Mart
                 ^
                 |
      -------------------------
      |           |           |
     s1          s2          s3

Static vs Non-Static Memory Diagram

CLASS AREA

+--------------------------------+
| Shop.name = Fresh Mart         |
| Shop.age  = 20                 |
+--------------------------------+



HEAP

s1
 |
 v
+--------------------------------+
| prod_name = Rice               |
+--------------------------------+


s2
 |
 v
+--------------------------------+
| prod_name = Milk               |
+--------------------------------+

What Is Static?

Remember the shop name board?

Everyone can see it without entering the shop.

That's exactly how static members work.

Example:

static String name = "Fresh Mart";

You can access it directly through the class:

System.out.println(Shop.name);

No object required.

Because static belongs to the class itself.

Why Static Exists

Imagine there are 1,000 shop objects.

Should every object store the same shop name?

That wastes memory.

Instead:

static String name = "Fresh Mart";

Only one copy exists.

All objects share it.

Benefits:

✅ Memory efficient

✅ Faster access

✅ Shared information

What Is Non-Static?

Products inside the shop are different.

One shelf contains:

Rice

Another shelf contains:

Milk

Each shop object stores its own products.

Example:

String prod_name;

This is non-static.

Every object gets its own copy.

Access:

product.prod_name

Not:

Shop.prod_name

Because the product belongs to a specific shop object.

Static vs Non-Static

Static	Non-Static
Belongs to class	Belongs to object
One copy exists	Separate copy per object
Access using class name	Access using object
Memory efficient	Stores object-specific data
Created when class loads	Created when object is created

Code to the Story

public class Shop {

    // Visible from outside
    static int age = 20;
    static String name = "Fresh Mart";

    // Inside the shop
    String prod_name;

    public static void main(String[] args) {

        Shop product = new Shop();
        product.prod_name = "First Product";

        Shop product2 = new Shop();
        product2.prod_name = "Second Product";

        System.out.println("=== Looking from outside ===");

        System.out.println("Shop Age: " + Shop.age);
        System.out.println("Shop Name: " + Shop.name);



        System.out.println("=== Entering Shop ===");

        System.out.println(product.prod_name);
        System.out.println(product2.prod_name);
    }
}

Output:

=== Looking from outside ===
Shop Age: 20
Shop Name: Fresh Mart

=== Entering Shop ===
First Product
Second Product

See the difference?

Outside:

Shop.age
Shop.name

Inside:

product.prod_name
product2.prod_name

How to Print Static Variables

Static variables belong to the class.

System.out.println(Shop.age);
System.out.println(Shop.name);

Output:

20
Fresh Mart

How to Print Non-Static Variables

Create an object first.

Shop product = new Shop();

product.prod_name = "Laptop";

System.out.println(product.prod_name);

Output:

Laptop

When Should You Use Static?

Use static when data is shared by all objects.

Examples:

Company Name
Tax Rate
Application Version
Counter
Constants
Utility Methods

Example:

static String company = "ABC Ltd";

Every employee object uses the same company name.

When Should You Use Non-Static?

Use non-static when every object needs its own value.

Examples:

Student Name
Employee Salary
Car Number
Product Name
Account Balance

Example:

String studentName;

Every student has a different name.

Where Are These Memories Stored in JVM?

Think of the JVM as having three important areas.

Stack Memory

Stores:

s1
s2
product
product2

Reference variables live here.

STACK

s1 ------+
s2 ------+

Heap Memory

Stores actual objects.

HEAP

Object 1
Object 2
Object 3

Whenever you write:

new Shop();

Memory is allocated in the Heap.

Method Area (Class Area)

Stores:

Class metadata
Static variables
Static methods

Example:

static String name;
static int age;

These are stored once in the Method Area.

METHOD AREA

Shop.name
Shop.age

Complete JVM Memory Picture

METHOD AREA
+-------------------------+
| Shop.name = Fresh Mart  |
| Shop.age  = 20          |
+-------------------------+


STACK
+-------------------------+
| s1 -> Object1           |
| s2 -> Object2           |
+-------------------------+


HEAP
+-------------------------+
| Object1                 |
| prod_name = Rice        |
+-------------------------+

+-------------------------+
| Object2                 |
| prod_name = Milk        |
+-------------------------+

Now you can actually visualize what happens when Java executes:

Shop s1 = new Shop();

Quick Challenge For You

Before reading the answer, guess the output:

public class Shop {

    static String name = "Fresh Mart";

    String product;

    public static void main(String[] args) {

        Shop s1 = new Shop();
        Shop s2 = new Shop();

        s1.product = "Rice";
        s2.product = "Milk";

        System.out.println(name);

        System.out.println(s1.product);

        System.out.println(s2.product);
    }
}

Think...

Ready?

Output:

Fresh Mart
Rice
Milk

Why?

Because:

name is shared by the class.
product belongs to each object separately.

Final Takeaway

Whenever you're confused between static and non-static, remember the shop story.

Shop Name Board = Static

Everyone can access it without entering.

Products Inside the Shop = Non-Static

You must enter a specific shop object to access them.

And remember:

Class = Blueprint
Object = Real thing created from the blueprint
Static = Shared by everyone
Non-Static = Unique to each object

Whenever you see:

Shop s1 = new Shop();

Read it like this:

Shop      -> Type of object

s1        -> Reference variable

new       -> Allocate new memory

Shop()    -> Create and initialize object

Visualize:

s1
 |
 v
+------------------+
| Shop Object      |
+------------------+

Once you understand this memory picture, static vs non-static stops being something to memorize and becomes something you can actually see happening inside the JVM.

References

Official Java Documentation:

Java Classes and Objects: https://docs.oracle.com/javase/tutorial/java/javaOO/classes.html
Understanding Class Members (Static and Instance): https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html
The Java Language Specification: https://docs.oracle.com/javase/specs/