Forem: Karthick Narayanan

JavaScript Programs Using If-Else

Karthick Narayanan — Thu, 02 Apr 2026 13:55:33 +0000

1) Shopping Discount System

A user gets a discount based on the purchase amount. Members get an extra discount.

let amount = 6000;
let isMember = true;
let discount = 0;

if (amount >= 5000) {
    discount = 0.20;
} else if (amount >= 2000) {
    discount = 0.10;
} else {
    discount = 0;
}

let finalPrice = amount - (amount * discount);

if (isMember) {
    finalPrice = finalPrice - (finalPrice * 0.10);
}

console.log("Final Price:", finalPrice);

2) Login Access Check

Checks if user credentials are correct and not blocked.

let username = "admin";
let password = "1234";
let isBlocked = false;

if (isBlocked) {
    console.log("User is blocked");
} else if (username === "admin" && password === "1234") {
    console.log("Login successful");
} else {
    console.log("Invalid username or password");
}

3) Traffic Signal System

Simple program to show actions based on signal color.

let color = "red";

if (color === "red") {
    console.log("Stop");
} else if (color === "yellow") {
    console.log("Get Ready");
} else if (color === "green") {
    console.log("Go");
} else {
    console.log("Invalid signal");
}

4) ATM Withdrawal

Checks balance and withdrawal rules.

let balance = 5000;
let withdrawAmount = 2000;

if (withdrawAmount > balance) {
    console.log("Insufficient funds");
} else if (withdrawAmount <= 0) {
    console.log("Invalid amount");
} else {
    balance = balance - withdrawAmount;
    console.log("Remaining Balance:", balance);
}

5) Mobile Data Usage

Checks if the user is nearing or exceeding the data limit.

let dataUsed = 8;
let limit = 10;

let usage = (dataUsed / limit) * 100;

if (usage >= 100) {
    console.log("Limit exceeded");
} else if (usage >= 80) {
    console.log("Warning: nearing limit");
} else {
    console.log("Usage normal");
}

6) Electricity Bill Calculation

Calculates bill based on slab system.

let units = 350;
let bill = 0;

if (units <= 100) {
    bill = units * 5;
} else if (units <= 300) {
    bill = (100 * 5) + ((units - 100) * 7);
} else {
    bill = (100 * 5) + (200 * 7) + ((units - 300) * 10);
}

console.log("Total Bill:", bill);

JavaScript Part 3: Operators, Arithmetic, Assignment & Comparisons

Karthick Narayanan — Mon, 30 Mar 2026 12:39:37 +0000

An operator is a symbol that performs an operation on one or more values. Think of operators as the verbs of JavaScript — they make things happen.

1. JS Arithmetic Operators

Arithmetic operators do math.

Operator	Name	Example	Result
`+`	Addition	`10 + 5`	`15`
`-`	Subtraction	`10 - 5`	`5`
`*`	Multiplication	`10 * 5`	`50`
`/`	Division	`10 / 5`	`2`
`%`	Modulus (remainder)	`10 % 3`	`1`
`**`	Exponentiation	`2 ** 4`	`16`
`++`	Increment	`x++`	adds 1
`--`	Decrement	`x--`	subtracts 1

Basic examples

let a = 20;
let b = 6;

console.log(a + b);  // 26
console.log(a - b);  // 14
console.log(a * b);  // 120
console.log(a / b);  // 3.3333...
console.log(a % b);  // 2  (remainder when 20 is divided by 6)
console.log(a ** 2); // 400 (20 squared)

Modulus `%`

The % operator gives you the remainder after division. It's surprisingly useful!

console.log(10 % 3); // 1  → because 10 = (3 × 3) + 1
console.log(15 % 5); // 0  → because 15 divides evenly by 5

💡 A common use: checking if a number is even or odd.
let num = 8;
if (num % 2 === 0) {
  console.log("Even"); // Even
}

Increment `++` and Decrement `--`

These are shortcuts to add or subtract 1 from a variable.

let count = 5;

count++; // same as count = count + 1
console.log(count); // 6

count--; // same as count = count - 1
console.log(count); // 5

2. JS Assignment Operators

Assignment operators are used to set or update the value of a variable. You already know the basic one — =.

Operator	Example	Same as
`=`	`x = 10`	`x = 10`
`+=`	`x += 5`	`x = x + 5`
`-=`	`x -= 5`	`x = x - 5`
`*=`	`x *= 5`	`x = x * 5`
`/=`	`x /= 5`	`x = x / 5`
`%=`	`x %= 5`	`x = x % 5`
`**=`	`x **= 2`	`x = x ** 2`

Examples

let score = 100;

score += 50;  // score is now 150
score -= 20;  // score is now 130
score *= 2;   // score is now 260
score /= 4;   // score is now 65
score **= 2;  // score is now 4225

console.log(score); // 4225

These shorthand operators save you from writing the variable name twice. Instead of:

score = score + 50; // repetitive

You simply write:

score += 50; // clean and short ✅

3. JS Comparison Operators

Comparison operators compare two values and always return a boolean — either true or false.

Operator	Meaning	Example	Result
`==`	Equal to (loose)	`5 == "5"`	`true`
`===`	Equal to (strict)	`5 === "5"`	`false`
`!=`	Not equal (loose)	`5 != 3`	`true`
`!==`	Not equal (strict)	`5 !== "5"`	`true`
`>`	Greater than	`10 > 5`	`true`
`<`	Less than	`10 < 5`	`false`
`>=`	Greater than or equal	`5 >= 5`	`true`
`<=`	Less than or equal	`4 <= 5`	`true`

Basic examples

let age = 18;

console.log(age > 16);  // true
console.log(age < 16);  // false
console.log(age >= 18); // true
console.log(age <= 17); // false
console.log(age == 18); // true
console.log(age != 20); // true

`==` vs `===` — the most important difference

This is one of the most common beginner mistakes in JavaScript.

== (double equals) compares only the value, automatically converting types if needed.

=== (triple equals) compares both the value AND the type — no conversion.

console.log(5 == "5");  // true  ← JS converts "5" to a number first
console.log(5 === "5"); // false ← number vs string — not the same type!

console.log(0 == false);  // true  ← JS converts false to 0
console.log(0 === false); // false ← number vs boolean — not the same type!

Using comparisons in conditions

let marks = 75;

if (marks >= 50) {
  console.log("Pass ✅");
} else {
  console.log("Fail ❌");
}
// Output: Pass ✅

Quick Recap

Arithmetic operators — do math (+, -, *, /, %, **, ++, --)

Assignment operators — set or update variable values (=, +=, -=, *=, /=)

Comparison operators — compare values and return true or false (==, ===, !=, !==, >, <, >=, <=)

Tip	Remember
Use `%`	to check even/odd or remainders
Use `+=`	instead of `x = x + value`
Always use `===`	not `==` to avoid type bugs

JavaScript Part 2: let, const & Data Types

Karthick Narayanan — Mon, 30 Mar 2026 12:16:27 +0000

1. `let` — The Modern Variable

let was introduced in ES6 (2015) and is now the preferred way to declare variables that can change their value.

let age = 20;
console.log(age); // 20

age = 21; // ✅ you can update it
console.log(age); // 21

Why `let` over `var`?

The key difference is scope — let is block-scoped, meaning it only exists within the {} block it was defined in.

if (true) {
  let message = "Hi!";
  console.log(message); // ✅ works here
}
console.log(message); // ❌ ReferenceError — not accessible outside

With var, the same code would work outside the block — which often causes unexpected bugs. let keeps things predictable and safe.

2. `const` — The Constant

Use const when the value should never change after it's set.

const PI = 3.14159;
console.log(PI); // 3.14159

PI = 3; // ❌ TypeError — you cannot reassign a const

Must be initialised immediately

Unlike let, you cannot declare a const without giving it a value.

const country;        // ❌ SyntaxError
const country = "India"; // ✅ correct

When to use `let` vs `const`?

A simple rule of thumb:

Use const by default. Switch to let only if you know the value will change.

const userName = "Karthick";   // won't change — use const
let score = 0;                  // will change as user plays — use let

3. JavaScript Data Types

Every value in JavaScript has a type. Understanding types helps you know what you can do with a value.

JavaScript has 8 primitive types and 1 non-primitive type (object). Let's look at the most important ones.

String

A string is text. Wrap it in single quotes '...', double quotes "...", or backticks `...`.

let name = "Priya";
let city = 'Chennai';
let greeting = `Hello, ${name}!`; // template literal — can embed variables
console.log(greeting); // Hello, Priya!

Number

JavaScript has just one number type — it handles both whole numbers and decimals.

let age = 25;
let price = 49.99;
let temperature = -5;

You can also do math with numbers:

let total = 100 + 50;   // 150
let half = 100 / 2;     // 50
let squared = 4 ** 2;   // 16

BigInt

Use BigInt when you need whole numbers larger than what Number can safely handle.

JavaScript's Number type has a maximum safe value:

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

Beyond this, regular numbers lose precision. BigInt solves this — just add n at the end of the number:

let bigNumber = 9007199254740991n;
let bigger    = 99999999999999999999n; // no precision loss!

console.log(typeof bigNumber); // bigint

BigInt only works with other BigInts — you can't mix them with regular numbers:

let a = 100n + 200n; // ✅ 300n
let b = 100n + 5;    // ❌ TypeError

Boolean

A boolean is simply true or false. Used a lot in conditions.

let isLoggedIn = true;
let hasDiscount = false;

if (isLoggedIn) {
  console.log("Welcome back!");
}

Undefined

A variable that has been declared but not yet given a value is undefined.

let score;
console.log(score); // undefined

Null

null is an intentional "empty" value. You use it when you want to explicitly say "this has no value".

let selectedItem = null; // nothing selected yet

