DEV Community: Hariharan S J

The Meetup Story

Hariharan S J — Mon, 15 Jun 2026 10:28:44 +0000

Hey Guys

Today in this blog you are going to see some Curious Topics that What i Have Learned in the Meetup i Attendend

Before That this sunday i Attended the ILUGC Meetup That meetup was So useful to me as a tech enthusiassist

The ILUGC Community is started their meetup since 1988 so it was got a lot of history about this

so i learned lot of things on the meetup My Philosophy is if i had learned something new to the technology means i should to some other person so that they should be useful for the content that what i have shared , so i use this blog to share my experice on that particular meetup

Without Any Further delay lets get Started

The First talk is about

Google's New 2026 Developer Verification Policy – Will It Change the Future of Android?

What's the first thing that comes to mind when we think about Android? Freedom. We can install apps from different sources, download APK files, and even use third-party app stores. However, in 2026, Google introduced a major change called the Developer Verification Policy.

Under this policy, Android developers must verify their identity with Google before distributing apps. This requirement is not limited to apps published on the Play Store it also applies to developers who distribute APKs through their own websites or other channels.

What Problem Is Google Trying to Solve?

The Android ecosystem has faced issues such as malware, scam applications, and fake developer accounts for years.

In many cases, when a developer account is banned for violating policies, the same person can create a new account and continue distributing harmful apps. Google's goal is to reduce these risks by ensuring that every developer can be identified and held accountable.

What Does the Policy Require?

Developers may need to provide:

Legal name
Address
Email address
Phone number
Government-issued identification (in certain cases)
Additional business verification for organization accounts

This information is used to confirm the identity of the developer before app distribution.

Timeline

Early access began in late 2025.
Verification became available to developers in 2026.
Enforcement starts in phases during 2026.
Wider rollout is expected to continue globally.

Advantages of the Policy

1. Improved Security

Verified developers are easier to track and monitor, making it harder for malicious actors to operate anonymously.

2. Reduced Malware and Scam Apps

By verifying identities, Google can better prevent harmful applications from reaching users.

3. Increased User Trust

Users will have greater confidence knowing that app developers have gone through an identity verification process.

Concerns and Criticism

1. Will Android Lose Its Openness?

One of Android's biggest strengths has always been its open ecosystem.

Some developers argue that stricter verification requirements could make Android feel more controlled and less open than before.

2. Impact on Independent Developers

Students, hobby developers, and small open-source contributors may find the verification process more challenging compared to large companies.

3. Sideloading Restrictions

Google has stated that sideloading is not being removed. However, apps distributed by unverified developers may face additional security warnings or restrictions.

My Perspective

The intention behind this policy is understandable.

It aims to:

Improve security
Reduce scams and malware
Increase accountability

However, Google must maintain a balance between security and openness.

Security is important.
Freedom is important too.

Android became successful not only because it was secure, but also because it gave users and developers the freedom to innovate.

The real challenge is finding the right balance between these two values.

After this they all requested to give a shor intro about ourself so i also gave a short intro about this

in between the topic a heated argument is going on between linux vs windows which os is the best to use each person shared their own point of view to say which one is the best

personally if you ask me linux is the best for developers because if i want to write a normal print statement in python i want to download a IDE to run it or or i want to run it on any by using the online google compiler by using windows

but by using linux python is inbuildtly there is linux

The Second Talk is about the Opensource Testing Tool Called

Playwright

he also told like why Playwright is best than Selinium he also give a lot of technical inputs about the playwright tool

My Final Thoughts

It was an Eye Opening session for me because from there on my curiousity level increses like whats is going on the technical world how we are going about in the future like that thoughts are think myself

so thats all gyus you can also attend the ILUGC Monthly Meetup they conduct every month of second saturday

Go to the Official Site of ILUGC , go to the contact page in there Subscribe to the ILUGC Mailing List After Subscribing it you get all notification from there which date the meetup is conducted on

okay gyus see you in the next blog...

Abstraction in Java

Hariharan S J — Sat, 13 Jun 2026 05:17:52 +0000

1.Introduction

Hey guys today in this Blog you are going to learn about one of the OOPS Concepts called Abstraction

Important Note

Before studying or Practising this topic please do Study the OOPS concepts of class,object,Polymorphism,Inheritance and Endcapsulation because The OOPS concepts are deeply intertwined, and understanding one concept helps in understanding the others without studying those topics this topics would be much much difficult to understand so please do ensure to study those topics before comming into this topic

without any further delay let's get started

2.What is mean by Abstraction

first we will discuss this term non technically

Abstract means a 5 to 10 lines Which will discribe the whole Paragraph

for ex : take your college final year abstract in that how's the project working is only is there in abstract the functionalities or the parts of behaviour is not mention in the abstract or in simple words it can be called as a Synopsis

Like that

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.

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

Real-Life Example of Abstraction

Imagine you are the guy who is Standing in Front of an ATM Machine Like this in the photo , you enter the card in the machine and you click the withdraw option in Machine , and put your Personal Identification Number Which is Shortly Called as PIN Number

You Wait for few seconds after the machine dispence the cash you take the cash and go for your work

but have you ever wondered like what is the internal process going on inside the machine

yeahh your guessing is right it also follows abstraction because u can only see the screen and buttons of the atm machine through your eyes but you cannot see whats going on inside process

2.Why is Abstraction used in Java?

Abstraction is used to hide implementation details and show only the essential features of an object.

Simple Example

Take a car , in car everything in an object like the wiper , tire, Seat belt like that so for a driver which object should important is

Steering wheel
Acclerator
Brake
Clutch
Gear

The Driver don't need to know how the engine, gearbox, or fuel injection system works internally.

This is abstraction — exposing what to do while hiding how it is done.

Okay now lets see some example Code after seeing the code you can even more connect with these topic called Abstraction

abstract class Indians {

    abstract void haveBreakfast();

    public void applyRationCard() {
        System.out.println("Ration card");
    }

    public void applyDrivingLisence() {
        System.out.println("Driving lisence");
    }
}

class Tamils extends Indians {

    public static void main(String[] args) {

        Tamils thamizhan = new Tamils();

        thamizhan.applyRationCard();
        thamizhan.applyDrivingLisence();
        thamizhan.haveBreakfast();
    }

    public void haveBreakfast() {
        System.out.println("Idly , Dosa");
    }

}

India is a country where Diverse culture is there that's why India is popularly called as "Unity in Diversity"

this code is related to that because in Indians.java i have a method called have method called

abstract void haveBreakfast();

haveBreakfast Method cannot be defined because in south india which Tami nadu , Kerala , Andhra Pradesh and Karnataka eat Different foods whereas north india which is Maharashtra , Uttar Pradesh , Bihar like that they eat different foods for their Breakfast

so the method breakfast is undefined

Rule 1 in abstraction

even if one method is Abstract in one class then the Entire Class Should be Abstract

Rule 2 Object Should not Be created in the Abstract Class

