DEV Community: Vinayagam

Abstraction in Java: A Complete Guide with Examples

Vinayagam — Sun, 14 Jun 2026 15:53:01 +0000

Introduction

Abstraction is one of the four fundamental principles of Object-Oriented Programming (OOP) in Java. It helps developers focus on what an object does rather than how it does it. By hiding implementation details and exposing only essential features, abstraction makes programs easier to use, maintain, and extend.

For example, when driving a car, we use the steering wheel, brake, and accelerator without knowing the internal working of the engine. Similarly, abstraction in Java hides complex implementation details from the user.

What is Abstraction?

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

In Java, abstraction can be achieved using:

Abstract Classes
Interfaces

The main goal of abstraction is to reduce complexity and increase code reusability.

Abstract Class in Java

An abstract class is a class that cannot be instantiated directly. It may contain both abstract methods (methods without a body) and concrete methods (methods with a body).

Example

Animal.java

Dog.java

Main.java

ouput

Difference Between JDK, JRE, and JVM

Vinayagam — Thu, 11 Jun 2026 12:51:54 +0000

Introduction

When I started learning Java, I often heard the terms JDK, JRE, and JVM. At first, these names sounded confusing because they are closely related. I wondered why Java needed all three and what each one actually does.

After learning more about Java, I realized that understanding JDK, JRE, and JVM is important because they are the foundation of how Java programs are developed and executed. In this blog, I will explain these concepts in a simple way that beginners can easily understand.

What is JVM?

JVM stands for Java Virtual Machine.

The JVM is responsible for running Java programs. When a Java program is compiled, it is converted into a special format called bytecode. The JVM reads this bytecode and converts it into machine code that the computer can understand.

One of the main advantages of the JVM is platform independence. A Java program can run on different operating systems such as Windows, Linux, and macOS because each operating system has its own JVM implementation.

Functions of JVM

Executes Java bytecode
Manages memory
Performs garbage collection
Provides platform independence

In simple terms, the JVM acts like a translator between Java code and the computer.

What is JRE?

JRE stands for Java Runtime Environment.

The JRE provides everything needed to run Java applications. It includes the JVM and the necessary libraries required for execution.

If a user only wants to run a Java application and does not need to write Java code, installing the JRE is sufficient.

Components of JRE

JVM
Java class libraries
Supporting files

Think of the JRE as a package that contains the JVM along with all the resources needed to execute Java programs.

What is JDK?

JDK stands for Java Development Kit.

The JDK is mainly used by developers who want to create Java applications. It contains the JRE and additional tools that help in writing, compiling, debugging, and running Java programs.

When we install Java for development purposes, we usually install the JDK.

Components of JDK

JRE
JVM
Java compiler (javac)
Debugging tools
Development utilities

Without the JDK, developers cannot compile Java source code into bytecode.

Understanding with a Simple Example

Suppose you write a Java program called HelloWorld.java.

Step 1: Write the Code

You create a Java file using a text editor or an IDE.

Step 2: Compile the Program

The compiler provided by the JDK converts the source code into bytecode.

javac HelloWorld.java

This creates a file called HelloWorld.class.

Step 3: Run the Program

The JVM reads the bytecode and executes it.

java HelloWorld

The JRE provides the environment, while the JVM actually runs the program.

Relationship Between JDK, JRE, and JVM

The relationship can be represented as:

JDK
 └── JRE
      └── JVM

This means:

JDK contains JRE
JRE contains JVM
JVM executes Java programs

Real-Life Analogy

A simple way to remember these concepts is by comparing them to a car.

JVM = Engine

The engine performs the actual work of running the car.

JRE = Car

The car contains the engine and everything needed to drive.

JDK = Car Factory

The factory contains all the tools needed to build and test the car.

Just as a factory includes everything required to produce a car, the JDK includes everything required to develop Java applications.

Comparison Table

Feature	JVM	JRE	JDK
Runs Java Programs	Yes	Yes	Yes
Contains JVM	No	Yes	Yes
Contains Libraries	No	Yes	Yes
Contains Compiler	No	No	Yes
Used by Developers	No	No	Yes
Used for Execution	Yes	Yes	Yes

References

Access Modifiers in Java Explained for Beginners

Vinayagam — Thu, 11 Jun 2026 04:39:08 +0000

Introduction

In Java, access modifiers are used to control how variables and methods can be accessed from different places. They are very important for writing safe and organized programs.

There are four types of access modifiers in Java:

public
protected
default
private

In this blog, we will understand these using a simple example with packages and inheritance.

What is an Access Modifier

An access modifier decides where a class, method, or variable can be used.

It answers questions like:

Can it be used inside the same class?
Can it be used in another class?
Can it be used in another package?

Types of Access Modifiers

1. Public

Public members can be accessed from anywhere in the program.

Example:

public int atmPin = 1234;

You can use this variable in any class and any package.

2. Protected

Protected members can be accessed:

Inside the same package
In child classes from different packages

Example:

