DEV Community: Ebenezer

Beginner Approach for Removing the Duplicates from Array

Ebenezer — Tue, 30 Jun 2026 16:51:14 +0000

Hey folks!

Good day...

Today I solved and practiced one of the tasks that is given by the trailner.
Task : To Remove the Duplicate elements in array

My Logic :

As a beginner and human what we will do to solve this problem is we should take the number and compare it to another number if it is same that is duplicate . After we find the duplicted we need to remove that element .The Same logic I implemented in my code because first I have my hand in one number compare it to next number if it is same skip the change of hand to the next number . If it is not same we need to change our hand to the next number that's how we loop through the array and find the duplicate. In my code I didn't remove the duplicate and pushed the duplicates to the end of the array.After that I created a variable to store the count of the result and loop through the count of the nums and printed it.

It's my kind of beginner approach (human thinking approach) there are so many methods to solve this problem like hashset , etc...

As a beginner for better understanding of loops and array I did it.

Code :

Output:

That's all about today.

Let's see tomorrow with another interesting blog...

Understanding and Practicing the Problem - Frequency of Characters in a String

Ebenezer — Mon, 29 Jun 2026 14:29:16 +0000

Hey Folks!

Good Day...

Today I Practiced one of the Frequently asked Question that is nothing but "To find the frequency of characters in a given string"

Disclaimer : Eventhough there are so many inbuilt methods or ways to find the solution for this problem in python . As a beginner / budding developer , I practiced using loop for better understanding about loops and concepts.

Let's get into Logic first:

By default we cannot change the string in python because Strings are Immutable in Python.So that I changed it to list , it is a basically a array in python . We can loop through it and change the characters we want.

By human brain logic , let's say "ebenezer" in this string the letter "e" is appeared four times and "b" appeared one time .
We need to run the loop and check the letter "e" is appeared or not , if it is appeared we have to increment the count.

But there is one difficulties after the second letter "b" again letter "e" will come and compare with other letters. If this thing happens the output will looks like e 4 , b 1 , e 3 ...

For that we have to change the already appeared letter to any unique characters like ! , @, # .

Code:

Output:

That's all about this Blog . See you in my next Blog...

My First Linux Community Meetup

Ebenezer — Sun, 14 Jun 2026 08:39:46 +0000

Hey Folks

Good Day...

First of all This Blog is Slightly Differnt Comparing to my Previous Blog , Coz I Wrote full of technical stuff or my learniing stuffs.
In this Blog I wrote about my first experience in Linux Community Meetup.
It's very Intersting Let's see How it goes from start to end

Introduction about ILUGC :

In this Introduction they talked about when and where the Linux Community meetup will held and what time will start.
And then about Mailing list , so we need to Subscribe to mailing list , It is like a group chat . When we mail to one person all others can see it through Mailing List .
Lastly about Matrix , It is like Whatsapp or Telegram group chat . They requested to join in both.

First Talk - Google's Developer Verification Policy:

These points are my summary or key takeaways from first talk
Google's new 2027 policy makes identity verification mandatory for all Android developers to stop fake apps. Sideloading apps from outside Google Play will be restricted with extra safety steps for users. To install unverified apps, users must enable developer mode, restart their phone, and wait 24 hours. After the 24-hour wait, they can use Android Debug Bridge (ADB) to install the app immediately. These rules will hurt open-source projects like F-Droid because they cannot verify every developer. F-Droid says this policy could end their project since they do not control individual developer keys. Alternative app stores may disappear if Google becomes the only gatekeeper for all Android apps. This change makes Android safer but also less open for free and independent software developers.g

Before the Second talk all the participants gave the Self Introduction about themselves , Profession , How they came inside the Linux World.

After that the volunteer introduced a New Challenge in one website called *W3.challs * .The challenge is nothing what are the differnt way to read a text in the file.

Second Talk - Why Playwright Despite of Selenium:

This talk is given by one of the audience , He is working on Automation . He used to work in Playwright tool.

These points are my summary or key takeaways from Second talk

Playwright has auto-waiting built-in, so tests do not fail when elements load slowly, while Selenium needs manual waits. Playwright supports parallel test execution natively, making tests run much faster on multiple browsers at once. It works with all modern browsers including Chromium, Firefox, and WebKit using a single API, while Selenium needs different drivers for each. Playwright also has built-in assertions, screenshots, videos, and API testing, so you do not need extra tools like Selenium does.