💡 undefined vs null: undefined means a value was never assigned. null means you intentionally set it to "nothing".

Object

An object groups related data together using key-value pairs.

let student = {
  name: "Karthick",
  age: 21,
  course: "Data Mining"
};

console.log(student.name);   // Karthick
console.log(student["age"]); // 21

Array

An array is a list of values, stored in order.

let fruits = ["apple", "mango", "banana"];
console.log(fruits[0]); // apple  (index starts at 0)
console.log(fruits.length); // 3

Checking the Type of a Value

Use the typeof operator to find out what type a value is:

console.log(typeof "hello");    // string
console.log(typeof 42);         // number
console.log(typeof true);       // boolean
console.log(typeof undefined);  // undefined
console.log(typeof null);       // object  ← known JavaScript quirk!
console.log(typeof {});         // object
console.log(typeof []);         // object

Quick Recap

Keyword	Can reassign?	Block-scoped?	Use when...
`var`	✅ Yes	❌ No	Legacy code only
`let`	✅ Yes	✅ Yes	Value will change
`const`	❌ No	✅ Yes	Value stays fixed

Type	Example
String	`"Hello"`
Number	`42`, `3.14`
Boolean	`true`, `false`
Undefined	`let x;`
Null	`let x = null;`
Object	`{ name: "Priya" }`
Array	`[1, 2, 3]`
BigInt	`9999999999999999n`

JavaScript Part 1: Syntax, Statements, Comments & Variables

Karthick Narayanan — Mon, 30 Mar 2026 10:00:11 +0000

1. JavaScript Syntax

Syntax is simply the set of rules that define how JavaScript code must be written just like grammar rules in English.

JavaScript is case-sensitive. This means name, Name, and NAME are all treated as different things.

let name = "Karthick";   // ✅ valid
let Name = "Ravi";       // also valid, but different variable

Whitespace (spaces, tabs, blank lines) is mostly ignored by JavaScript, but using it properly makes your code readable.

// Hard to read
let x=5;let y=10;let z=x+y;

// Easy to read
let x = 5;
let y = 10;
let z = x + y;

2. JavaScript Statements

A statement is a single instruction that tells JavaScript to do something. Think of it like a sentence in English — it expresses a complete action.

let age = 25;             // declares a variable
console.log(age);         // prints the value to the console
alert("Hello, World!");   // shows a popup in the browser

Semicolons

Statements usually end with a semicolon ;. While JavaScript can often figure out where a statement ends without it (a feature called ASI — Automatic Semicolon Insertion), it's good practice to always include them.

let city = "Chennai";   // ✅ with semicolon — recommended
let city = "Chennai"    // also works, but avoid relying on this

Code Blocks

Multiple statements can be grouped inside curly braces {}. You'll see this a lot with functions and conditions.

if (age > 18) {
  console.log("Adult");
  console.log("Can vote");
}

3. JavaScript Comments

Comments are notes you write in your code for yourself or other developers. JavaScript completely ignores them when running the code.

There are two types:

Single-line comments

Use // to comment out a single line.

// This is a single-line comment
let price = 500; // price is in rupees

Multi-line comments

Use /* ... */ to comment across multiple lines.

/*
  This function calculates the total price
  including GST.
  Written by: Karthick
*/
function calculateTotal(price) {
  return price * 1.18;
}

💡 Tip: Use comments to explain why you did something, not just what you did. The code itself shows what — the comment should explain why.

4. JavaScript Variables

A variable is like a labelled box — it stores a value that your program can use later.

Declaring a variable with `var`

var is the old way to declare variables (before 2015). You'll still see it in older code.

var greeting = "Hello!";
console.log(greeting); // Hello!

var has some quirky behavior (like being accessible outside the block it was defined in), which is why modern JavaScript uses let and const instead — covered in Part 2!

Naming variables

Variable names in JavaScript must follow these rules:

Must start with a letter, underscore _, or dollar sign $
Cannot start with a number
Cannot use reserved keywords like let, return, function
Are case-sensitive

let firstName = "Priya";    // ✅ valid
let _count = 0;             // ✅ valid
let $total = 100;           // ✅ valid
let 1stName = "Ravi";       // ❌ invalid — starts with a number
let let = "something";      // ❌ invalid — reserved keyword

Assigning and updating values

var score = 10;
console.log(score); // 10

score = 20;         // updating the value
console.log(score); // 20

Variables without a value

If you declare a variable but don't assign a value, it holds the special value undefined.

var myVariable;
console.log(myVariable); // undefined

Quick Recap

Concept	What it means
Syntax	Rules for writing valid JavaScript
Statement	A single instruction (often ends with `;`)
Comment	Notes in code ignored by JavaScript
Variable	A named container to store values

Day 17: Interface in Java

Karthick Narayanan — Thu, 29 Jan 2026 17:28:24 +0000

What is an Interface?

An interface is a set of rules that a class must follow.

Simple Definition