protected void makeBiriyani() {
    System.out.println("biriyani");
}

3. Default

Default means no access modifier is given.

It can be accessed only inside the same package.

Example:

void show() {
    System.out.println("default method");
}

4. Private

Private members can be accessed only inside the same class.

Example:

private int password = 123;

Example Using Packages

We created two packages:

salem
madurai

This helps us understand how access works between different packages.

Parent Class

package salem;

public class Parent {

    public int atmPin = 1234;

    protected void makeBiriyani() {
        System.out.println("biriyani");
    }

    protected void checkBalance() {
        System.out.println("15000");
    }
}

In this class:

atmPin is public, so it can be accessed anywhere
methods are protected, so they follow special rules

Child Class (Same Package)

package salem;

public class Child extends Parent {

    public static void main(String[] args) {
        Child obj = new Child();
        obj.makeBiriyani();
        obj.checkBalance();
        System.out.println(obj.atmPin);
    }
}

This class is in the same package as Parent.

So:

It can access protected methods directly
It can access public variables

Child2 Class (Different Package)

package madurai;

import salem.Parent;

public class Child2 extends Parent {

    public static void main(String[] args) {
        Child2 obj = new Child2();
        obj.makeBiriyani();
        obj.checkBalance();
        System.out.println(obj.atmPin);
    }
}

This class is in a different package.

Here:

It extends Parent class
So it can use protected methods through inheritance

Access Behavior Based on Location

Let us understand how access changes based on location:

Same class → all modifiers work
Same package → public, protected, default work
Different package (child class) → public and protected work
Different package (non-child class) → only public works

Python Number Programs Using While Loop: Step-by-Step Guide

Vinayagam — Thu, 04 Jun 2026 15:56:36 +0000

Introduction

Number-based problems are essential for improving programming logic. Using Python's while loop, we can solve different types of problems involving divisibility, counting, and special numbers.

This article demonstrates step-by-step solutions using simple logic and structured code.

Basic Practice

1. Print Numbers from 1 to 5

start = 1
while start <= 5:
    print(start, end=" ")
    start = start + 1

2. Print Odd Numbers from 1 to 10

start = 1
while start <= 10:
    if start % 2 != 0:
        print(start)
    start = start + 1

3. Print Multiples of 3 (Ascending)

start = 3
while start <= 15:
    if start % 3 == 0:
        print(start)
    start += 1

4. Print Multiples of 3 (Descending)

start = 15
while start >= 1:
    if start % 3 == 0:
        print(start)
    start = start - 1

5. Print Even Numbers (Descending)

start = 10
while start >= 2:
    if start % 2 == 0:
        print(start)
    start = start - 1

6. Print Odd Numbers (Descending)

start = 10
while start >= 1:
    if start % 2 != 0:
        print(start)
    start = start - 1

7. Divisibility Check for 3 and 5

start = 1
while start <= 50:
    if start % 3 == 0 and start % 5 == 0:
        print("divisible by both", start)
    elif start % 3 == 0:
        print("divisible by 3", start)
    elif start % 5 == 0:
        print("divisible by 5", start)
    start += 1

8. Divisible by 3 or 5

start = 1
while start <= 20:
    if start % 3 == 0 or start % 5 == 0:
        print(start)
    start += 1

9. Finding Divisors of a Number

num = 12
i = 1

while i <= num:
    if num % i == 0:
        print(i)
    i += 1

10. Count of Divisors

num = 12
i = 1
count = 0

while i <= num:
    if num % i == 0:
        count += 1
    i += 1

print("Total divisors:", count)

11. Prime Number Check

num = 7
i = 1
count = 0

while i <= num:
    if num % i == 0:
        count += 1
    i += 1

if count == 2:
    print("Prime Number")
else:
    print("Not a Prime Number")

12. Perfect Number Check

num = 6
i = 1
sum = 0

while i < num:
    if num % i == 0:
        sum += i
    i += 1

if sum == num:
    print("Perfect Number")
else:
    print("Not a Perfect Number")

Explanation

The while loop repeats execution until the condition becomes false
The % operator is used to check divisibility
Logical operators like and and or help combine conditions
Counters are used to track occurrences such as divisors

Beyond Inheritance in Java: A Practical Guide to Composition

Vinayagam — Thu, 04 Jun 2026 15:36:46 +0000

Introduction

In Java, inheritance is commonly used to reuse code using the extends keyword. However, inheritance is not always the best solution. In many real-world applications, developers prefer a more flexible and maintainable approach called composition.

This article explains how to share data both with inheritance and without inheritance, using simple examples, a relatable story, and the role of access modifiers.

A Simple Story to Understand

Consider a School and Student relationship:

A School does not become a Student
A School has Students

This highlights the difference:

Inheritance represents an IS-A relationship
Composition represents a HAS-A relationship

Using Inheritance (IS-A Relationship)

Student.java

package shop;

public class Student {
    protected String name = "Vinay";

    public void showName() {
        System.out.println(name);
    }
}

School.java

package shop;

public class School extends Student {