for last 30 minutes the discussion , Questions and answes went on . From my side I asked one question which is the best developer distribution in Linux? and I got the answer for that

You know any of the best developer distributor in Linux ?If you please let me know in comment section .Right now I am using mint-cinnamon If there is better distribution I can move to that for better efficieny in my work.

SO, That's all about my first community meetup , I think it is Nice collaboration with working professionals ,students .

Prime Number Problems Explained - Easy Logic with Python Code

Ebenezer — Fri, 12 Jun 2026 10:25:13 +0000

Hey guys

Good day...

This Blog contains the tasks which is given or Assigned by trainer.

SO first problem is
1) The number of prime numbers between 11 and 60 is________.
My Logic:
Intialize the two pointer 11 and 60 and run the while loop upto 60. Find the prime and print it .
Code:

Output:

Second task is
2) Find the 4 Digit Prime Number - Smallest

My Logic:
Run the loop between 1000 to 9999 so we all know first prime number is the smallest that's why I breaked the loop
Code:

Output:

Third task is
3) Write the smallest and the biggest two digit prime number. [First, Last --> Greatest Common Divisor]

My Logic:
Initialize the first and last variable with 0 and run the while loop between 10 to 99 if the prime loop runs firstly copy the value of the number to first and when the loop ends copy the last number to Last

Code:

Output:

Fouth task is
4)I am a two digit prime number and the sum of my digits is 10. I am also one of the factors of 57. Who am I?

My Logic:
They told only two digit so we are going to run a loop upto 99 and I created a function to find the sum of digits and when the prime number true loop starts run we are calling the function with prime number to find the sum of digits and nested if condition is check the factor for 57.

Code:

:
Output:

Fifth task is
5)What is the smallest 5 digit number that is exactly divisible by 72 and 108?

My Logic:
As they given the smallest five digit run the loop from 10000 to 99999 and the checking the condition using if and break the loop because they asked to find first only

Code:

Output:

Last task is

6) There are four Mobile Phones in a house. At 5 a.m, all the four Mobile
Phones will ring together. Thereafter, the first one rings every 15 minutes, the second one
rings every 20 minutes, the third one rings every 25 minutes and the fourth one rings
every 30 minutes. At what time, will the four Mobile Phones ring together again?

My Logic: This task is little bit tricky compared to all and also writing code . so we have to Least common multiple for 15,20,25,30 . Least common multiple is nothing but the joining point of all number . If we find that the task is over

Code:

Output:

After 5'o clock the alarm will ring at 10'o clock.

That's all about today's task
Let's see in another blog with different tasks...

Twin Primes and Divisible by 11

Ebenezer — Thu, 11 Jun 2026 20:51:59 +0000

Hey guys

Good day...

Continuation to the previous blog . Today I solved two tasks which is assigned by our trainer. These programs taught me how to use functions and where to use functions and another one is to thoroughly understand the modulo and float logic .

Ok first things first

1 .Twin Prime

Firstly the logic is simple we need to check the number is prime if the number is prime add it with 2 after adding pass the numbe to function to check that is also prime. That's how I thinks logic eventhough I'm weak in syntax stuff I did the program with trial and errror method

Output :

2.Divisible by 11

This problem we need to filter the number because the divisibility rule for 11 is Sum of alternative digits is either by 11 or Zero

So for example the number is 675433 so after the sum of alternative digits the answer is 14 and 14 and If we subtract it result will be zero
Another example is **272822 **so after the sum of alternative digits the answer is 17 and 6 If we subtract that the result is 11

Code :

Output :

So that's all about today's blog , Please adjust my English coz I'm very weak in grammar . I will learn and improve .

Let's see in next blog - Different tasks and Different Blog...

Problems can be Solved using Modulo and Float Operators

Ebenezer — Thu, 11 Jun 2026 14:24:06 +0000

Hey guys

Good day...

Yesterday Trainer assigned some tasks in python like divisibility check and printing some number patterns.
We will detaily in the blog how I solved using Modulo and Float Operators.

Firstly, The problem is we need to print 34 23 12 using the given number 1234

The output which I got is

Here I binded another problem which is assigned by trainer to find the total of the printed digits that is** 34 23 12**

Second task is similiar to first one but there is small change in operations . so we need to print to** 34 12** using the given number 1234

for that

The output which I got is

Third task is little bit different we need to print 456 123 using the given number 123456

for that

The output which I got is