When you are creating Object in the Abstract Class it will show an Error like

abstract class cannot be instantiated

With the help of Inheritance you can create a child class for your parent class and create object for your child and call the non static methods from your child class of your child object

so when you execute this program the output of the program will be

Java provides two ways to implement abstraction, which are listed below:

1.)Abstract Classes (Partial Abstraction)

2.)Interface (provides abstraction for behavior, may contain default or static methods) To Be Discussed

Okay guys i hope somewhat you understand About this Topic if you having Any Doubts Drop it down in the Comment Section

My Final Thoughts About This Topic

You may Watched this movie or you may Heard about this movie called Inception so Basically the movie is all about dreams vs reality esspecially the climax is scene is an ultimate twist Because the Hero of the movie Cob spins of his totem if the totem automatically stops menas the hero is in reality if it is not stopped or else if it is continuously spins means the hero will be in dream

the mad man director christopher nolan takes the scene and in the climax hero spins his totem and go to his child but the biggest question here is wheather the totem is stopped or not

christopher nolan sends it to the audiance perspective let audiance decide wheather the totem is stopped or not

but accoding to technically it is undefined because the creator of the film itself designed like that only

Like wise the same way The Abstraction Applies to the Undefined Methods

See you in my next blog guys ...

The Hidden Beauty of Numbers: Solving Perfect Numbers, Factorials, and More with Python

Hariharan S J — Sat, 06 Jun 2026 07:25:42 +0000

1.Introduction

Did you know that some numbers are considered so special that mathematicians have been studying them for thousands of years?

Take the number 28, for example. At first glance, it looks like any ordinary number. But surprisingly, it belongs to a rare category known as Perfect Numbers. Similarly, concepts like factorials and number series play a crucial role in mathematics, probability, and computer science.

As programmers, understanding how to solve these problems not only improves our coding skills but also strengthens our logical thinking. One of the best tools for solving such problems in Python is the while loop, a simple yet powerful looping construct that allows us to repeat tasks efficiently.

In this article, we'll build and understand four practical Python programs using while loops. By the end, you'll have a better understanding of Perfect Numbers, Factorials, Number Patterns, and Summation Techniques while also improving your Python programming skills.

Let's dive in!

2.Perfect Number Program

A perfect number is a positive integer that is equal to the sum of its positive divisors, excluding itself. For instance, 28 is a perfect number because the sum of its divisors (1, 2, 4, 7, and 14) is 28.

Perfect numbers are also known as "Complete Numbers" in number theory.
Some of the first perfect numbers are 6, 28, 496, and 8128
As of 2025, a total of 52 perfect numbers have been discovered.

Other Examples

6
28
496
8128
33550336 up to infinity.

The latest Perfect Number was discovered in 2024 and has 82,048,64 digits.

3.Why are Perfect Numbers Important?

Perfect Numbers have fascinated mathematicians for thousands of years and are an important topic in Number Theory. They help researchers study the relationships between numbers and understand mathematical patterns.

For programmers, perfect number problems are useful because they teach important concepts such as:

Loops
Conditional statements
Divisor calculation
Modulus operator (%)
Problem-solving skills

Perfect number questions are also common in coding interviews, programming assignments, and competitive programming contests.

Python Program

no = 28

divisor = 1
sum = 0

while divisor < no:
    if no % divisor == 0:
        sum = sum + divisor
    divisor = divisor + 1

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

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
Initialize
no, divisor, sum
     │
     ▼
divisor < no ?
     │
 ┌───┴───┐
 │  Yes  │
 └───┬───┘
     │
     ▼
no % divisor == 0 ?
     │
 ┌───┴────┐
 │  Yes   │
 └───┬────┘
     │
     ▼
sum = sum + divisor
     │
     ▼
divisor++
     │
     └──────────┐
                │
                ▼
        divisor < no ?
                │
                ▼
       Loop Continues

After Loop

sum == no ?
     │
 ┌───┴───┐
 │       │
 ▼       ▼
Perfect  Not Perfect
Number   Number

Output

Perfect Number

How the Program Works

The program checks every number from 1 up to the given number. Whenever a number divides the given number completely, it is considered a divisor and added to the sum. Finally, if the sum of all divisors equals the original number, the program prints "Perfect Number".

4.Odd and Even Number Pattern in a Single Loop

Sometimes a problem can be solved in multiple ways. The following program generates odd numbers first and then even numbers using a single loop.

Python Program

no = 1

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

    no = no + 1

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 no = 1
     │
     ▼
 no <= 10 ?
     │
 ┌───┴───┐
 │  Yes  │
 └───┬───┘
     │
     ▼
 no <= 5 ?
     │
 ┌───┴─────┐
 │         │
 ▼         ▼
Print      Print
Odd        Even
Formula    Formula
     │
     ▼
 no++
     │
     └─────Loop

Output

How the Program Works

For the first five iterations, the formula (no * 2) - 1 generates odd numbers.

For the remaining iterations, the formula (no - 5) * 2 generates even numbers.

This approach demonstrates how mathematical expressions and conditions can be combined inside a single loop to produce a specific pattern.

5.Factorial of a Number

Factorial is one of the most commonly used mathematical operations in programming.

The factorial of a number is the product of all positive integers from 1 to that number.

For example:

5! = 5 × 4 × 3 × 2 × 1 = 120

Why is Factorial Used?

Factorials are widely used in:

Permutations and Combinations
Probability calculations
Mathematics
Algorithm design
Computer Science research

Python Program

no = 5

i = 1
fact = 1

while i <= no:
    fact = fact * i
    i = i + 1

print(fact)

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
Initialize
i = 1
fact = 1
     │
     ▼
 i <= no ?
     │
 ┌───┴───┐
 │  Yes  │
 └───┬───┘
     │
     ▼
fact = fact * i
     │
     ▼
i++
     │
     └────Loop

After Loop

     ▼
Print factorial
     │
     ▼
    End

Output

How the Program Works

The variable fact starts with the value 1. The loop multiplies it by every number from 1 to 5. Once the loop finishes, the final result stored in fact becomes 120.

6.Sum of First N Numbers

Finding the sum of a sequence is another common programming problem.

If we want to find the sum of the first 10 numbers:

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10

The result is:

Python Program

no = 10

i = 1
sum = 0

while i <= no:
    sum = sum + i
    i = i + 1

print(sum)

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
Initialize
i = 1
sum = 0
     │
     ▼
 i <= no ?
     │
 ┌───┴───┐
 │  Yes  │
 └───┬───┘
     │
     ▼
sum = sum + i
     │
     ▼
i++
     │
     └────Loop

After Loop

     ▼
Print sum
     │
     ▼
    End

Output

How the Program Works

The variable sum starts with 0. During each iteration, the current value of i is added to sum. After all numbers from 1 to 10 are processed, the final value of sum becomes 55.

Real-World Applications

This concept is useful in:

Data analysis
Mathematical series calculations
Statistical computations
Algorithm development
Financial calculations