    public static void main(String[] args) {
        School sc = new School();
        sc.showName();  // inherited method
    }
}

Explanation

School extends Student, meaning School is treated as a Student
This is not logically correct for this scenario
protected allows access within subclasses

Using Composition (Without Inheritance)

Student.java

package shop;

public class Student {
    private String name = "Vinay";

    public String getName() {
        return name;
    }
}

School.java

package shop;

public class School {

    public void display(Student s) {
        System.out.println(s.getName());
    }
}

Main.java

package shop;

public class Main {

    public static void main(String[] args) {
        Student s = new Student();
        School sc = new School();

        sc.display(s);  // HAS-A relationship
    }
}

Role of Access Modifiers

Access modifiers control how data is accessed:

private → accessible only within the same class
protected → accessible in subclasses
public → accessible everywhere

In composition:

Data is kept private
Access is provided through public getter methods

This improves data security and encapsulation.

Inheritance vs Composition

Feature	Inheritance	Composition
Relationship	IS-A	HAS-A
Flexibility	Low	High
Coupling	Tight	Loose
Real-world modeling	Sometimes incorrect	More accurate

When to Use Each

Use inheritance when:

There is a clear IS-A relationship
Example: Dog is an Animal

Use composition when:

There is a HAS-A relationship
Example: School has Students

References

Java OOP Basics: Constructors and Packages Explained Clearly

Vinayagam — Wed, 03 Jun 2026 09:31:58 +0000

Introduction

In Java, constructors are used to initialize objects, while packages are used to organize classes and interfaces. Both concepts are essential for writing clean, structured, and maintainable programs.

This article covers:

Java Packages
Default Constructor
No-Argument Constructor
Parameterized Constructor

What is a Package in Java?

A package in Java is a namespace that groups related classes and interfaces together. It helps in organizing code, avoiding name conflicts, and improving reusability.

Key Points

Packages act like folders in a file system
They help organize large projects
They prevent class name conflicts
They support access control

Syntax

package packagename;

Example

package shop;

public class Product {
    String name;
    int price;
}

To compile:

javac -d . Product.java

To run:

java shop.Product

What is a Constructor?

A constructor is a special method that:

Has the same name as the class
Has no return type
Is automatically called when an object is created

Syntax

ClassName() {
    // initialization code
}

Default Constructor

A default constructor is automatically created by the Java compiler if no constructor is defined.

Example

class Demo {
    int x;

    public static void main(String[] args) {
        Demo d = new Demo();
        System.out.println(d.x);
    }
}

Output:

No-Argument Constructor

A no-argument constructor is explicitly defined and does not take any parameters.

Example

class Product {
    String name;
    int price;

    Product() {
        name = "Biscuit";
        price = 20;
    }

    void display() {
        System.out.println(name + " " + price);
    }

    public static void main(String[] args) {
        Product p = new Product();
        p.display();
    }
}

Output:

Biscuit 20

Parameterized Constructor

A parameterized constructor accepts arguments to initialize variables.

Example

class Product {
    String name;
    int price;

    Product(String n, int p) {
        name = n;
        price = p;
    }

    void display() {
        System.out.println(name + " " + price);
    }

    public static void main(String[] args) {
        Product p1 = new Product("Chocolate", 50);
        Product p2 = new Product("Milk", 30);

        p1.display();
        p2.display();
    }
}

Output:

Chocolate 50
Milk 30

Combining Package and Constructors

Here is a complete example using a package with constructors:

package shop;

public class Product {

    String name;
    int price;

    // No-argument constructor
    Product() {
        name = "Default Item";
        price = 0;
    }

    // Parameterized constructor
    Product(String n, int p) {
        name = n;
        price = p;
    }

    void display() {
        System.out.println(name + " " + price);
    }

    public static void main(String[] args) {
        Product p1 = new Product();
        Product p2 = new Product("Chocolate", 50);

        p1.display();
        p2.display();
    }
}

Difference Between Constructors

Feature	Default Constructor	No-Argument Constructor	Parameterized Constructor
Created By	Compiler	Programmer	Programmer
Parameters	No	No	Yes
Flexibility	Low	Medium	High

Common Mistake

Default constructor and no-argument constructor are not the same.

Default constructor is automatically provided by the compiler
No-argument constructor is written by the programmer

Constructors in Java with Default Constructor Explained

Vinayagam — Tue, 02 Jun 2026 09:50:17 +0000

Introduction

In Java, constructors play a crucial role in initializing objects. Whenever an object is created, a constructor is automatically invoked to assign initial values and set up the object properly. Understanding constructors is essential for writing clean and efficient object-oriented programs.

This article explains constructors in Java, focusing especially on the default constructor, its behavior, and how it differs from user-defined constructors.

What is a Constructor?

A constructor in Java is a special method used to initialize objects. It has the same name as the class and does not have a return type, not even void.

Key Characteristics:

Same name as the class
No return type
Automatically called when an object is created
Used to initialize instance variables

Example:

class Student {
    String name;
    int age;

    // Constructor
    Student() {
        name = "Unknown";
        age = 0;
    }

    void display() {
        System.out.println(name + " " + age);
    }

    public static void main(String[] args) {
        Student s = new Student();
        s.display();
    }
}

Types of Constructors in Java

1. Default Constructor

A default constructor is a constructor that is automatically provided by the Java compiler if no constructor is defined in the class.

It assigns default values:

int → 0
double → 0.0
boolean → false
String → null

Example:

class Demo {
    int num;
    String text;

    public static void main(String[] args) {
        Demo d = new Demo();
        System.out.println(d.num);   // 0
        System.out.println(d.text);  // null
    }
}

Important Point:

If you create any constructor manually, the compiler will NOT create the default constructor.

2. No-Argument Constructor (User-defined Default-like Constructor)

This is a constructor written by the programmer with no parameters.

class Example {
    int x;

    Example() {
        x = 100;
    }

    public static void main(String[] args) {
        Example e = new Example();
        System.out.println(e.x);
    }
}

3. Parameterized Constructor

A constructor that accepts parameters to initialize values.

class Product {
    String name;
    int price;

    Product(String n, int p) {
        name = n;
        price = p;
    }

    public static void main(String[] args) {
        Product p1 = new Product("Pen", 10);
        System.out.println(p1.name + " " + p1.price);
    }
}

Default Constructor vs User-Defined Constructor

Feature	Default Constructor	User-defined Constructor
Created by	Compiler	Programmer
Parameters	No	Can have parameters
Control	Limited	Full control
Initialization	Default values	Custom values

When is Default Constructor Used?

When no constructor is written in the class
When objects need simple initialization
During object creation in frameworks and libraries

Static vs Instance Methods in Java Explained with Examples

Vinayagam — Mon, 01 Jun 2026 16:27:55 +0000

Introduction

In Java, understanding the difference between static and non-static methods is a fundamental concept that every developer must master. These two types of methods define how a program is structured, how memory is managed, and how objects interact within a class.

Whether you are preparing for interviews or building real-world applications, knowing when and how to use static and non-static methods can greatly improve your coding efficiency and design clarity.

This article explores both concepts in detail, with examples, comparisons, and practical insights.

What is a Static Method?

A static method is a method that belongs to the class rather than an instance (object) of the class. It is declared using the static keyword.

Static methods are commonly used for operations that do not require object-specific data. Since they are associated with the class itself, they can be accessed without creating an object.

Key Characteristics of Static Methods

Declared using the static keyword
Belongs to the class, not to objects
Can be called using the class name
Can access only static variables and static methods directly
Cannot use the this keyword

Example of Static Method

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

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(10, 20);
        System.out.println("Sum: " + result);
    }
}

In this example, the add method is static, so it can be called directly using the class name without creating an object.

What is a Non-Static Method?

A non-static method, also known as an instance method, belongs to an object of a class. To use it, you must create an instance of the class.

These methods are used when operations depend on instance-specific data.

Key Characteristics of Non-Static Methods

Do not use the static keyword
Belong to objects (instances)
Must be called using an object
Can access both static and non-static variables
Can use the this keyword

Example of Non-Static Method

class Student {
    String name;

    void display() {
        System.out.println("Student Name: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Vinay";
        s1.display();
    }
}

Here, the display method is non-static and depends on the object’s data.

Key Differences Between Static and Non-Static Methods

Understanding the differences between these two types of methods is crucial for writing efficient Java programs.

Feature	Static Method	Non-Static Method
Belongs to	Class	Object
Memory Allocation	Once per class	For each object
Method Call	Class name	Object reference
Data Access	Only static members	Static + non-static members
`this` keyword	Not allowed	Allowed
Use Case	Utility/common functions	Object-specific behavior

Why Static Methods Cannot Access Non-Static Members Directly

One of the most common confusion points is why static methods cannot directly access non-static variables.

The reason lies in memory and object creation.

Static methods are loaded when the class is loaded, while non-static variables are created only when an object is instantiated. Since no object exists at the time a static method runs, it cannot directly access instance variables.

Example of Error

class Test {
    int x = 10;