Thanks for Seeing and Reading my Blog , Next Blog we will see about Twin Primes ,Consecutive Primes , Divisible by 11

Understanding Encapsulation in Java:Access Modifiers , Getters and Setters for Beginners

Ebenezer — Wed, 10 Jun 2026 22:01:22 +0000

Hey guys

Good day!

Today I learned one of the four pillars of OOP concepts that's wrapped inside the blog.
As I said, wrapped—guess what? It's nothing but encapsulation.
In encapsulation, as of now, I learned access modifiers and getter-setter methods. We will see them in detail in the blog.

Access Modifiers:

Definition : Access level modifiers determine whether other classes can use a particular field or invoke a particular method.

There are two levels of access control:

At the top level—public, or package-private (no explicit modifier).
At the member level—public, private, protected, or package-private (no explicit modifier).

Types of Access Modifiers:

Public
Default or package- private
Private
Protected

Public :

As the name gives it can be accessed by all
All means same class , same package child class, different package child class, same package non-child class ,different package non-child class.

Default or Package-Private :

As the name suggests it can be accessed only within the same package

Private :

As the name suggests , it is private to the parent classs, it cannot be accessed by no one outside the class.

Protected :

It is bit tricky when I practiced it. It can accessed by any class within the same package and by sub classes in the different packages.

Differentiation summary :

Getter and Setter methods :

Why we need that method :

Class 1:

public class GRT
{


private int price  = 14200;


//getter method
public int getPrice(){;
    return this.price;
}

public void setPrice(int price){
    if(price >= this.price)
        this.price = price;
    else
        System.out.println("Amount is less then fixed value");
}




}

Class 2:

public class Customer{
public static void main (String [] args){
                GRT grt = new GRT();
//                 int itemPrice = grt.getPrice();
//                System.out.println(itemPrice);

                    grt.setPrice(14500);
                    System.out.println(grt.getPrice());
                    grt.setPrice(14000);
        }
    }

Story for the above code :
There is a jewellery shop called GRT. Every day, the gold rate goes up and down. A customer visits the jewellery shop. Note that if the jewellery shop keeps the gold price public, the customer can access and change the price to whatever he or she wants. That is why we keep the price private.

When the customer walks into the shop and asks for the current gold price, that is called the getter method. If the customer wants to change the price, there is only one way to do it: through the setter method.

Inside the setter method, we can apply any conditions, rules, and regulations because the shop belongs to us.

How can we connect it with Encapsulation:

The gold price is kept private, so it cannot be accessed directly from outside the class.

The getter method is used to read or view the gold price.

The setter method is used to update the gold price while enforcing business rules and validations.

This is how encapsulation protects data and provides controlled access to it.

If you any doubts or clarifications feel free ask in the comment section because I am budding developer . Goodfeedbacks are always taken.

Let's see in the another Interesting Blog...

Palindrome Number — My Beginner Thinking Process, Pseudocode & Optimal Solution

Ebenezer — Sun, 07 Jun 2026 14:33:11 +0000

Hey Folks! 👋

Good Day...

As I shared in my previous blog, I have started a new problem-solving practice routine. From today onwards, I'll be working on some of the most commonly asked interview questions that developers often encounter during coding interviews. These problems are also popular on LeetCode, making them a great way to strengthen both problem-solving skills and coding fundamentals.
Today I solved one of the most famous beginner-friendly LeetCode problems: Palindrome Number.

At first, I wasn't thinking about code. I was thinking about the pattern.

Problem Statement

Given an integer x, return true if x is a palindrome and false otherwise.

Example

121  -> true

-121 -> false

10   -> false

A palindrome reads the same from left to right and right to left.

My Initial Thinking (Two Pointer Approach)

Before writing any code, I drew the number on paper.

For example:

1 2 1 2 1
↑       ↑
L       R

I started comparing the first and last digits.

1 == 1 

2 == 2

Eventually both pointers meet in the middle.

Since every comparison matched, the number is a palindrome.

My thought process was:

Compare left digit with right digit.

If both are same:
    Move inward.

If different:
    Not a palindrome.

This is exactly how humans check a palindrome.

Rule #1: Negative Numbers Are Never Palindromes

Example:

-121

Read from left to right:

-121

Read from right to left:

121-

Both are different.

Therefore:

Any negative number is NOT a palindrome.

Rule #2: Numbers Ending With 0 Are Not Palindromes

Example:

Reverse:

Which becomes:

Not the same.

Therefore:

If a number ends with 0 and is not 0 itself,
it cannot be a palindrome.