7.Conclusion

The while loop is one of the most fundamental tools in Python programming. Although it appears simple, it can be used to solve a wide variety of problems.

In this article, we explored how to:

Identify a Perfect Number
Generate odd and even number patterns
Calculate the factorial of a number
Find the sum of the first N numbers

These programs help beginners strengthen their understanding of loops, conditions, arithmetic operations, and logical thinking. Once you master these concepts, you'll be better prepared to solve more advanced programming challenges in Python.

Happy Coding.

Reference

(https://www.geeksforgeeks.org/maths/perfect-numbers/)

Behind the Scenes of Java OOP: Constructors to Run Time Polymorphism

Hariharan S J — Fri, 05 Jun 2026 11:53:28 +0000

1.Introduction

Have you ever wondered what actually happens when you create an object in Java?
Why does the parent constructor execute before the child constructor?
Why can a child class access parent methods, but a parent class cannot directly call a child constructor?
And why is method overriding called Run Time Polymorphism?

Most beginners learn Java syntax, but very few truly understand what happens behind the scenes when inheritance, constructors, super() keyword, and method overriding work together.

In this blog, we are going to break down these core OOP concepts in the simplest possible way using real Java examples based on Hotel.java and Vadakkambatti.java.

By the end of this blog, you will clearly understand:

How constructors work internally
How inheritance actually behaves
Why super() is important
How method overriding works
Why overriding is called Run Time Polymorphism
Whether return types can be changed during method overriding

If you are learning Java or preparing for interviews, these concepts are extremely important because they are frequently asked in technical discussions and coding interviews.

Let’s dive into the world of Java OOP concepts step by step

2.What is a Constructor in Java?

A constructor is a special block in Java that is automatically called when an object is created.

Important Points About Constructors

Constructor name should be the same as the class name
Constructors do not have a return type
Constructors are automatically executed during object creation
Constructors are mainly used to initialize object values

Example

public class Hotel {

    String foodName;
    int price;

    public Hotel(String foodName, int price){

        this.foodName = foodName;
        this.price = price;
    }

    void display(){

        System.out.println(foodName);
        System.out.println(price);
    }
}

public class Vadakkambatti {

    public static void main(String[] args){

        Hotel item1 = new Hotel("Chicken Biriyani", 250);

        item1.display();
    }
}

Output

Chicken Biriyani
250

Here, the constructor initializes the values using this.

3.Understanding Inheritance in Java

A class that is derived from another class is called a subclass (also a derived class, extended class, or child class). The class from which the subclass is derived is called a superclass (also a base class or a parent class).

Excepting Object, which has no superclass, every class has one and only one direct superclass (single inheritance). In the absence of any other explicit superclass, every class is implicitly a subclass of Object.

Classes can be derived from classes that are derived from classes that are derived from classes, and so on, and ultimately derived from the topmost class, Object. Such a class is said to be descended from all the classes in the inheritance chain stretching back to Object.

The idea of inheritance is simple but powerful: When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class. In doing this, you can reuse the fields and methods of the existing class without having to write (and debug!) them yourself.

A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

Syntax

class Child extends Parent

Here:

Parent class → Super class
Child class → Sub class

4.Understanding super Keyword in Java

The super keyword in Java is used to refer to the immediate parent class object in an inheritance hierarchy. It allows a subclass to explicitly access parent class members when they are hidden or overridden. This keyword helps maintain clarity and control while working with inheritance.

Used to call parent class constructors using super().
Helps access parent class methods and variables when overridden or hidden.
Ensures proper inheritance behavior and code reusability.

Example

Hotel.java

public class Hotel {

    Hotel(){

        System.out.println("Parent Constructor");
    }
}

Vadakkambatti.java

public class Vadakkambatti extends Hotel {

    Vadakkambatti(){

        super();

        System.out.println("Child Constructor");
    }

    public static void main(String[] args){

        Vadakkambatti obj = new Vadakkambatti();
    }
}

Output

Parent Constructor
Child Constructor

What Happens Here?

When the child object is created:

new Vadakkambatti();

Java automatically calls:

super();

This super() calls the parent class constructor first.

So the execution order becomes:

Parent constructor
Child constructor

Important Rules About super Keyword

super() must be the first statement inside the child constructor
It is used to call the parent constructor
If super() is not written, Java automatically inserts it

5.Can Parent Class Call Child Constructor?

This is one of the most confusing questions for beginners.

Answer: No

A parent class cannot directly call a child class constructor.

Wrong Example

public class Hotel {

    Hotel(){

        Vadakkambatti(); // Error
    }
}

This produces a compile-time error like:

cannot find symbol

Reason

Constructors cannot be called like normal methods.

Correct way:

new Vadakkambatti();

Constructors only execute during object creation.

6.What is Method Overriding?

Method overriding means redefining a parent class method inside the child class with the same method name and same parameters.

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

Usage of Java Method Overriding

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

Example

Hotel.java

public class Hotel {

    void SpecialFood(){

        System.out.println("Chicken Biriyani");
    }
}

Vadakkambatti.java

public class Vadakkambatti extends Hotel {

    void SpecialFood(){

        System.out.println("Grill Chicken");
    }

    public static void main(String[] args){

        Vadakkambatti obj = new Vadakkambatti();

        obj.SpecialFood();
    }
}

Output

Grill Chicken

Here, the child class overrides the parent method and provides its own implementation.

7.Why Method Overriding is Called Run Time Polymorphism?

In method overriding, Java decides which method to execute during run time.

Example

Hotel obj = new Vadakkambatti();

obj.SpecialFood();

Even though the reference type is Hotel, the object type is Vadakkambatti.

So Java checks the actual object during execution and calls the child method.

This decision happens at run time, so method overriding is called:

Run Time Polymorphism

Can We Change Return Type in Method Overriding?

Answer: Yes and No

Return type can be changed only in certain situations.

Same Return Type

class Hotel {

    int price(){

        return 100;
    }
}

class Vadakkambatti extends Hotel {

    int price(){

        return 200;
    }
}

Here both methods return int, so overriding is valid.

Covariant Return Type

A child class return type can replace the parent class return type.

Example

class Food {

}

class Biriyani extends Food {

}

class Hotel {

    Food SpecialFood(){

        return new Food();
    }
}

class Vadakkambatti extends Hotel {

    Biriyani SpecialFood(){

        return new Biriyani();
    }
}

This is called:

Covariant Return Type

Completely Different Return Type

class Hotel {

    int price(){

        return 100;
    }
}

class Vadakkambatti extends Hotel {

    String price(){ // Error

        return "Two Hundred";
    }
}

This produces a compile-time error because int and String are unrelated return types.

Important Rule for Method Overriding

Method overriding requires:

The method must have the same name as in the parent class.
The method must have the same parameter as in the parent class.
Compatible return type
Inheritance relationship

8.Final Thoughts

Understanding constructors, inheritance, super keyword, method overriding, and return types is essential for mastering Java OOP concepts.

Key Takeaways

Constructors initialize objects
Inheritance helps reuse code
super() calls parent constructors
Parent constructors can be called by child classes
Child constructors cannot be directly called by parent classes
Method overriding enables run time polymorphism
Return type can be changed only if it is compatible

Once these basics become clear, advanced Java concepts become much easier to understand.

Happy Coding.

Reference

(https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)

(https://www.geeksforgeeks.org/java/super-keyword/)

(https://java-iitd.vlabs.ac.in/exp/method-overriding/theory.html)

Python While Loop Practice: Multiples, Divisors, Count of Divisors & Prime Numbers

Hariharan S J — Thu, 04 Jun 2026 14:23:12 +0000

1.Introduction

What do multiples of numbers, divisors, and prime numbers have in common?

At first glance, they may seem like simple math concepts we learned in school. But behind the scenes, these are some of the most common problems programmers solve using loops and conditions.

Imagine asking a computer questions like:

Which numbers between 1 and 100 are divisible by both 3 and 5?
How can I find all divisors of a number?
How many divisors does a number have?
Is a given number prime or not?

The answer to all these questions starts with one fundamental programming concept: the while loop.

In this article, we'll use a series of simple Python programs to explore how while loops work and how they can be used to solve real mathematical problems. Whether you're a beginner learning Python or someone looking to strengthen your problem-solving skills, these examples will help you understand the power of loops in a practical way.

Let's dive in and see how a few lines of Python code can solve some interesting number-based challenges.

2. Finding Numbers Divisible by Both 3 and 5

Let's start with a simple problem.

We need to print all numbers between 1 and 100 that are divisible by both 3 and 5.

no = 1

while no <= 100:
    if no % 3 == 0 and no % 5 == 0:
        print(no)
    no += 1
else:
    print("false")

How it Works

The loop starts from 1 and continues until 100.
% is the modulus operator that returns the remainder.
If a number leaves a remainder of 0 when divided by both 3 and 5, it gets printed.
Such numbers are multiples of 15.

Output

3.Finding Numbers Divisible by Either 3 or 5

Now let's print numbers that are divisible by 3 or 5.

no = 1

while no <= 100:
    if no % 3 == 0 or no % 5 == 0:
        print(no)
    no += 1
else:
    print("false")

How it Works

Here we use the or operator instead of and.
If a number is divisible by either 3 or 5, it will be printed.

Examples

4. Finding the Divisors of a Number

A divisor is a number that divides another number completely without leaving a remainder.

Let's find all divisors of 20.

no = 20
i = 1

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

How it Works

Start checking from 1.
If 20 is divisible by the current value of i, print it.
Continue until i reaches 20.

Output

5. Counting the Number of Divisors

Instead of just printing divisors, we can count them as well.

no = 12
i = 1
count = 0

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

print("Count =", count)

How it Works

Every time a divisor is found, increase count by 1.
After the loop finishes, print the total count.

Output

1
2
3
4
5
6
12
Count = 6

Since 12 has six divisors, the count is 6.

6.Checking Whether a Number is Prime

A prime number has exactly two divisors:

1
The Number Itself

Let's check whether 13 is prime.

no = 13
i = 1
count = 0

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

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

How it Works

Count the total number of divisors.
If the count is exactly 2, the number is prime.
Otherwise, it is not prime.

Output

Prime Number

Because 13 is divisible only by 1 and 13.

7.Why These Programs Matter

These examples may look simple, but they introduce several important programming concepts:

While loops
Conditional statements
Modulus operator (%)
Counting Logic
Number theory fundamentals

Understanding these concepts will help you solve more advanced coding problems in the future.

8.Final Takeaway

The while loop is one of the most powerful tools for beginners learning Python. By combining loops with conditions, you can solve a variety of mathematical problems such as finding multiples, identifying divisors, counting factors, and checking prime numbers.

Master these basics, and you'll build a strong foundation for tackling more complex programming challenges.

What Really Happens When You Create an Object in Java? Understanding Constructors and Packages

Hariharan S J — Wed, 03 Jun 2026 13:21:54 +0000

1.Introduction

Have you ever created an object in Java and wondered what happens behind the scenes the moment that object comes to life?

When you write something as simple as:

Student s1 = new Student();

Java doesn't just magically create an object. It first invokes a special mechanism called a constructor, which prepares the object and gets it ready for use. Whether you're assigning default values or passing custom data during object creation, constructors play a crucial role in every Java application.

But creating objects is only part of the story.

As applications grow from a few classes to hundreds or even thousands, managing code becomes a challenge. Imagine trying to find a single class in a project where every file is stored in the same folder. That's where packages come in. Packages help developers organize code, avoid naming conflicts, and build scalable applications that are easier to maintain.

In this article, we'll explore the different types of constructors in Java, understand how they work, and learn how packages help structure real-world Java projects. By the end, you'll have a solid understanding of two fundamental concepts that every Java developer uses daily.

In my previous blog i had discussed what is constructor? , why constructor is needed in this blog we are going to discuss about the Types of Constructor and Packages

2.Types of Constructors in Java

Java mainly provides three types of constructors:

Default Constructor
No-Argument Constructor
Parameterized Constructor

1. Default Constructor

A default constructor is automatically provided by the Java compiler when no constructor is explicitly written.

If we do not create any constructor, the Java compiler automatically creates a no-arg constructor during the execution of the program.

This constructor is called the default constructor.

Example

class Student {

    int id;
    String name;

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(s1.id);
        System.out.println(s1.name);
    }
}

Output

0
null

Explanation

Since no constructor was defined, Java automatically generated a default constructor and assigned default values to instance variables.

2. No-Argument Constructor

A no-argument constructor is created by the programmer and does not accept any parameters

Similar to methods, a Java constructor may or may not have any parameters (arguments).

If a constructor does not accept any parameters, it is known as a no-argument constructor. For example,

Example

class Student {

    int id;
    String name;

    Student() {
        id = 101;
        name = "Hari";
    }

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(s1.id);
        System.out.println(s1.name);
    }
}

Output

101
Hari

Why Use It?

A no-argument constructor allows us to initialize objects with custom default values instead of Java's built-in defaults.

3. Parameterized Constructor

A parameterized constructor accepts values during object creation.

A Java constructor can also accept one or more parameters. Such constructors are known as parameterized constructors (constructors with parameters).

Example

class Student {

    int id;
    String name;

    Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public static void main(String[] args) {

        Student s1 = new Student(101, "Hari");

        System.out.println(s1.id);
        System.out.println(s1.name);
    }
}

Output

101
Hari

Why Use It?

Parameterized constructors allow each object to have different values during creation.

Student s1 = new Student(101, "Hari");
Student s2 = new Student(102, "John");
Student s3 = new Student(103, "David");

Each object stores unique data.

Constructor Overloading

Java allows multiple constructors within the same class as long as their parameter lists are different.

Example

class Student {

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

    Student(String name) {
        System.out.println("Parameterized Constructor");
    }

    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student("Hari");
    }
}