An interface tells a class what to do, not how to do it.

The how part is written by the class that implements the interface.

Why Do We Use Interface?

Interfaces are mainly used to:

Achieve 100% abstraction
Support multiple inheritance
Define common behavior across different classes
Enforce a standard structure in applications

How to Create an Interface?

We use the interface keyword.

Syntax:

interface InterfaceName {
    // abstract methods
}

Important Rules of Interface (Before Java 8)

An interface contains only abstract methods
All methods are public and abstract by default
All variables are public static final by default
We cannot create an object for an interface
We cannot create a constructor inside an interface

Simple Interface Example

interface ATM {

    void withdraw();

    void deposit();
}

Explanation:

Methods are automatically public abstract
No method body is allowed
No constructor is allowed

Implementing an Interface

A class uses the implements keyword to implement an interface.

class IciciBank implements ATM {

    @Override
    public void withdraw() {
        System.out.println("Withdraw money");
    }

    @Override
    public void deposit() {
        System.out.println("Deposit money");
    }
}

Explanation:

IciciBank implements ATM
All interface methods must be implemented
If not, the class must be declared abstract

Using the Implemented Interface

public class User {

    public static void main(String[] args) {
        ATM atm = new IciciBank();
        atm.withdraw();
        atm.deposit();
    }
}

Explanation:

Interface reference can point to class object
Achieves runtime flexibility
Implementation details remain hidden

Interface and Multiple Inheritance

Java does not support multiple inheritance using classes,
but it supports multiple inheritance using interfaces.

Example:

interface A {
    void methodA();
}

interface B {
    void methodB();
}

class C implements A, B {

    public void methodA() {
        System.out.println("Method A");
    }

    public void methodB() {
        System.out.println("Method B");
    }
}

Interface After Java 8

From Java 8 onwards, interfaces can have method body using:

1. Default Methods

interface Bank {

    default void welcome() {
        System.out.println("Welcome");
    }
}

Explanation:

default keyword allows method body
Helps in adding new methods without breaking existing code
Can be overridden in implementing class

2. Static Methods in Interface

interface Bank {

    static void rules() {
        System.out.println("Bank Rules");
    }
}

How to Call Static Method?

Bank.rules();

Important Points:

Static methods are called using interface name
Static methods cannot be overridden
Belong to the interface, not to the class

Key Differences: Abstract Class vs Interface

Feature	Abstract Class	Interface
Object creation	❌ No	❌ No
Constructor	✔ Yes	❌ No
Multiple inheritance	❌ No	✔ Yes
Method body	✔ Yes	❌ (Before Java 8)
Abstraction	Partial	100%

Key Points to Remember

Interface is a blueprint / rulebook
Achieves 100% abstraction
Uses implements keyword
Supports multiple inheritance
Cannot create object or constructor
Java 8 introduced default and static methods

When to Use Interface?

Use interface when:

You need multiple inheritance
You want complete abstraction
You want to define common behavior
You want loose coupling in applications

Day 16: Abstraction in Java

Karthick Narayanan — Wed, 21 Jan 2026 18:46:07 +0000

What is Abstraction?

Abstraction means:

Showing only the necessary data and hiding the unwanted or internal details.

In simple words, abstraction focuses on what an object does, not how it does it.

Why Do We Need Abstraction?

To reduce complexity
To hide implementation details
To improve security
To make code easy to understand and maintain

Real-life example:
When we use an ATM, we only know actions like withdraw, check balance, etc.
We don’t know how the ATM internally processes the transaction — that part is hidden.

How to Achieve Abstraction in Java?

Abstraction is achieved using the abstract keyword.

The abstract keyword can be used at:

Class level
Method level

Important Rules of Abstraction

An abstract class can have:
- Abstract methods
- Non-abstract (normal) methods
We cannot create an object for an abstract class
An abstract class can have a constructor
Abstract methods do not have a body
Child class must override all abstract methods

Abstract Class Example (From Class)

Abstract Class: `ATM`

public abstract class ATM {

    public abstract void withdraw();

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

    ATM() {
        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        // ATM atm = new ATM();  // Not allowed
    }
}

Explanation:

ATM is an abstract class
withdraw() is an abstract method
welcomeMessage() is a non-abstract method
Constructor is allowed in abstract class
Object creation of ATM is not allowed

Child Class Implementing Abstract Method

Class: `IciciBank`

public class IciciBank extends ATM {

    public static void main(String[] args) {
        IciciBank icici = new IciciBank();
    }

    @Override
    public void withdraw() {
        System.out.println("withdraw");
    }
}

Explanation:

IciciBank extends ATM
It implements the abstract method withdraw()
Without implementing withdraw(), this class would also become abstract
Object creation is allowed for IciciBank

Using the Implemented Methods

Class: `User`

public class User extends IciciBank {

    public static void main(String[] args) {

        User user = new User();
        user.welcomeMessage();
        user.withdraw();
    }
}

Explanation:

User class indirectly inherits from ATM
It can access:
- welcomeMessage() (non-abstract method)
- withdraw() (implemented method)
Output is achieved using abstraction without knowing internal logic

Flow of Execution

Object of User is created
Abstract class constructor executes first
welcomeMessage() method is called
withdraw() method implementation is executed

Key Points to Remember

Abstraction hides internal implementation
Achieved using abstract keyword
Abstract class can have constructor
Object creation for abstract class is not allowed
Child class must override abstract methods
Abstraction focuses on what, not how

Difference Between Abstract and Normal Class

Feature	Abstract Class	Normal Class
Object creation	❌ Not allowed	✔ Allowed
Abstract methods	✔ Allowed	❌ Not allowed
Constructor	✔ Allowed	✔ Allowed
Inheritance	✔ Required	Optional

When to Use Abstraction?

Use abstraction when:

You want to hide implementation details
Multiple classes follow a common structure
You want to enforce method implementation
You want loose coupling in your application

Day 15: Encapsulation and Access Modifiers in Java

Karthick Narayanan — Wed, 21 Jan 2026 18:40:49 +0000

What is Encapsulation?

Encapsulation means data protection.

In Java, encapsulation is the concept of wrapping data (variables) and methods together and controlling who can access them.

👉 In simple words:
Encapsulation = Protecting data from unauthorized access

How is Encapsulation Achieved in Java?

Encapsulation is achieved using Access Modifiers.

Access modifiers decide:

Who can access a class
Who can access variables
Who can access methods
Who can access constructors

What are Access Modifiers?

Access modifiers define the visibility of class members.

Java has 4 access modifiers:

private
default (no keyword)
protected
public

Example

Parent Class: `Nanthakumar`

public class Nanthakumar {

    private int salary = 10000;

    String task = "Dev";

    protected String headPhone = "redmi";

    public String designation = "Development";
}

Here we have declared variables with different access modifiers.

Main Class: `Karthick`

public class Karthick {

    public static void main(String[] args) {

        Karthick k = new Karthick();
        // System.out.println(k.salary); // Not allowed

        Nanthakumar n = new Nanthakumar();
        System.out.println(n.task);
        System.out.println(n.headPhone);
        System.out.println(n.designation);
    }
}

Child Class: `Ruby`

public class Ruby extends Nanthakumar {

    public static void main(String[] args) {

        Nanthakumar n = new Nanthakumar();
        // System.out.println(n.task); // Not allowed

        Ruby r = new Ruby();
        System.out.println(r.headPhone);
        System.out.println(r.designation);
    }
}

Understanding Each Access Modifier

1️⃣ Private

private int salary = 10000;

Accessible only inside the same class
Cannot be accessed outside the class
Used for maximum data protection

❌ Not accessible in Karthick
❌ Not accessible in Ruby

👉 This shows strong encapsulation

2️⃣ Default (No Keyword)

String task = "Dev";

Accessible within the same package
Not accessible outside the package
Also called package-private

✔ Accessible in Karthick (same package)
❌ Not accessible in Ruby (different class via inheritance)

3️⃣ Protected

protected String headPhone = "redmi";

Accessible within the same package
Accessible in child class even outside the package

✔ Accessible in Karthick
✔ Accessible in Ruby (because it extends Nanthakumar)

4️⃣ Public

public String designation = "Development";

Accessible from anywhere
No restriction

✔ Accessible in Karthick
✔ Accessible in Ruby

Access Modifier Visibility Table

Modifier	Same Class	Same Package	Subclass	Anywhere
private	✔	❌	❌	❌
default	✔	✔	❌	❌
protected	✔	✔	✔	❌
public	✔	✔	✔	✔

Why Encapsulation is Important?

Protects sensitive data
Prevents unauthorized access
Improves code security
Makes code easy to maintain
Follows real-world object behavior

Real-Life Example

Think of an ATM card:

PIN → private
Bank branch access → protected
Customer details → default
Bank name → public

You cannot access everything directly — this is encapsulation.

Key Points (For Revision)

Encapsulation means data protection
Achieved using access modifiers
private → most secure
public → accessible everywhere
protected → inheritance-friendly
default → package-level access

Day 14 – Method Overloading and Method Overriding in Java

Karthick Narayanan — Tue, 13 Jan 2026 14:10:35 +0000

Below are the two important object-oriented concepts in Java:

Method Overloading
Method Overriding

These concepts allow us to use the same method name in different ways, which improves code readability, flexibility, and reusability.

1️⃣ Method Overloading

What is Method Overloading?

Method Overloading means defining multiple methods with the same name in the same class, but with different parameter lists.

Java decides which method to call at compile time, based on:

Number of parameters
Type of parameters
Order of parameters

Example (From Class)

public class Bank {

    public static void main(String[] args) {

        Bank bank = new Bank();
        bank.balance("Karthick", 101);
        bank.balance(101);
        bank.getInerest();
    }