Examples:

10   
100  
120

But:

is a palindrome.

Moving From Pointer Thinking to Math Thinking

My initial idea was based on pointers.

However, LeetCode asks:

Can you solve it without converting the integer into a string?

That means we cannot use:

String.valueOf(x)

Instead, we need to work directly with digits.

We can extract digits using:

x % 10

and remove digits using:

x / 10

Beginner-Friendly Pseudocode

This is the pseudocode I understood before writing Java.

If number is negative
    Return false

If number ends with 0 and is not 0
    Return false

Create reversedHalf = 0

While original number is greater than reversedHalf

    Take the last digit

    Add that digit into reversedHalf

    Remove last digit from original number

For even length numbers:
    Compare original number and reversedHalf

For odd length numbers:
    Compare original number and reversedHalf/10

Return result

Understanding rev / 10

This confused me initially.

Let's take:

After processing:

x   = 1
rev = 12

Notice that:

rev
↓
1 2

The middle digit got included.

The middle digit doesn't need comparison because it has no pair.

So we remove it:

rev / 10

12 / 10 = 1

Now:

x = 1
rev/10 = 1

Match found

That's why the final condition is:

x == rev || x == rev / 10

Optimal Java Solution

class Solution {
    public boolean isPalindrome(int x) {

        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int rev = 0;

        while (x > rev) {
            int digit = x % 10;
            rev = rev * 10 + digit;
            x = x / 10;
        }

        return x == rev || x == rev / 10;
    }
}

Output

For input:

Output:

true

I verified the solution on LeetCode and it was accepted successfully.

Time Complexity

O(log₁₀ n)

We process only half of the digits.

Space Complexity

O(1)

No extra array, string, or collection is used.

Thanks for reading!

If you're also learning Data Structures & Algorithms as a beginner, feel free to share how you initially thought about this problem. Sometimes your thinking teaches more than an advanced solution.

Java for Beginners: Why Learn Java Instead of C, C++, C#, Python, or JavaScript?

Ebenezer — Sat, 06 Jun 2026 16:19:18 +0000

Hey Folks! 👋

Good Day...

I started learning Java one week ago.

Every day I hear the word Java.

If somebody asks me, "What are you studying in your crash course?"

My answer is always:

"Java."

In class, Java.

During practice, Java.

In Institute, Java.

Almost every day, the word Java appears somewhere in my life.

One day I was sitting quietly and started overthinking.

Questions began running through my mind:

Why Java?
What is Java?
When should we use Java?
How is Java different from other programming languages?

I believe asking the right questions is called curiosity.

And curiosity is often the starting point of mastering any skill.

Instead of ignoring these questions, I started researching. I spent time reading Oracle documentation, developer forums, Reddit discussions, Medium articles, and programming communities.

This blog is a summary of everything I learned in the simplest way possible.

Let's begin.

Before Java, Let's Understand the Problem

Today we have many programming languages:

C
C++
C#
Python
JavaScript
Go
Rust
Kotlin

So the obvious question is:

Why do colleges, institutes, and companies still teach Java?

The answer is simple:

Java solves some very important software engineering problems extremely well.

It is not the "best" language for everything.

But it is one of the most balanced languages ever created.

What Makes Java Different?

1. Write Once, Run Anywhere (WORA)

This is probably Java's most famous feature.

Suppose you write a Java program on Windows.

You can run the same program on:

Linux
macOS
Unix

without changing the source code.

This concept is called:

Write Once, Run Anywhere

How?

Because Java code is converted into something called Bytecode.

That Bytecode runs inside the JVM (Java Virtual Machine). Oracle explains that Java programs are compiled into platform-independent bytecode which is executed by a JVM available for different operating systems.

Real-Life Example

Imagine writing a movie in English.

Instead of rewriting the movie in Tamil, Hindi, Telugu, and Malayalam, you simply use a translator.

The JVM acts like that translator.

Your Java code stays the same.

Only the JVM changes depending on the operating system.

2. Easier Than C and C++

Many experienced developers say Java borrowed the good parts of C and C++ while removing some complicated features.

Java removes:

Direct memory manipulation
Complex pointer handling
Multiple inheritance through classes

This makes learning easier for beginners. Oracle's documentation notes that Java's syntax is similar to C and C++ but omits features that make those languages complex and unsafe.

Beginner View

Think about driving.

C and C++ are like driving a manual sports car.

Java is like driving a modern automatic car.