    static void show() {
        // System.out.println(x); // ERROR
    }
}

Correct Approach

static void show() {
    Test obj = new Test();
    System.out.println(obj.x); // Correct
}

Real-Life Analogy

To better understand, consider a real-world example:

A static method is like a company policy. It applies to everyone and does not depend on individual employees.
A non-static method is like an employee’s personal task. It depends on the individual performing it.

This analogy helps clarify why static methods do not rely on object-specific data.

When to Use Static Methods

Static methods are best suited for:

Utility or helper functions (e.g., mathematical calculations)
Methods that do not depend on instance variables
Common operations shared across all objects

Examples include:

Math.sqrt()
Integer.parseInt()

When to Use Non-Static Methods

Non-static methods are ideal when:

Behavior depends on object-specific data
Each object has its own state
You need to use instance variables

Examples include:

Displaying user details
Updating object-specific values
Handling object-based logic

From Logic to Numbers: A Beginner’s Guide to Programming Through Mathematical Thinking

Vinayagam — Sat, 30 May 2026 14:50:58 +0000

Introduction

Programming is not just about writing code—it is about understanding logic, patterns, and mathematical thinking. Every beginner starts with simple concepts such as loops, conditions, and numbers, but these small ideas build the foundation for solving real-world problems.

This blog explores a collection of fundamental programming and mathematical concepts, including loops, number systems, divisibility, perfect numbers, and prime numbers. Each concept is explained using simple logic and practical examples, making it easy for beginners to understand and apply.

Understanding Loops Through a Real Example

One of the most important concepts in programming is iteration. A loop allows us to execute a block of code multiple times without rewriting it.

Consider a situation where we want to find stations that satisfy two conditions:

Divisible by 3
Divisible by 8

Instead of checking each number manually, we use a loop:

Start from station 1
Go up to station 150
Check divisibility conditions
Track first station, last station, and total count

This approach demonstrates:

Efficient problem solving
Use of conditions inside loops
Tracking values dynamically

Key Observations

The first station that satisfies both conditions is the Least Common Multiple (LCM) of 3 and 8.
All such stations are common multiples.
The last station represents the largest multiple within the range.
The count shows how many such numbers exist.

This simple logic is widely used in real-world applications such as scheduling, filtering data, and automation.

Understanding Number Systems

Numbers form the backbone of programming. Let’s explore how numbers are represented.

Binary Representation

Computers understand only binary (0 and 1).

Example:

Character A
Binary: 01000001
Decimal value: 65

This shows how characters are stored internally in memory.

Types of Data

Programming languages support different types of data:

int → Integer values (e.g., 1, 2, 100)
float → Decimal numbers (e.g., 3.14)
complex → Complex numbers
bool → True/False
str → Text values

Understanding data types is essential because it defines how data is stored and processed.

Even and Odd Number Logic

A simple yet powerful concept in programming is determining whether a number is even or odd.

Rule:

If a number is divisible by 2 → Even
Otherwise → Odd

Interesting Observation:

Sum of an odd and even number → Always Odd
Product of numbers can vary depending on inputs

Using conditions like if-else, we can easily determine this in code.

This concept is used in:

Data validation
Game logic
Mathematical computations

Divisibility and Factors

Understanding factors helps us solve many mathematical problems.

Example:
For number 6:

Divisible by 1, 2, 3

These are called factors.

Checking divisibility using modulus operator % is a key programming skill.

Perfect Numbers

A perfect number is a number that is equal to the sum of its proper divisors.

Example:

Number: 6
Factors: 1, 2, 3
Sum: 1 + 2 + 3 = 6

So, 6 is a perfect number.

Logic:

Loop from 1 to number-1
Add all divisors
Compare sum with original number

This teaches:

Looping
Conditional checks
Accumulation logic

Perfect numbers are rare and interesting in mathematics.

Prime Numbers

Prime numbers are numbers that have only two factors:

1 and itself

Examples:

2, 3, 5, 7, 11, 13...

Prime numbers are important in:

Cryptography
Security systems
Algorithm design

Sum of Two Prime Numbers

Another interesting problem is expressing a number as the sum of two prime numbers.

Example:

24 can be written as:

11 + 13
5 + 19

Logic:

Take a number (e.g., 60)
Assume one number (no1)
Calculate second number (no2 = total - no1)
Check if both are prime

This concept improves:

Logical thinking
Problem-solving skills
Understanding of number relationships

Real-World Thinking with Numbers

Even simple numbers can represent real-life ideas:

Station problems → Scheduling systems
Prime numbers → Security algorithms
Binary → Computer memory
Loops → Automation

Programming is not separate from mathematics—it is built on top of it.

Understanding Fields in Java: Static vs Non-Static Explained Clearly

Vinayagam — Fri, 29 May 2026 16:41:24 +0000

Understanding Fields in Java: Static vs Non-Static

Introduction

In Java programming, variables play a crucial role in storing and managing data. Among these variables, fields are especially important because they define the state of a class and its objects. Understanding how fields work—and more importantly, the difference between static and non-static (instance) fields—is essential for mastering object-oriented programming (OOP) concepts in Java.

This article explores fields in depth, explains their types, and demonstrates their behavior with practical examples.

What is a Field in Java?

A field is a variable declared inside a class but outside any method, constructor, or block. Fields represent the properties or attributes of an object.

Syntax Example:

class Car {
    String brand;   // field
    int speed;      // field
}

In this example:

brand and speed are fields of the Car class.
These variables store data related to each object created from the class.

Fields can have different access levels such as private, public, or protected, depending on how they are intended to be used.

Classification of Fields

Fields in Java are primarily classified into:

Instance (Non-Static) Fields
Static Fields (Class Variables)

Each type has different memory behavior, access patterns, and use cases.

Instance (Non-Static) Fields

Instance fields are declared without the static keyword. These fields belong to individual objects of a class.

Example:

class Student {
    String name;
    int age;
}

Behavior:

When objects are created, each object gets its own copy of instance fields.

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();