    private void balance(int accountNo) {
        System.out.println(accountNo);
    }

    public void balance(String name, int accountNo) {
        System.out.println(name);
        System.out.println(accountNo);
    }

    public void getInerest() {
        System.out.println("5%");
    }
}

Explanation

Two methods have the same name: balance
But their parameters are different:
- balance(int accountNo)
- balance(String name, int accountNo)
This is method overloading

When we call:

bank.balance("Karthick", 101);

Java calls:

balance(String name, int accountNo)

When we call:

bank.balance(101);

Java calls:

balance(int accountNo)

✔ The decision is made at compile time

Key Points of Method Overloading

Happens within the same class
Method name must be same
Parameters must be different
Return type alone cannot differentiate methods
Also known as Compile-time Polymorphism (concept only, not started yet)

2️⃣ Method Overriding

What is Method Overriding?

Method Overriding occurs when a child class provides its own implementation of a method that already exists in the parent class, with:

Same method name
Same parameters
Same return type

Inheritance is mandatory for method overriding.

Example (From Class)

public class SBI extends Bank {

    public static void main(String[] args) {
        SBI sbi = new SBI();
        sbi.getInerest();
    }

    public void getInerest() {
        System.out.println("10%");
    }
}

Explanation

Bank class has a method:

public void getInerest() {
    System.out.println("5%");
}

SBI class overrides the same method:

public void getInerest() {
    System.out.println("10%");
}

When we create an object of SBI:

SBI sbi = new SBI();
sbi.getInerest();

✔ The child class method is executed
✔ Output:

10%

This happens because Java checks the object type at runtime

Key Rules of Method Overriding

Inheritance is required
Method signature must be the same
Access modifier cannot be reduced
private, static, and final methods cannot be overridden
Decision is made at runtime

Method Overloading vs Method Overriding

Feature	Method Overloading	Method Overriding
Class	Same class	Parent–Child classes
Method name	Same	Same
Parameters	Different	Same
Inheritance	Not required	Required
Time of decision	Compile time	Runtime

Real-Time Understanding

Method Overloading → Same action, different inputs
(Example: balance check by account number or by name + account number)
Method Overriding → Same service, different behavior
(Example: Different banks offering different interest rates)

Interview Key Takeaways

Method Overloading improves flexibility
Method Overriding supports custom behavior
Java resolves overloading at compile time
Java resolves overriding at runtime
Overriding always depends on inheritance

Day 13: Understanding Inheritance in Java

Karthick Narayanan — Tue, 13 Jan 2026 13:57:25 +0000

What is Inheritance?

Inheritance is a mechanism in Java where one class acquires the properties and behaviors of another class.

The class whose properties are inherited is called the Parent / Super class
The class that inherits the properties is called the Child / Sub class

Inheritance represents an IS-A relationship.

Why Use Inheritance?

Inheritance is used to:

Reuse existing code
Avoid code duplication
Improve maintainability
Create a parent-child relationship between classes

Syntax of Inheritance

class Parent {
    // variables and methods
}

class Child extends Parent {
    // child class code
}

The keyword extends is used to achieve inheritance in Java.

Types of Inheritance in Java

Java supports five types of inheritance conceptually, but only three are supported using classes.

1. Single Inheritance

What is Single Inheritance?

A single child class inherits from one parent class.

Structure:

Parent → Child

Example:

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

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

Here, Dog inherits the eat() method from Animal.

2. Multilevel Inheritance

What is Multilevel Inheritance?

A class inherits from another class, which itself inherits from another class.

Structure:

Grandparent → Parent → Child

Example:

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

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

class Puppy extends Dog {
    void weep() {
        System.out.println("Puppy weeps");
    }
}

Here, Puppy can access methods from both Dog and Animal.

3. Hierarchical Inheritance

What is Hierarchical Inheritance?

Multiple child classes inherit from one parent class.

Structure:

        Parent
       /      \
   Child1   Child2

Example:

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

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

class Cat extends Animal {
    void meow() {
        System.out.println("Cat meows");
    }
}

Here, both Dog and Cat inherit from Animal.

4. Multiple Inheritance (Not Supported with Classes)

What is Multiple Inheritance?

A single class inherits from more than one parent class.

Example (Not Allowed):

class A { }
class B { }
class C extends A, B { } // ❌ Invalid

Java does not support multiple inheritance using classes to avoid ambiguity (Diamond Problem).

5. Hybrid Inheritance (Not Supported with Classes)

Hybrid inheritance is a combination of multiple inheritance types.

Java does not support hybrid inheritance using classes, but it can be achieved using interfaces.

Summary of Inheritance Support in Java

          | Type         | Supported Using Classes |
          | ------------ | ----------------------- |
          | Single       | Yes                     |
          | Multilevel   | Yes                     |
          | Hierarchical | Yes                     |
          | Multiple     | No                      |
          | Hybrid       | No                      |

Important Points to Remember