You still learn driving principles, but with fewer chances to make dangerous mistakes.

3. Automatic Memory Management

One of the biggest problems in programming is memory management.

In languages like C, developers often need to manually manage memory.

Java introduced something called:

Garbage Collection

The JVM automatically removes unused objects from memory.

Real-Life Example

Imagine your room.

Instead of cleaning old waste yourself every day, someone automatically removes garbage whenever it becomes useless.

That's exactly what Java's Garbage Collector does.

4. Strong Object-Oriented Programming (OOP)

When people say:

"Learn Java and your programming fundamentals become strong."

They are usually talking about OOP.

Java heavily encourages:

Classes
Objects
Encapsulation
Inheritance
Polymorphism
Abstraction

These concepts are used in enterprise software around the world.

Why Is This Important?

Large companies build huge applications.

Without proper structure, the code becomes a nightmare.

Java helps organize software like a well-planned city.

5. Enterprise Companies Love Java

Many large organizations use Java because it is:

Stable
Secure
Scalable
Reliable

Oracle states that Java remains one of the world's most widely used development platforms and continues to be a preferred choice for enterprises.

Industries using Java include:

Banking
Insurance
Healthcare
Manufacturing
E-commerce
Government systems

This is one reason Java skills remain valuable.

6. Multithreading Support

Java allows multiple tasks to run simultaneously.

This feature is called:

Multithreading

For example:

While downloading a file:

One thread downloads data.
Another thread updates the progress bar.
Another thread keeps the application responsive.

Java provides built-in support for this capability.

7. Security

Security was one of Java's design goals from the beginning.

Java programs run inside the JVM, which adds an extra layer of protection.

This is one reason Java became popular in enterprise environments. Oracle documentation highlights Java's security-focused architecture and runtime environment.

Java vs Other Popular Languages

Java vs C

Java	C
Object-Oriented	Procedural
Automatic Memory Management	Manual Memory Management
Platform Independent	Platform Dependent
Easier for Large Applications	Great for System Programming

Java vs C++

Java	C++
Simpler	More Complex
Garbage Collection	Manual Memory Handling
Safer for Beginners	More Control
JVM Based	Native Compilation

Java vs Python

Java	Python
Faster in Many Enterprise Cases	Simpler Syntax
Strong OOP Structure	Very Beginner Friendly
Used Heavily in Large Enterprises	Popular in AI and Data Science

Java vs JavaScript

Many beginners think Java and JavaScript are related.

They are completely different languages.

Java

Backend
Android
Enterprise Software
Banking Applications

JavaScript

Websites
Frontend Development
Browser Applications

The names are similar.

The languages are not.

So Why Do Institutes Teach Java First?

Because Java sits in the middle.

It teaches:

Programming logic
OOP concepts
Software architecture
Industry coding practices

Once you understand Java well:

Python becomes easier
C# becomes easier
JavaScript becomes easier
Frameworks become easier

Java teaches the foundation.

My Learnings :

Initially I thought:

"Java is just another programming language."

After researching, I realized:

Java is not famous simply because it is old.

Java is famous because it solves real-world software problems very effectively.

The more I learn Java, the more I understand that it is teaching me not only syntax but also how professional software is designed.

Final Thoughts

If you are a beginner and wondering:

"Should I learn Java in 2026?"

My answer would be:

Yes.

Not because Java is perfect.

Not because Java is the easiest.

But because Java teaches programming fundamentals, software design, object-oriented thinking, and industry-standard development practices.

And those skills remain valuable regardless of which programming language you learn next.

Keep asking questions.

Because curiosity is where every developer's journey begins.

Sources

Python Looping #3: Divisors, Multiples, and Number Patterns Explained

Ebenezer — Sat, 06 Jun 2026 05:16:52 +0000

Hey Folks! 👋

Good Day.

Welcome back to Day 3 of my Python Problem Solving journey.

Over the past few days, our trainer assigned us 15 beginner-level Python problems to strengthen our logical thinking and programming fundamentals.

In my previous blogs, I covered factorials, perfect numbers, and custom number patterns. Today, I completed the remaining problems from the assignment using simple logic and basic Python concepts.

Whenever I face a new problem, I try to answer three questions before writing code:

What is the expected output?
What pattern do I see?
How would I solve it manually on paper?

Once those answers become clear, the code usually becomes straightforward.

In this Blog, I'll share the solutions along with the way I approached each problem mentally.