        s1.name = "Vinay";
        s2.name = "Kumar";

        System.out.println(s1.name); // Vinay
        System.out.println(s2.name); // Kumar
    }
}

Explanation:

s1 and s2 are two different objects.
Each object has its own name field.
Changing one object’s field does not affect the other.

Memory Allocation:

Stored in the heap memory
Separate memory is allocated for each object

Key Characteristics:

Belongs to objects
Requires object creation
Can have different values for different objects
Accessed using object references

Static Fields

Static fields are declared using the static keyword. These fields belong to the class rather than individual objects.

Example:

class Student {
    static String college = "ABC College";
}

Behavior:

Static fields are shared among all objects of the class.

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();

        System.out.println(s1.college); // ABC College
        System.out.println(s2.college); // ABC College
    }
}

Explanation:

Only one copy of college exists.
Both s1 and s2 refer to the same variable.
If one object changes it, all objects see the change.

s1.college = "XYZ College";
System.out.println(s2.college); // XYZ College

Memory Allocation:

Stored in the method area (class area)
Allocated once when the class is loaded

Key Characteristics:

Belongs to the class
Shared among all instances
Memory efficient
Accessed using class name (Student.college)

Static vs Non-Static Fields (Detailed Comparison)

Feature	Instance Field	Static Field
Ownership	Object	Class
Memory Allocation	Heap (per object)	Method Area (single copy)
Access	Object reference	Class name
Value Sharing	No	Yes
Lifecycle	Depends on object	Depends on class loading
Example	name, age	college, counter

Practical Example: Counter

Static fields are often used for counting objects.

class Counter {
    static int count = 0;

    Counter() {
        count++;
    }
}

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

        System.out.println(Counter.count); // 3
    }
}

Explanation:

Every time an object is created, count increases.
Since count is static, it tracks all objects collectively.

Real-World Analogy

Consider a college system:

Student Name → Different for each student → Instance field
College Name → Same for all students → Static field

This separation helps structure data efficiently and avoids unnecessary duplication.

Accessing Fields

Instance Field Access:

Student s = new Student();
s.name = "Vinay";

Static Field Access:

Student.college = "ABC College";

Using the class name for static fields is recommended because it improves readability and clearly indicates shared data.

Common Mistakes

1. Accessing instance field without object

System.out.println(Student.name); // Error

2. Misusing static for unique data

Declaring fields as static when they should be instance-specific can lead to incorrect data sharing.

3. Overuse of static

Excessive use of static fields can reduce flexibility and violate object-oriented principles.

When to Use Static Fields

Static fields are suitable when:

The value is constant or common for all objects
Data should be shared globally within the class
You need to maintain a common counter or configuration

When to Use Instance Fields

Instance fields are appropriate when:

Each object must maintain its own state
Data varies between objects
Object-level customization is required

Internal Working

When a Java program runs:

Class is loaded into memory
Static fields are initialized first
Objects are created later
Instance fields are initialized for each object

This order explains why static variables exist independently of objects.

References

Java SE Documentation – Oracle
https://docs.oracle.com/javase/tutorial/java/javaOO/
Effective Java by Joshua Bloch
Head First Java by Kathy Sierra & Bert Bates
GeeksforGeeks – Java Static Keyword
https://www.geeksforgeeks.org/static-keyword-java/
W3Schools Java Tutorial
https://www.w3schools.com/java/java_variables.asp
Java: The Complete Reference by Herbert Schildt

Java Data Types Made Simple: Primitive vs Non-Primitive Explained

Vinayagam — Thu, 28 May 2026 14:14:39 +0000

Understanding Java Data Types: Primitive and Non-Primitive

Java data types define the type of data a variable can store in a program. They help the compiler allocate memory efficiently, ensure type safety, and improve overall program reliability.

Java is a statically typed language, which means every variable must be declared with a data type before it is used.

Basic Syntax

dataType variableName = value;

Example:

int age = 21;

Why Data Types Are Important?

Memory Allocation → Determines how much memory is required
Operation Support → Defines allowed operations
Type Safety → Prevents invalid assignments
Default Values → Each data type has a default value

Types of Data Types in Java

Java provides two main categories:

Primitive Data Types
Non-Primitive (Reference) Data Types

1. Primitive Data Types

Primitive data types are the most basic types in Java. They store actual values directly in memory and have a fixed size.

Primitive Data Types in Java (Detailed Explanation)

Java provides 8 primitive data types. These are used to store simple values directly in memory and are the foundation of all Java programs.

1. boolean Data Type

The boolean data type represents only two values: true or false. It is mainly used in decision-making statements like if, while, and loops.

Syntax:

boolean isActive;

Example:

public class Main {
    public static void main(String[] args) {
        boolean isJavaFun = true;
        boolean isFishTasty = false;

        System.out.println("Is Java fun? " + isJavaFun);
        System.out.println("Is fish tasty? " + isFishTasty);
    }
}