Output

No Argument Constructor
Parameterized Constructor

This feature is known as Constructor Overloading.

3.What is a Package in Java?

A package is a collection of related classes, interfaces, and sub-packages.

Think of a package as a folder in your computer.

Just as folders help organize files, packages help organize Java classes.

A package in Java is a mechanism to group related classes, interfaces, and sub-packages into a single unit. Packages help organize large applications, avoid naming conflicts, provide access protection, and make code modular and maintainable.

Avoiding name conflicts (two classes with the same name can exist in different packages)
Providing access control using public, protected, and default access
Reusability: packaged code can be imported and used anywhere
Encouraging modular programming

4.Why Do We Need Packages?

Packages provide several advantages:

1. Better Code Organization

Without packages:

Student.java
Employee.java
Customer.java
Order.java

With Packages

com.company.student
com.company.employee
com.company.order

Everything becomes easier to manage.

2. Prevent Naming Conflicts

Two developers might create classes with the same name.

Example:

student.Student
employee.Student

Packages help Java identify which class is being used.

3. Access Protection

Packages help control visibility of classes and members using access modifiers.

Types of Packages

Java provides two types of packages:

1. Built-in Packages

These are packages provided by Java itself.

Examples:

java.lang(TBD)
java.util(TBD)
java.io(TBD)
java.sql(TBD)