Inheritance uses the extends keyword
Java supports only single inheritance with classes
Parent class members are accessible in the child class
Constructors are not inherited
Inheritance promotes code reusability

When to Use Inheritance?

Use inheritance when:

There is a clear IS-A relationship
Child class needs parent class behavior
Code reuse is required

Key Points Summary

Inheritance allows one class to reuse another class’s code
It creates a parent-child relationship
Java supports single, multilevel, and hierarchical inheritance
Multiple inheritance is not supported using classes

Day 12: Understanding Constructors in Java

Karthick Narayanan — Thu, 08 Jan 2026 15:35:49 +0000

What is a Constructor?

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

Key Characteristics of a Constructor

Constructor name must be the same as the class name
It does not have a return type
It is called automatically when an object is created
Used to initialize instance variables

Why Do We Need Constructors?

Constructors help to:

Initialize object values
Reduce extra setter methods
Ensure objects are created in a valid state
Improve code readability and structure

Syntax of a Constructor

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

When an object of Student is created, the constructor executes automatically.

Types of Constructors in Java

Java mainly has two types of constructors:

Default Constructor
Parameterized Constructor

1. Default Constructor

A default constructor is a constructor with no parameters.

Example:

class Employee {

    Employee() {
        System.out.println("Hi");
    }

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

Explanation:

When the object emp is created, the default constructor is called and prints Hi.

2. Parameterized Constructor

A parameterized constructor accepts parameters to initialize object variables.

Example:

class Employee {

    int empId;
    String empName;
    int empAge;

    Employee(int empId, int empAge, String empName) {
        this.empId = empId;
        this.empAge = empAge;
        this.empName = empName;
    }

    public static void main(String[] args) {
        Employee kumar = new Employee(101, 20, "Kumar");
        System.out.println(kumar.empId);
    }
}

Explanation:

We have created a class named Employee.
Inside the class, we declared three variables:
int empId;, String empName;, and int empAge;.
These variables are declared but not initialized.
Since they are declared inside the class and outside the main method, they are instance (global) variables, which can be accessed anywhere inside the class using an object.
We then created a parameterized constructor named Employee that accepts three arguments with their respective data types.
Inside the constructor, we assigned the local variables (constructor parameters) to the instance variables using the this keyword.
In the main method, we created an object named kumar using the object creation syntax.
While creating the object, we passed values directly inside the constructor arguments.
These values are received by the constructor parameters and then assigned to the instance variables using the this keyword.
Since the values are now stored in the instance variables, we can access them using the object reference name.
Here, we printed the employee ID using:

   System.out.println(kumar.empId);

This prints the output:

Summary

A parameterized constructor allows us to initialize object values at the time of object creation using arguments.

The `this` Keyword in Constructors

What is `this`?

this is a reference variable that refers to the current object.

Why Use `this` Keyword?

When constructor parameters and instance variables have the same names, Java gives priority to the parameters.
The this keyword is used to differentiate instance variables from parameters.

Example Explanation

this.empId = empId;

this.empId → instance variable of the current object
empId → constructor parameter

This ensures the passed value is stored in the object.

Day 11: Understanding `break` and `continue` Statements in Java

Karthick Narayanan — Thu, 08 Jan 2026 14:07:56 +0000

What are `break` and `continue`?

In Java, break and continue are loop control statements.
They are used to change the normal flow of loops (for, while, do-while, and switch).

break → stops the loop completely
continue → skips the current iteration and moves to the next one

The `break` Statement

What is `break`?

The break statement is used to terminate a loop immediately when a specific condition is met.

Once break is executed:

The loop stops
Control moves to the statement after the loop

Syntax of `break`

break;

Example: Using `break` in a loop

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

Output:

Explanation:

The loop starts from 1. When i becomes 5, the break statement executes and stops the loop completely. Numbers after 4 are not printed.

Using `break` in a `switch` Statement

int day = 2;

switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Invalid day");
}

Explanation:

break prevents execution from falling into the next case. Without break, multiple cases would execute.

The `continue` Statement

What is `continue`?

The continue statement is used to skip the current iteration of a loop and move to the next iteration.

Unlike break:

The loop does not stop
Only the current iteration is skipped

Syntax of `continue`

continue;

Example: Using `continue` in a loop

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;
    }
    System.out.println(i);
}

Output:

Explanation:

When i becomes 3, the continue statement skips printing 3 and moves to the next iteration. The loop continues normally.

`break` vs `continue`

Feature	break	continue
Stops loop	Yes	No
Skips iteration	No	Yes
Control moves to	After loop	Next iteration
Used in switch	Yes	No

Important Points to Note

break exits the loop completely
continue skips only the current iteration
Both improve loop control and readability
Used with conditional statements (if)
Helps avoid unnecessary execution

Common Use Cases

`break` is used when:

A value is found in a search
Input validation fails
Loop should stop early

`continue` is used when:

Certain values should be ignored
Filtering even or odd numbers
Skipping invalid data