Output:

Is Java fun? true
Is fish tasty? false

2. byte Data Type

The byte data type is an 8-bit signed integer. It is useful for saving memory in large arrays.

Syntax:

byte value;

Example:

public class Main {
    public static void main(String[] args) {
        byte age = 25;
        byte temperature = -10;

        System.out.println("Age: " + age);
        System.out.println("Temperature: " + temperature);
    }
}

Output:

Age: 25
Temperature: -10

3. short Data Type

The short data type is a 16-bit signed integer used when values are within a moderate range.

Syntax:

short number;

Example:

public class Main {
    public static void main(String[] args) {
        short students = 1000;
        short temp = -200;

        System.out.println("Number of Students: " + students);
        System.out.println("Temperature: " + temp);
    }
}

Output:

Number of Students: 1000
Temperature: -200

4. int Data Type

The int data type is the most commonly used integer type in Java. It is a 32-bit signed integer.

Syntax:

int number;

Size: 4 bytes (32 bits)

Example:

public class Main {
    public static void main(String[] args) {
        int population = 2000000;
        int distance = 150000000;

        System.out.println("Population: " + population);
        System.out.println("Distance: " + distance);
    }
}

Output:

Population: 2000000
Distance: 150000000

5. long Data Type

The long data type is a 64-bit signed integer, used for very large values.

Syntax:

long number;

Size: 8 bytes (64 bits)

Example:

public class Main {
    public static void main(String[] args) {
        long worldPopulation = 7800000000L;
        long lightYears = 9460730472580800L;

        System.out.println("World Population: " + worldPopulation);
        System.out.println("Light Years: " + lightYears);
    }
}

Output:

World Population: 7800000000
Light Years: 9460730472580800

6. float Data Type

The float data type is a 32-bit floating-point type used for decimal values with less precision.

Syntax:

float number;

Size: 4 bytes (32 bits)

Example:

public class Main {
    public static void main(String[] args) {
        float pi = 3.14f;
        float gravity = 9.81f;

        System.out.println("Pi: " + pi);
        System.out.println("Gravity: " + gravity);
    }
}

Output:

Pi: 3.14
Gravity: 9.81

7. double Data Type

The double data type is a 64-bit floating-point type and is the default for decimal values.

Syntax:

double number;

Size: 8 bytes (64 bits)

Example:

public class Main {
    public static void main(String[] args) {
        double pi = 3.141592653589793;
        double avogadro = 6.02214076e23;

        System.out.println("Pi: " + pi);
        System.out.println("Avogadro's Number: " + avogadro);
    }
}

Output:

Pi: 3.141592653589793
Avogadro's Number: 6.02214076E23

8. char Data Type

The char data type is used to store a single character. It uses Unicode and supports multiple languages.

Syntax:

char letter;

Size: 2 bytes (16 bits)

Example:

public class Main {
    public static void main(String[] args) {
        char grade = 'A';
        char symbol = '$';

        System.out.println("Grade: " + grade);
        System.out.println("Symbol: " + symbol);
    }
}

Output:

Grade: A
Symbol: $

2.Non-Primitive (Reference) Data Types in Java

Unlike primitive data types, non-primitive data types do not store actual values directly. Instead, they store references (memory addresses) that point to objects.

These types are more powerful and are used to build real-world applications using Object-Oriented Programming (OOP).

1. String

A String represents a sequence of characters enclosed in double quotes. In Java, strings are objects and are immutable, meaning their value cannot be changed after creation.

Syntax:

```java id="p7t4yr"
String str = "Hello";




**Example:**



```java id="v2h5xq"
public class Main {
    public static void main(String[] args) {
        String name = "Geek1";
        String message = "Welcome to Java";

        System.out.println("Name: " + name);
        System.out.println("Message: " + message);
    }
}

Output:

Name: Geek1
Message: Welcome to Java

Note: Strings cannot be modified after creation. For heavy modifications, use StringBuilder.

2. Class

A class is a user-defined blueprint used to create objects. It defines properties (variables) and behaviors (methods).

Example:

```java id="3n5k9p"
class Car {
String model;
int year;

Car(String model, int year) {
    this.model = model;
    this.year = year;
}

void display() {
    System.out.println(model + " " + year);
}

}

public class Main {
public static void main(String[] args) {
Car myCar = new Car("Toyota", 2020);
myCar.display();
}
}




**Output:**



```id="5l2m1n"
Toyota 2020

3. Object

An object is an instance of a class. It represents real-world entities and contains:

State → Data (variables)
Behavior → Methods
Identity → Unique reference

Example:

```java id="8q1z9w"
class Car {
String model;
int year;

Car(String model, int year) {
    this.model = model;
    this.year = year;
}

}

public class Main {
public static void main(String[] args) {
Car myCar = new Car("Honda", 2021);

    System.out.println("Model: " + myCar.model);
    System.out.println("Year: " + myCar.year);
}

}




**Output:**



```id="1a2b3c"
Model: Honda
Year: 2021