2. User-Defined Packages

Developers can create their own packages.

Creating a Package

package college;

public class Student {

    public void display() {
        System.out.println("Inside Student Class");
    }
}

Using the Package

import college.Student;

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

        s.display();
    }
}

Package Naming Convention

Java package names usually follow reverse domain naming.

Example:

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

This helps avoid naming conflicts in large applications.

5.Final Thoughts

Constructors and packages may seem like small Java concepts at first, but they play a huge role in real-world application development.

Constructors ensure that objects are properly initialized when created, while packages help organize code into meaningful structures.

As your Java projects become larger and more complex, understanding these two concepts will help you write cleaner, more maintainable, and professional-quality code.

Master constructors to control object creation. Master packages to control project organization. Together, they form a strong foundation for becoming an effective Java developer.

Reference

(https://www.geeksforgeeks.org/java/packages-in-java/)

(https://www.programiz.com/java-programming/constructors)

One While Loop, Seven Patterns, Endless Learning

Hariharan S J — Wed, 03 Jun 2026 10:06:11 +0000

1.Introduction

Have you ever noticed that most beginners can write a while loop, but struggle when asked to create a simple number pattern?

The problem isn't the syntax.

It's understanding how numbers change from one iteration to the next.

A sequence like 1 2 3 4 5 may look different from 1 3 5 7 9 or 15 12 9 6 3, but behind the scenes, they all follow the same fundamental principle: start with a value, repeat a process, and update that value in a predictable way.

This is exactly why pattern programs are so popular among programmers. They don't just teach loops—they train your brain to think logically, identify sequences, and understand how a program evolves step by step.

In this article, we'll use Python's while loop to build a variety of number patterns, from simple counting sequences to reverse and alternating patterns. More importantly, we'll focus on the logic behind each pattern so that by the end, you won't just know how to print these patterns—you'll know how to create your own.

2.Why Learn Patterns?

Many beginners try to memorize pattern programs.

That's the wrong approach.

Instead, focus on understanding:

What is changing in each iteration?

Once you understand that, any pattern becomes easy to build.

Let's look at some examples.

Pattern 1: Repeating the Same Number

Output

1 1 1 1 1

Program

no = 1

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

How It Works

The loop runs 5 times.
We always print 1.
The variable no is only used to count the iterations.

Pattern 2: Counting Numbers

Output

1 2 3 4 5

Program

no = 1

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

How It Works

We start from 1.
After every iteration, we increase the value by 1.
The loop stops when the value becomes greater than 5.

Pattern 3: Odd Numbers

Output

1 3 5 7 9

Program

no = 1

while no <= 9:
    print(no, end=" ")
    no += 2

How It Works

Odd numbers have a difference of 2.
Instead of increasing by 1, we increase by 2.

Pattern 4: Multiples of 3

Output

3 6 9 12 15

Program

no = 3

while no <= 15:
    print(no, end=" ")
    no += 3

How It Works

We start from 3.
Every next value is 3 more than the previous value.

Pattern 5: Reverse Multiples of 3

Output

15 12 9 6 3

Program

no = 15

while no >= 3:
    print(no, end=" ")
    no -= 3

How It Works

We start from the largest value.
Instead of incrementing, we decrement by 3.

Pattern 6: Reverse Even Numbers

Output

10 8 6 4 2

Program

no = 10

while no >= 2:
    print(no, end=" ")
    no -= 2

How It Works

We begin with 10.
Every iteration subtracts 2.
This produces even numbers in reverse order.

Pattern 7: Reverse Odd Numbers

Output

9 7 5 3 1

Program

no = 9

while no >= 1:
    print(no, end=" ")
    no -= 2

How It Works

We start from the largest odd number.
We subtract 2 in every iteration.
The sequence continues until 1.

The Hidden Pattern Behind All Patterns

If you look carefully, every program follows the same structure:

starting_value

while condition:
    print(value)
    update_value

The only things that change are:

Starting value
Condition
Increment or decrement

That's it.

Once you understand these three components, creating new patterns becomes much easier.

Final Takeaway

Pattern programs are not about printing numbers on the screen. They are exercises that train your brain to recognize sequences, understand loop behavior, and think logically.

The moment you stop memorizing patterns and start identifying what changes in each iteration, you'll be able to create your own patterns confidently.

Learn the logic, not the pattern. That's where real programming begins.

Java Constructors Demystified: What Happens Before Your Object Exists?

Hariharan S J — Tue, 02 Jun 2026 14:50:36 +0000

1.Introduction

Have you ever wondered what actually happens when you write:

SuperMarket product = new SuperMarket("Noodles", 50);

We all know that an object gets created. But what happens behind the scenes? Where does the memory come from? When are the values assigned? And why does Java automatically call a constructor without us explicitly invoking it?

When I first learned constructors, I thought they were just special methods used to initialize objects. But after experimenting with object creation, default values, the this keyword, and constructor parameters, I discovered that constructors are much more than that—they are the starting point of an object's lifecycle.

In this blog, we'll go beyond the textbook definition of constructors. We'll explore what really happens when an object is created, why this is important, how Java assigns default values, and some beginner mistakes that can silently break your code.

By the end of this article, you'll not only know what a constructor is, but also why it behaves the way it does behind the scenes.

Let's create our first object and uncover the magic that happens the moment we use the new keyword.

2.What is a Constructor?

A constructor is used in the creation of an object that is an instance of a class. Typically it performs operations required to initialize the class before methods are invoked or fields are accessed. Constructors are never inherited.

A constructor in Java is a special member that is called when an object is created. It initializes the new object’s state. It is used to set default or user-defined values for the object's attributes

A constructor in Java is a special method that is used to initialize objects.

The constructor is called when an object of a class is created.

It can be used to set initial values for object attributes:

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

Syntax

class SuperMarket {

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

Creating an Object

SuperMarket product = new SuperMarket();

Output

Constructor Called

The moment the object is created using the new keyword, Java automatically invokes the constructor.

3.Rules of a Constructor

A constructor has a few important rules:

1. Constructor name must be the same as the class name

class SuperMarket {

    SuperMarket() {

    }
}

2. Constructors do not have a return type

Correct

SuperMarket() {

}

Incorrect

void SuperMarket() {

}

The second example is not a constructor. It is a normal method.

4.Why Do We Need Constructors?

Imagine creating an object and manually assigning values every time.

SuperMarket product1 = new SuperMarket();
product1.name = "Noodles";
product1.price = 50;

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

This works, but it becomes repetitive.

Instead, constructors allow us to initialize object-specific values immediately during object creation.

class SuperMarket {

    String name;
    int price;

    SuperMarket(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

Now we can simply write:

SuperMarket product1 = new SuperMarket("Noodles", 50);
SuperMarket product2 = new SuperMarket("Shampoo", 150);

Cleaner, safer, and easier to maintain.

5.Why Is the Constructor Called Twice?

Consider this code:

SuperMarket product1 = new SuperMarket("abc", 20);
SuperMarket product2 = new SuperMarket("xyz", 2000);

Constructor:

SuperMarket(String name, int price) {
    System.out.println("Are you constructor?");
}

Output:

Are you constructor?
Are you constructor?

Many beginners get confused here.

The reason is simple:

One object = One constructor call
Two objects = Two constructor calls

Every time you use the new keyword, Java creates a new object and invokes the constructor.

6.The Mystery of this

Consider the following code:

class SuperMarket {

    String name;
    int price;

    SuperMarket(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

Here:

this.name

refers to the instance variable.

While:

name

refers to the constructor parameter.

So:

this.name = name;

Means:

instanceVariable = parameter;

7.What Happens If We Remove this?

Suppose we write:

SuperMarket(String name, int price) {
    name = name;
    price = price;
}

At first glance, it looks correct.

But Java interprets it as:

parameter = parameter;
parameter = parameter;

The instance variables never receive the values.

8.Then Why Do We See null and 0?

Let's look at the class:

class SuperMarket {

    String name;
    int price;
}

Even though we never assigned values, Java still prints:

null
0

Why?

Because Java automatically assigns default values to instance variables.

9.What Actually Happens During Object Creation?

When Java executes:

new SuperMarket("Noodles", 50);

The JVM follows these steps:

Step 1

Memory is allocated for the object.

Step 2

Default values are assigned.

name = null
price = 0

Step 3

Field initializers are executed (if any).

String name = "Python";

Step 4

Constructor executes.

SuperMarket(String name, int price) {
    this.name = name;
    this.price = price;
}

Final flow:

Object Creation
       ↓
Default Values
       ↓
Field Initializers
       ↓
Constructor Execution

This order is extremely important for understanding how Java objects are initialized.

10.Final Takeaway

A constructor is not just a special method—it is the starting point of an object's life cycle.

Whenever an object is created:

Memory is allocated.
Default values are assigned.
Field initializers run.
The constructor executes.
The object becomes ready for use.

Understanding constructors also helps you understand other important concepts like this, object initialization, inheritance, and super() TBD.

If you're learning Java, mastering constructors is one of the best investments you can make before moving deeper into Object-Oriented Programming.

Strong Java Starts with Strong Fundamentals

Hariharan S J — Fri, 29 May 2026 06:26:01 +0000

1.Introduction

Programming languages come and go. Technologies change every year.
But even after decades, Java still powers millions of applications around the world — from banking systems and Android apps to enterprise software used by giant companies.

The interesting part?
Every advanced Java application starts with just a few basic concepts.

Before learning frameworks, APIs, or backend development, every Java developer must first understand:

How classes are declared
What data types actually mean
How fields store and manage data inside objects

These may look like beginner topics, but they form the backbone of Java programming. If these fundamentals are strong, learning advanced concepts becomes much easier.

In this blog, we’ll break down Java classes, primitive and non-primitive data types, and fields in a simple and beginner-friendly way with clear examples.

2.Classes, Data Types, and Fields in Java

Java is one of the most popular programming languages in the world. From Android apps to enterprise software, Java is used everywhere because of its simplicity, security, and platform independence.

Before building real-world applications, every Java developer must understand three important fundamentals:

How to declare a class correctly
Types of data types in Java
What fields are and how they work

Let’s explore them one by one.

3. Rules for Declaring a Class in Java

A class is the blueprint of an object.
In Java, everything revolves around classes.

Basic Syntax

class Student {

}

4.Important Rules for Declaring a Class

1. Class Name Should Start with a Letter

Correct:

class Employee {

}

Wrong:

class 123Employee {

}

2. Java is Case Sensitive

class Student {

}

class student {

}

Both are considered different classes.

3. Spaces Are Not Allowed in Class Names

Wrong:

class My Class {

}

Correct:

class MyClass {

}

4. Special Characters Are Not Allowed (Except _ and $)

Correct:

class Student_Data {

}

Wrong:

class Student@Data {

}

5. File Name and Public Class Name Must Be Same

public class Car {

}

The file name must be:

Car.java

Otherwise Java will throw an error.

4.Data Types in Java

Data types define what kind of value a variable can store.

Java mainly has two categories of data types:

Primitive Data Types
Non-Primitive Data Types

Primitive Data Types

Primitive data types are predefined by Java.
They store simple values directly.

Java has 8 primitive data types.

1. byte

The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters. They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.

byte age = 25;

Size: 1 byte

2. short

The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters.

short salary = 20000;

Size: 2 bytes

3. int

By default, the int data type is a 32-bit signed two's complement integer, which has a minimum value of -231 and a maximum value of 231-1. In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 232-1. Use the Integer class to use int data type as an unsigned integer. See the section The Number Classes for more information. Static methods like compareUnsigned, divideUnsigned etc have been added to the Integer class to support the arithmetic operations for unsigned integers.

int marks = 95;

Size: 4 bytes

4. long

The long data type is a 64-bit two's complement integer. The signed long has a minimum value of -263 and a maximum value of 263-1. In Java SE 8 and later, you can use the long data type to represent an unsigned 64-bit long, which has a minimum value of 0 and a maximum value of 264-1. Use this data type when you need a range of values wider than those provided by int. The Long class also contains methods like compareUnsigned, divideUnsigned etc to support arithmetic operations for unsigned long.

long population = 8000000000L;

Size: 8 bytes

5. float

The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.

float price = 99.5f;

Size: 4 bytes

6. double

The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification. For decimal values, this data type is generally the default choice. As mentioned above, this data type should never be used for precise values, such as currency.

double pi = 3.141592653;

Size: 8 bytes

7. char

The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

char grade = 'A';

Size: 2 bytes

8. boolean

The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.

boolean isJavaFun = true;

Non-Primitive Data Types

Non-primitive data types are created by programmers or provided by Java.

They store references instead of actual values.

Examples:

String
Arrays (TBD)
Classes
Interfaces (TBD)
Objects

Non-primitive data types are called reference types because they refer to objects.

The main differences between primitive and non-primitive data types are:

Primitive types in Java are predefined and built into the language, while non-primitive types are created by the programmer (except for String).
Non-primitive types can be used to call methods to perform certain operations, whereas primitive types cannot.
Primitive types start with a lowercase letter (like int), while non-primitive types typically starts with an uppercase letter (like String).
Primitive types always hold a value, whereas non-primitive types can be null.

String Example

String name = "Hari";

Class Object Example

class Student {

}

Student s1 = new Student();

5.Final Takeaway

Every expert Java developer once started with the basics.
Understanding classes, data types, and fields may seem simple at first, but these concepts are the foundation of everything you build in Java.

A class gives structure to your program.
Data types help Java understand and manage data efficiently.
Fields define the properties that make every object unique.

When your fundamentals are strong, learning advanced topics like objects, constructors, inheritance, collections, JDBC, Spring Boot, and backend development becomes much easier.

So don’t rush through the basics.
Master them.

Because strong Java developers are built on strong fundamentals.

Reference

(https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)

(https://www.w3schools.com/java/java_data_types_non-prim.asp)

From Railway Stations to Police Chase — Master Python While Loops

Hariharan S J — Thu, 28 May 2026 11:17:26 +0000

1.Mastering while Loops in Python with Real-Time Examples

Programming becomes interesting when we connect logic with real-world situations.
Instead of learning loops with boring numbers, let’s understand Python while loops using practical examples like:

Finding railway stations
Detecting common multiples
Catching a thief

In this blog, we’ll break down multiple Python programs step-by-step and understand how loops actually work behind the scenes.

2.Example 1 — Finding Numbers Divisible by 3 and 5

Program

station_no = 1

while station_no <= 30:
    if station_no % 3 == 0 and station_no % 5 == 0:
        print(station_no)

    station_no = station_no + 1

Output

15
30

Explanation

Here:

station_no starts from 1
The loop runs until 30
We check:

station_no % 3 == 0

AND

station_no % 5 == 0

If both are true, the number is printed.

3.What Does % Mean?

% is called the modulus operator.

It returns the remainder.

Example:

15 % 3 = 0

Because 15 is perfectly divisible by 3.

4.Example 2 — Finding the First Matching Station using break

Program

station_no = 1

while station_no <= 300:
    if station_no % 3 == 0 and station_no % 5 == 0:
        print(station_no)
        break

    station_no = station_no + 1

Output

5.What is break?

The break statement in Python is used to exit or "break" out of a loop (either for or while loop) prematurely, before the loop has iterated through all its items or reached its condition. When the break statement is executed, the program immediately exits the loop, and the control moves to the next line of code after the loop.

The break keyword is used to break out a for loop, or a while loop.

Without break, the loop would print:

But with break, the loop stops after finding the first matching value.

6.Example 3 — Unknown Number of Stations using while True

Program

station_no = 1

while True:  # Total no. of stations unknown

    if station_no % 18 == 0 and station_no % 62 == 0:
        print(station_no)
        break

    station_no = station_no + 1

Output

Why while True?

Sometimes we don't know:

how many times the loop should run
where the answer exists

So we create an infinite loop using:

while True:

Then stop it manually using break.

7.Example 4 — Police Catching a Thief

Program

while True:

    police = police + 5
    thief = thief + 2

    if police >= thief:
        print(police)
        break

Concept Behind the Program

This is a beautiful real-world simulation.

Police speed increases by 5
Thief speed increases by 2

The loop runs continuously.

Once:

police >= thief

The thief gets caught.

Important Note

Before running this program, initialize the variables.

Example:

police = 0
thief = 20

Complete Program:

police = 0
thief = 20

while True:

    police = police + 5
    thief = thief + 2

    if police >= thief:
        print(police)
        break

Output

8.Why These Programs Matter

Most beginners think loops are difficult.

But once you connect loops with:

trains
stations
police chase
real-time logic

Programming becomes much easier and more fun.

9.Final Thoughts

The while loop is one of the most powerful concepts in Python.

Whether you're:

searching for values
building games
creating simulations
solving real-world problems

while loops are everywhere.

The best way to master loops is:

Practice
Visualize
Build logic gradually

Because programming is not about memorizing syntax —
it’s about training your thinking process.

Reference

(https://www.geeksforgeeks.org/python/python-break-statement/)

(https://www.w3schools.com/python/ref_keyword_break.asp)

The One Concept That Powers Every Java Application

Hariharan S J — Wed, 27 May 2026 11:53:57 +0000

1.Introduction

Imagine trying to build an application like Instagram, Amazon, or a banking system using thousands of random functions and unorganized code. Sounds impossible, right?

As software applications started becoming larger and more complex, developers needed a smarter way to organize code — something that was secure, reusable, scalable, and easier to maintain.

That’s where Object-Oriented Programming (OOPs) changed everything.

OOPs is not just a programming concept in Java.
It is the foundation behind how modern software is designed.

From mobile apps to enterprise systems , Java uses OOPs to model real-world entities like:

Users
Cars
Bank Accounts
Employees
Shopping Carts

into reusable software objects.

In this blog, we’ll deeply explore:

Why OOPs is needed
The four pillars of OOPs
Internal working of classes and objects
Real-world examples
How Java uses OOPs internally

By the end of this article, you won’t just memorize OOPs concepts — you’ll actually understand why they are the backbone of Java development.

2.What is OOPs?

Object-Oriented Programming System (OOPs) is a programming approach where everything is organized around objects and classes.

Instead of writing long procedural code, OOPs allows developers to model real-world entities like:

Cars
Students
Bank Accounts
Employees

as software objects.

3.Why OOPs Concept is Needed in Java?

Imagine building a very large application like:

Instagram
Amazon
Banking Systems
Hospital Management Systems

Without proper structure, the code would become:

Messy
Difficult to manage
Hard to debug
Unsafe
Impossible to scale

This is exactly why Object-Oriented Programming (OOPs) was introduced.

OOPs helps developers organize software in a smarter and more realistic way.

The Main Problem Before OOPs

Before OOPs, many programming languages mainly followed:

Procedural Programming

In procedural programming:

Everything is written as functions
Data is shared globally
Programs become harder to maintain as size increases

Example of Procedural Problem

Imagine creating a banking application.

You may have:

deposit()
withdraw()
checkBalance()
transferMoney()

All functions directly access shared data.

As the application grows:

Bugs increase
Security issues appear
Code duplication happens
Maintenance becomes difficult

For small programs this is okay.

But for real-world applications with millions of users, this becomes a disaster.

Why OOPs Was Introduced

OOPs was introduced to solve these real software development problems.

It helps developers:

Organize code properly
Reuse existing code
Improve security
Reduce complexity
Build scalable applications
Model real-world entities

4.Understanding Class and Object

Class

A class is a blueprint or template for creating objects.

Example:

class Car {
    String brand;
    int speed;
}

Here, Car is a class.

Object

An object is an instance of a class.

Car c1 = new Car();

Here, c1 is an object of the Car class.

5.The Four Pillars of OOPs

These are the core concepts that define Object-Oriented Programming:

Encapsulation
Inheritance
Polymorphism
Abstraction

1. Encapsulation

What is Encapsulation?

Encapsulation means:

Wrapping data and methods together into a single unit.

It also means restricting direct access to sensitive data.

In Java, encapsulation is achieved using:

Private variables
Public getter and setter methods

Why Encapsulation is Important?

Imagine a bank account.

If everyone could directly access your balance variable:

balance = -100000;

the system would become unsafe.

Encapsulation protects data from unauthorized modification.

Example of Encapsulation

class Student {

    private int marks;

    public void setMarks(int m) {

        if(m >= 0 && m <= 100) {
            marks = m;
        }
    }

    public int getMarks() {
        return marks;
    }
}

2. Inheritance

What is Inheritance?

Inheritance allows one class to acquire the properties and behaviors of another class.

The existing class is called:

Parent Class
Super Class
Base Class

The new class is called:

Child Class
Sub Class
Derived Class

Why Inheritance?

Without inheritance, developers would repeatedly write the same code.

Inheritance promotes:

Code Reusability
Maintainability
Hierarchical Relationships

Example of Inheritance

class Animal {

    void eat() {
        System.out.println("Animal eats food");
    }
}

- 
class Dog extends Animal {

    void bark() {
        System.out.println("Dog barks");
    }
}

3. Polymorphism

What is Polymorphism?

Polymorphism means:

One entity behaving in multiple forms.

Example:

A person can behave differently as:

Student
Employee
Customer

Similarly, Java methods can behave differently depending on the situation.

Types of Polymorphism

Method Overloading (TBD)
Method Overriding (TBD)

4. Abstraction

What is Abstraction?

Abstraction means:

Hiding internal implementation and showing only essential features.

Example:

You drive a car using:

Steering
Brake
Accelerator

But you don’t see internal engine mechanisms.

Why Abstraction?

Without abstraction, systems become extremely complex.

Abstraction reduces complexity.

abstract class Vehicle {

    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

6.Final Conclusion

OOPs is not just a programming topic.

It is a software design philosophy that helps developers create clean, maintainable, reusable, and scalable applications.

To truly master Java, understanding these concepts deeply is essential:

Encapsulation
Inheritance
Polymorphism
Abstraction

Once these concepts become clear, writing advanced Java applications becomes much easier.

Java Isn’t Just a Language — It’s an Ecosystem

Hariharan S J — Tue, 26 May 2026 12:42:07 +0000

1.Introduction

Have you ever wondered how the same Java program runs perfectly on Windows, Linux, and macOS without changing a single line of code?

That’s the magic of Java Architecture.

Behind every Java application, powerful components like JVM, JDK, JRE, Bytecode, and JIT Compiler work together to make Java secure, portable, and incredibly powerful.

But most beginners use Java without actually understanding what happens internally when a Java program runs.

In this blog, we’ll break down the complete architecture of Java in a simple and beginner-friendly way. From the history of Java to understanding how bytecode works and why Java follows the famous principle:

“Write Once, Run Anywhere”

You’ll learn everything you need to build a strong foundation in Java.

2.Origin of Java

Java was developed by James Gosling and his team at Sun Microsystems in the early 1990s.

The project started in 1991.

The main members of the Java team were:

James Gosling
Mike Sheridan
Patrick Naughton

This team was later called the Green Team.

3.Why Was Java Created?

Initially, Java was developed for:

Television systems
Embedded devices
Electronic appliances

The goal was to create a language that could run on multiple devices without modification.

At that time, existing languages were platform dependent.

The Green Team wanted a language that followed:

“Write Once, Run Anywhere”

4.What is Java?

Java is a high-level, object-oriented programming language developed by Oracle Corporation.

Java is designed to be:

Simple
Secure
Portable
Platform Independent

Java Program Execution Flow

Java Source Code (.java)
        ↓
Compiler (javac)
        ↓
Bytecode (.class)
        ↓
JVM
        ↓
Machine Code
        ↓
Output

5.What is JDK?

JDK → Java Development Kit

JDK is a complete package used for developing Java applications.

It provides all the tools required to:

Write Java programs
Compile Java code
Run Java applications
Debug programs

Components of JDK

JDK contains:

JRE
Java Compiler (javac)
Debugging tools
Documentation tools
Development utilities

Formula

JDK = JRE + Development Tools

6.Why JDK is Important?

Without JDK, developers cannot create Java applications because it contains the compiler needed to convert source code into bytecode.

7.What is Bytecode?

Bytecode Definition

Bytecode is the intermediate code generated after compiling a Java program.

When we compile:

javac Hello.java

Java creates:

Hello.class

This .class file contains bytecode.

Why Bytecode is Important?

Bytecode is platform independent.

This means the same bytecode can run on:

Windows
Linux
macOS

This is the core reason behind Java’s portability.

8.What is JVM?

JVM → Java Virtual Machine

JVM is the heart of Java Architecture.

It converts bytecode into machine code and executes the program.

JVM acts as a bridge between Java applications and the operating system.

Responsibilities of JVM

Loads class files
Verifies bytecode
Executes code
Allocates memory
Performs Garbage Collection

9.What is JIT Compiler?

JIT → Just-In-Time Compiler

The JIT Compiler improves Java performance.

Instead of interpreting the same bytecode repeatedly, JIT converts frequently used bytecode into native machine code.

This makes Java programs faster.

How JIT Works?

Without JIT:

Bytecode → Interpreter → Execution

With JIT:

Bytecode → JIT Compiler → Native Machine Code → Faster Execution

Advantages of JIT Compiler

Improves performance
Reduces execution time
Optimizes frequently used code
Makes Java applications faster

10.What is JRE?

JRE → Java Runtime Environment

JRE provides the environment required to run Java applications.

It contains:

JVM
Core libraries
Supporting files

Formula

JRE = JVM + Libraries

Why JRE is Important?

If you only want to run Java applications and not develop them, JRE is enough.

11.Final Takeaway

Understanding concepts like JDK, JVM, JRE, Bytecode, and JIT Compiler is essential for every Java developer.

These concepts explain:

How Java programs execute
Why Java is platform independent
How Java manages memory
How Java achieves performance

Once you understand Java Architecture deeply, learning advanced Java concepts becomes much easier.