Problem 1: Finding Divisors of a Number

Let's take the number 10.

The divisors of 10 are:

1 2 5 10

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

Before coding, I thought:

If I wanted to find all divisors manually, I would check every number from 1 to 10 and see whether it divides 10 perfectly.

That thought became the algorithm.

Python Solution

no = 10
i = 1
count = 0

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

    i += 1

print(count)

Pseudocode

START

number = 10

FOR every value from 1 to number

    IF number is divisible by current value

        PRINT current value

END FOR

PRINT total divisor count

STOP

What I Learned

The modulus operator (%) is one of the most useful tools in problem solving.

Whenever I need to check:

divisors
multiples
odd numbers
even numbers

I almost always end up using %.

Problem 2: Multiples of 3 and 5

The goal was to print numbers that are divisible by both 3 and 5 between 1 and 100.

Before coding, I asked:

What makes a number a multiple of both 3 and 5?

Answer:

number % 3 == 0
AND
number % 5 == 0

Python Solution

no = 1

while no <= 100:

    if no % 3 == 0 and no % 5 == 0:
        print(no)

    no += 1

Pseudocode

START

number = 1

WHILE number <= 100

    IF divisible by 3 AND divisible by 5

        PRINT number

    number = number + 1

END WHILE

STOP

Key Learning

Many beginners confuse:

and

with

or

Remember:

and → both conditions must be true
or → at least one condition must be true

Problem 3: Simple Number Patterns

Most beginners see pattern problems as difficult.

I used to think the same.

Now I try a different approach.

Instead of looking at the whole pattern, I ask:

What changes between one number and the next?

Once I find that relationship, the pattern becomes easy.

Pattern 1

Output:

1 1 1 1 1

Observation

Nothing changes.

The same value is printed every time.

no = 1

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

Pattern 2

Output:

1 2 3 4 5

Observation

Increase by 1.

no = 1

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

Pattern 3

Output:

1 3 5 7 9

Observation

Increase by 2.

no = 1

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

Pattern 4

Output:

3 6 9 12 15

Observation

Multiples of 3.

no = 1

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

Pattern 5

Output:

15 12 9 6 3

Observation

Reverse multiples of 3.

no = 5

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

Pattern 6

Output:

10 8 6 4 2

Observation

Reverse multiples of 2.

no = 5

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

Pattern 7

Output:

9 7 5 3 1

Observation

Reverse odd numbers.

no = 9

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

The Biggest Lesson From These 15 Problems

After solving all 15 problems, I realized something interesting.

The challenge was never Python.

The challenge was understanding the pattern.

Once the logic became clear, the code became simple.

What's Next?

With these beginner practice problems completed, I'll be moving to a new phase from tomorrow.

Instead of simple exercises, I'll start solving interview-style and job-market coding questions in detail.

The focus will be on:

Problem-solving approaches
Multiple solutions
Time complexity discussions
Common interview questions
Real-world coding challenges

Let's see what tomorrow brings.

Java Runtime Polymorphism Explained: My Learning Journey with Method Overriding

Ebenezer — Fri, 05 Jun 2026 16:29:32 +0000

Introduction

Hey Folks! 👋

Good Day...

Today’s Java session was one of those classes where multiple concepts suddenly connected together. Initially, I thought Method Overriding was just about writing the same method in a child class. But as we explored deeper, I understood how concepts like Upcasting, Runtime Polymorphism, Dynamic Method Dispatch, Reference Types, and Object Types all work together behind the scenes.

In this blog, I’ll share my key takeaways from today's session and the thought process that helped me understand them.

1. A Class is the Data Type of an Object

One of the first things I learned today was that a class acts as a data type for objects.

For example:

Dog dog = new Dog();

Here:

Dog is the class
dog is the reference variable
new Dog() creates the object

Just like int is a data type for numbers, a class becomes a data type for objects.

2. Defining a Child Object as a Parent Reference

The next interesting concept was:

Animal animal = new Dog();

At first, this syntax looked strange.

Questions that came to my mind:

Why are we creating a Dog object?
Why is the reference variable Animal?
Is Java allowing this?

The answer is yes.

This concept is called Upcasting.

Since every Dog is an Animal, Java automatically allows a child object to be stored inside a parent reference.

Dog → Animal

This conversion happens automatically and is therefore known as Implicit Upcasting.

3. What is Method Overriding?

Method Overriding happens when a child class provides its own implementation of a method already present in the parent class.

Example:

class Animal {

    void makeSound() {
        System.out.println("Animal Sound");
    }
}

class Dog extends Animal {

    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

Here, the Dog class overrides the makeSound() method of the Animal class.

4. Rules of Method Overriding

One important thing I learned today is that overriding follows strict rules.

The following must remain the same:

Method Name
Number of Parameters
Parameter Data Types
Parameter Order

Example:

void display(String name, int age)

The child class must use the exact same method signature.

5. What About Return Types?

Initially, I assumed return types must always be identical.

That is partially true.

Example:

String getName()

can be overridden by:

String getName()

However, Java also supports something called Covariant Return Types.

Example:

class Animal {

    Animal getAnimal() {
        return new Animal();
    }
}

class Dog extends Animal {

    @Override
    Dog getAnimal() {
        return new Dog();
    }
}

Since Dog is a subclass of Animal, Java allows this override.

6. Why Do We Call Method Overriding Runtime Polymorphism?

This was the most important learning of the session.

Consider:

Animal animal = new Dog();

animal.makeSound();

The compiler only knows:

Animal animal

But the actual object created is:

new Dog()

When the method executes, Java checks the actual object type and calls:

Dog.makeSound()

instead of:

Animal.makeSound()

The method decision happens while the program is running.

That is why it is called Runtime Polymorphism.

7. Reference Type vs Object Type

This concept helped me understand Runtime Polymorphism more clearly.

Example:

Animal animal = new Dog();

Reference Type:

Animal

Object Type:

Dog

Important Rule

Reference Type decides:

Which methods are visible at compile time

Object Type decides:

Which overridden method runs at runtime

This single statement clarified many of my doubts.

8. Dynamic Method Dispatch

When Java executes:

animal.makeSound();

it performs a runtime check.

Java asks:

What object is this reference pointing to?

If the object is Dog:

Dog.makeSound()

is executed.

If the object is Cat:

Cat.makeSound()

is executed.

This mechanism is known as Dynamic Method Dispatch.

9. Why Is It Called Runtime Polymorphism?

Another interesting discussion today was:

Why specifically "Runtime"?

Because objects are created only when the application runs.

Example:

new Dog()

The object memory is allocated during execution.

Since Java determines the actual method implementation using the runtime object, the behavior can only be finalized while the program is running.

Hence the name:

Runtime Polymorphism

10. Practice Exercise

To reinforce these concepts, I implemented an Employee hierarchy.

Employee e1 = new Developer();
Employee e2 = new Tester();

e1.work();
e2.work();

This simple example helped me visualize:

Upcasting
Method Overriding
Dynamic Method Dispatch
Runtime Polymorphism

all working together in a single program.

Final Thoughts

Today's session completely changed how I view Method Overriding.

Initially, I thought overriding was just about writing the same method in a child class.

Now I understand that Method Overriding is the foundation of:

Runtime Polymorphism
Dynamic Method Dispatch
Upcasting
Flexible Object-Oriented Design

The biggest takeaway for me was:

Reference Type decides what methods can be called. Object Type decides which overridden method gets executed.

That one sentence connected almost every concept we discussed today.

References

Python Looping #2: Factorial, Perfect Numbers, and Pattern Printing Explained

Ebenezer — Thu, 04 Jun 2026 17:27:48 +0000

Hey Folks! 👋

Good Day.

Welcome back to Day 2 of my Python Problem Solving journey.

A few days ago, our trainer assigned us 15 Python programming problems . Today, I solved another three problems from that list.

One thing I've started realizing is that programming is less about syntax and more about problem-solving. Once the logic becomes clear, writing the code becomes much easier.

In this article, I'll walk through three Python problems I solved and share the thinking process behind each solution.

Problem 1: Factorial of a Number

Understanding the Problem

A factorial is the product of all positive integers from a given number down to 1.

For example:

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

Result:

Before writing any code, I asked myself:

If I were solving this manually on paper, what exact steps would I follow?

The answer became the algorithm itself.

Start with 1.
Multiply by the current number.
Move to the next smaller number.
Repeat until reaching 1.

Python Solution Using While Loop

no = 5
factorial = 1

while no > 0:
    factorial = factorial * no
    no -= 1

print(factorial)

Output

Pseudocode

START

number = 5
factorial = 1

WHILE number > 0
    factorial = factorial × number
    number = number - 1
END WHILE

PRINT factorial

STOP

Flowchart

Start
  |
  v
number = 5
factorial = 1
  |
  v
number > 0 ?
  |
 Yes
  |
factorial = factorial * number
  |
number = number - 1
  |
  +------> Repeat
  |
 No
  |
Print factorial
  |
 End

Alternative Solution Using For Loop

no = 5
factorial = 1

for i in range(1, no + 1):
    factorial = factorial * i

print(factorial)

Output

Key Takeaway

When you already know how many iterations are required, a for loop is usually cleaner and easier to read.

Problem 2: Print Odd Numbers First and Then Even Numbers

Expected Output

1 3 5 7 9 2 4 6 8 10

At first glance, most people would solve this using two separate loops:

One loop for odd numbers
One loop for even numbers

I wanted to see whether I could achieve the same result using a single loop.

My Thought Process

I imagined the output as two separate queues.

Odd numbers:

1 → 3 → 5 → 7 → 9

Even numbers:

2 → 4 → 6 → 8 → 10

The challenge wasn't generating the numbers.

The challenge was switching from the first sequence to the second without creating another loop.

Python Solution

no = 1

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