Example: Using `break` and `continue` Together

for (int i = 1; i <= 10; i++) {
    if (i == 3) {
        continue;
    }
    if (i == 8) {
        break;
    }
    System.out.println(i);
}

Output:

Explanation:

continue skips printing 3
break stops the loop when i reaches 8

Common Mistakes to Avoid

Forgetting break in switch cases
Using continue without understanding loop flow
Creating infinite loops accidentally
Confusing break and continue behavior

When to Use `break` and `continue`?

Use these statements when:

You need better control over loops
Certain conditions require early exit
Some iterations should be skipped
Writing clean and efficient logic

Day 10: Understanding the Nested `for` Loop in Java

Karthick Narayanan — Mon, 05 Jan 2026 14:42:38 +0000

What is a Nested for Loop?

A nested for loop means:

A for loop inside another for loop
The outer loop controls rows
The inner loop controls columns
Used when a task requires multiple levels of repetition

Syntax of Nested for Loop

for (initialization; condition; increment/decrement) {
    for (initialization; condition; increment/decrement) {
        // code to be executed
    }
}

How a Nested for Loop Works

Outer loop runs first
For each outer loop iteration:
- Inner loop runs completely
After inner loop finishes:
- Control goes back to outer loop
Process continues until outer loop ends

Order of Execution in a Nested for Loop

Outer Loop Initialization
Outer loop variable is initialized once.
Outer Loop Condition Check
If condition is true, control enters the loop.
Inner Loop Initialization
Inner loop variable is initialized.
Inner Loop Condition Check
If condition is true, inner loop body executes.
Inner Loop Execution
Code inside the inner loop runs.
Inner Loop Increment
Inner loop variable is updated.
Inner Loop Ends
When inner condition becomes false, control returns to outer loop.
Outer Loop Increment
Outer loop variable is updated.
Repeat
Steps repeat until outer loop condition becomes false.

Important Point to Note

Inner loop runs completely for each iteration of the outer loop
Total executions = outer loop count × inner loop count
Nested loops increase time complexity

Key Points

Used for patterns, tables, and matrix problems
Outer loop controls rows
Inner loop controls columns
Most common in star patterns

* Needs careful control to avoid performance issues

Common Mistakes to Avoid

Forgetting to reset inner loop variable
Using wrong loop conditions
Printing println() instead of print() inside inner loop
Creating infinite loops accidentally
Too many nested loops causing slow performance

When to Use Nested for Loops?

Use nested for loops when:

Working with rows and columns
Printing patterns
Handling tables or matrices
Performing repeated combinations

Forem: Karthick Narayanan

JavaScript Programs Using If-Else

1) Shopping Discount System

2) Login Access Check

3) Traffic Signal System

4) ATM Withdrawal

5) Mobile Data Usage

6) Electricity Bill Calculation

JavaScript Part 3: Operators, Arithmetic, Assignment & Comparisons

1. JS Arithmetic Operators

Basic examples

Modulus %

Increment ++ and Decrement --

2. JS Assignment Operators

Examples

3. JS Comparison Operators

Basic examples

== vs === — the most important difference

Using comparisons in conditions

Quick Recap

JavaScript Part 2: let, const & Data Types

1. let — The Modern Variable

Why let over var?

2. const — The Constant

Must be initialised immediately

When to use let vs const?

3. JavaScript Data Types

String

Number

BigInt

Boolean

Undefined

Null

Object

Array

Checking the Type of a Value

Quick Recap

JavaScript Part 1: Syntax, Statements, Comments & Variables

1. JavaScript Syntax

2. JavaScript Statements

Semicolons

Code Blocks

3. JavaScript Comments

Single-line comments

Multi-line comments

4. JavaScript Variables

Declaring a variable with var

Naming variables

Assigning and updating values

Variables without a value

Quick Recap

Day 17: Interface in Java

What is an Interface?

Simple Definition

Why Do We Use Interface?

How to Create an Interface?

Syntax:

Important Rules of Interface (Before Java 8)

Simple Interface Example

Explanation:

Implementing an Interface

Explanation:

Using the Implemented Interface

Explanation:

Interface and Multiple Inheritance

Example:

Interface After Java 8

1. Default Methods

Explanation:

2. Static Methods in Interface

How to Call Static Method?

Important Points:

Key Differences: Abstract Class vs Interface

Key Points to Remember

When to Use Interface?

Day 16: Abstraction in Java

What is Abstraction?

Why Do We Need Abstraction?

How to Achieve Abstraction in Java?

Important Rules of Abstraction

Modulus `%`

Increment `++` and Decrement `--`

`==` vs `===` — the most important difference

1. `let` — The Modern Variable

Why `let` over `var`?

2. `const` — The Constant

When to use `let` vs `const`?

Declaring a variable with `var`

Abstract Class: `ATM`

Class: `IciciBank`

Class: `User`

Parent Class: `Nanthakumar`

Main Class: `Karthick`

Child Class: `Ruby`