4. Interface

An interface defines a contract that classes must follow. It contains abstract methods that must be implemented.

It helps achieve abstraction and supports multiple inheritance in Java.

Example:

```java id="k4p8w2"
interface Animal {
void sound();
}

class Dog implements Animal {
public void sound() {
System.out.println("Woof");
}
}

public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.sound();
}
}




**Output:**



```id="z8y7x6"
Woof

5. Array

An array is used to store multiple values of the same type in a single structure. Arrays in Java are objects, dynamically allocated, and indexed starting from 0.

Example:

```java id="j9v2t6"
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"Geek1", "Geek2", "Geek3"};

    System.out.println("First number: " + numbers[0]);
    System.out.println("Second name: " + names[1]);
}

}




**Output:**



```id="l0m9n8"
First number: 1
Second name: Geek2

References

GeeksforGeeks – Java Data Types
https://www.geeksforgeeks.org/java/java-data-types/
Programiz – Java Primitive Data Types
https://www.programiz.com/java-programming/variables-primitive-data-types

Becoming a Full Stack Developer with Java

Vinayagam — Wed, 27 May 2026 13:55:39 +0000

Introduction

Programming languages have evolved continuously to solve real-world problems more efficiently. Among these, C++ played a major role in system-level and application development. However, as software requirements grew more complex, developers started facing limitations with C++. This led to the creation of Java, a language designed to overcome many of those challenges.

Java was introduced by James Gosling and his team at Sun Microsystems in 1995. The main goal of Java was to make programming simpler, more secure, and platform-independent. This blog explains why Java came after C++ and highlights the important features that make Java one of the most popular programming languages today.

Why Java Came from C++

C++ is a powerful language, but it also has several drawbacks that made development difficult, especially for large-scale applications. Java was created to solve these problems.

1. Complexity of C++

C++ supports many features like pointers, multiple inheritance, operator overloading, and manual memory management. While these features provide flexibility, they also increase complexity.

For beginners, understanding pointers and memory allocation is very difficult. Even experienced developers can make mistakes that lead to serious issues like memory leaks or crashes.

Java was designed to remove unnecessary complexity. It avoids pointers and simplifies many concepts, making it easier to learn and use.

2. Memory Management Problems

In C++, developers must manually manage memory using functions like new and delete. If memory is not properly released, it leads to memory leaks, which can slow down or crash the program.

Java solves this problem using automatic garbage collection. The system automatically removes unused objects from memory. This reduces the burden on developers and makes programs more reliable.

3. Lack of Security

C++ does not provide strong built-in security features. Since it allows direct memory access through pointers, it becomes easier to exploit vulnerabilities.

Java was designed with security as a priority. It eliminates pointers and provides features like bytecode verification, secure class loading, and runtime checking. This makes Java suitable for applications like web and mobile development where security is critical.

4. Platform Dependency

C++ programs are platform-dependent. This means a program compiled on one system (like Windows) may not run on another system (like Linux) without modification.

Java introduced the concept of platform independence through the Java Virtual Machine (JVM). Java programs are compiled into bytecode, which can run on any system that has a JVM. This is why Java is known for its slogan: Write Once, Run Anywhere.

5. Difficulty in Building Distributed Applications

With the growth of the internet, there was a need for languages that could support network-based and distributed applications. C++ was not designed with this in mind.

Java provides built-in support for networking, multithreading, and distributed computing. This makes it easier to build web-based and enterprise applications.

Features of Java

Java includes several features that make it powerful, simple, and widely used.

1. Simple

Java is easier to learn compared to C++. It removes complex features like pointers and operator overloading. The syntax is clean and similar to C++, making it easy for C++ programmers to switch.

2. Object-Oriented

Java follows object-oriented programming principles such as:

Encapsulation
Inheritance
Polymorphism
Abstraction

This helps in organizing code properly and makes it reusable and maintainable.

3. Platform Independent

Java programs are compiled into bytecode, which runs on the JVM. This allows the same program to run on different operating systems without modification.

4. Secure

Java provides strong security features:

No use of pointers
Bytecode verification
Secure execution environment

This makes Java suitable for applications like banking systems and web applications.

5. Robust

Java is designed to be reliable. It includes:

Strong memory management
Exception handling
Automatic garbage collection

These features help in reducing errors and improving program stability.

6. Multithreading

Java supports multithreading, which allows multiple tasks to run at the same time. This improves performance and is useful in applications like games, web servers, and real-time systems.

7. High Performance

Although Java is not as fast as C++, it uses Just-In-Time (JIT) compilation to improve performance. The JIT compiler converts bytecode into machine code at runtime, making execution faster.

8. Distributed

Java is designed for distributed environments. It provides libraries for networking, remote method invocation (RMI), and web services, making it easier to develop internet-based applications.

9. Dynamic

Java supports dynamic loading of classes at runtime. This means programs can adapt and update without restarting, which is useful for modern applications.