    if no == 11:
        no = 2

Output

1 3 5 7 9 2 4 6 8 10

How the Logic Works

The loop starts at 1 and keeps incrementing by 2.

This generates:

1 3 5 7 9

After printing 9:

no += 2

changes the value to:

At that point:

if no == 11:
    no = 2

resets the sequence and begins printing even numbers.

A small condition completely changes the direction of the program.

Pseudocode

START

number = 1

WHILE number <= 10

    PRINT number

    number = number + 2

    IF number == 11
        number = 2

END WHILE

STOP

Flowchart

Start
  |
  v
number = 1
  |
  v
number <= 10 ?
  |
 Yes
  |
Print number
  |
number = number + 2
  |
number == 11 ?
 / \
Yes No
 |
number = 2
 |
 +------> Repeat
 |
 No
 |
 End

Key Takeaway

Sometimes a simple condition can eliminate the need for an additional loop.

Always ask yourself:

Can I simplify the solution without making it harder to understand?

Problem 3: Perfect Number Program in Python

What Is a Perfect Number?

A perfect number is a number whose proper divisors add up exactly to the original number.

Example:

Divisors:

1, 2, 3

Sum:

1 + 2 + 3 = 6

Since the sum equals the original number, 6 is called a Perfect Number.

Real-World Analogy

Imagine a group of friends contributing money to buy a gift.

If the total contribution exactly matches the target amount, everything balances perfectly.

That's exactly how a perfect number works.

The sum of all valid contributors (divisors) equals the target amount (the number itself).

Python Solution

no = 496
sum = 0
i = 1

while i < no:

    if no % i == 0:
        sum += i

    i += 1

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

How the Logic Works

The program checks every number from 1 to n - 1.

If a number divides the original number without leaving a remainder:

no % i == 0

it gets added to the running total.

After all checks are complete, we compare:

sum == no

If both values match, the number is perfect.

Dry Run Using 6

Divisor	Added?	Running Sum
1	Yes	1
2	Yes	3
3	Yes	6
4	No	6
5	No	6

Final Check:

6 == 6

Result:

Perfect Number

Pseudocode

START

number = n
sum = 0

FOR each value from 1 to n - 1

    IF value divides number
        sum = sum + value

END FOR

IF sum equals number
    PRINT Perfect Number
ELSE
    PRINT Not Perfect Number

STOP

Flowchart

Start
  |
  v
sum = 0
i = 1
  |
  v
i < number ?
  |
 Yes
  |
number % i == 0 ?
 / \
Yes No
 |
sum += i
 |
i += 1
 |
 +------> Repeat
 |
 No
 |
sum == number ?
 / \
Yes No
 |   |
Perfect
     |
Not Perfect

What I Learned from These Problems

Although these programs are small, they helped me strengthen some important programming fundamentals:

Loops
Conditional Statements
Mathematical Logic
Pattern Generation
Problem Decomposition
Dry Running Code

* Converting Logic into Programs

My Current Problem-Solving Workflow

Problem
    ↓
Understand the Requirement
    ↓
Break It Into Smaller Steps
    ↓
Write Pseudocode
    ↓
Code

This workflow has helped me reduce mistakes and understand programming concepts much more deeply.

If you're new to this series, check out Part 1:

https://dev.to/buddingdeveloper/python-for-beginners-how-i-solved-two-classic-problems-in-multiple-ways-with-flowcharts-30ie