DEV Community: SILAMBARASAN A

Interface in Java

SILAMBARASAN A — Thu, 14 May 2026 12:09:36 +0000

An interface in Java is a blueprint of a class.

It contains:

method declarations
constants

But usually it does not contain full method implementation.

Interface tells:

What to do
not
How to do

Syntax

interface Animal {

    void sound();

}

Here:

Animal is interface
sound() has no body

Implementing Interface

class Dog implements Animal {

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

}

implements keyword is used.

Why use Interface?

1. Achieve Abstraction

Hide internal details.

void sound();

Only rule is given.

2. Multiple Inheritance

Java does not support:

class A extends B, C

But interface allows multiple inheritance.

interface A {}
interface B {}

class Test implements A, B {}

Variables in interface are:

Automatically:

public static final

Example:

interface Test {

    int x = 10;

}

Same as:

public static final int x = 10;

Methods are automatically:

public abstract

Abstract In Java

SILAMBARASAN A — Wed, 13 May 2026 18:12:30 +0000

In Java, abstract means incomplete.

It is used when a class or method is not fully finished and child classes must complete it.

Abstract Class

A class declared with abstract keyword is called an abstract class.

abstract class Animal {
}

Cannot create object directly
Mostly used as parent class

Animal a = new Animal(); // ❌ Error

Abstract Method

An abstract method has:

only declaration
no body

abstract void sound();

Child class must implement it.

Example

abstract class Animal {
    abstract void sound();
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

Here:

Animal gives only idea
Dog completes the method

Simple Real-Life Example

Think about a “Vehicle”.

All vehicles move, but:

Car moves differently
Bike moves differently

So parent class says:

abstract void move();

Child classes define how they move.

final keyword in java?

SILAMBARASAN A — Wed, 13 May 2026 05:28:58 +0000

In Java, the final keyword is used to stop changes.
It can be used with variables, methods, and classes.

If a variable is final, its value cannot be changed.
If a method is final, it cannot be overridden.
If a class is final, it cannot be inherited.

1. Final Variable

A final variable can only be assigned once.

final int x = 10;
x = 20; //  Error: cannot change value

Acts like a constant
Must be initialized once (either at declaration or in constructor)

2. Final Method

A final method cannot be overridden by subclasses.

class Parent {
    final void show() {
        System.out.println("Final method");
    }
}

class Child extends Parent {
    void show() { //  Error
        System.out.println("Cannot override");
    }
}

3. Final Class

A final class cannot be inherited (extended).

final class Animal {}

class Dog extends Animal { //  Error
}

Example:

String class in Java is final

Pojo in Java

SILAMBARASAN A — Tue, 12 May 2026 07:19:51 +0000

POJO in Java – What and Why?

In Java, POJO stands for Plain Old Java Object.

A POJO is a simple Java class that is not dependent on any special framework, API, or technology.

It is mainly used to store and manage data in a clean and organized way.

What is a POJO?

A POJO class usually contains:

Private variables (fields)
Getter and Setter methods
Constructors
Optional business methods

Example of a POJO Class

public class Student {

    private int id;
    private String name;

    // Default Constructor
    public Student() {
    }

    // Parameterized Constructor
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getter
    public int getId() {
        return id;
    }

    // Setter
    public void setId(int id) {
        this.id = id;
    }

    // Getter
    public String getName() {
        return name;
    }

    // Setter
    public void setName(String name) {
        this.name = name;
    }
}

This is called a POJO class because:

It is a normal Java object
No framework dependency
Used mainly for storing data

Why Do We Use POJO?

1. To Store Data Properly

Instead of using many separate variables:

int id = 1;
String name = "Silambu";

We group them into one object:

Student s = new Student();

This makes code cleaner and easier to manage.

2. Improves Code Readability

POJO helps organize related data together.

Without POJO:

id, name, age, address

With POJO:

Student object

Easy to understand.

3. Reusability

One POJO class can be reused in:

Controllers
Services
Database operations
APIs
JSON conversion

4. Easy Database Mapping

Frameworks like:

Hibernate
JPA
Spring Boot

use POJO classes to map database tables into Java objects.

Example:

Database Column	POJO Field
student_id	id
student_name	name

5. Easy JSON Conversion

POJO objects can easily convert to:

JSON
XML

Example:

{
  "id": 1,
  "name": "Silambu"
}

Real-Life Example

Think of a POJO like a student form.

A form contains:

Name
Age
Roll Number

Similarly, a POJO stores related data together inside one class.

Important Characteristics of POJO

A POJO:

Does not extend special classes
Does not implement unnecessary interfaces
Has private fields
Uses getters/setters
Is simple and independent

POJO vs Normal Variable

Normal Variables

String name;
int age;

Data is separate.

POJO

Student s;

All related data is grouped together.

Method Overriding in Java

SILAMBARASAN A — Tue, 05 May 2026 18:58:23 +0000

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.

Rules for Java Method Overriding

The method must have the same name as in the parent class.
The method must have the same parameter as in the parent class.
There must be an IS-A relationship (inheritance).

What Cannot Be Overridden?

Static Methods: You cannot override static methods; defining a same-named static method in a subclass is called "method hiding".
Final Methods: Methods declared with the final keyword cannot be overridden.
Private Methods: Since private methods are not inherited, they cannot be overridden.
Constructors: Constructors are unique to their own class and cannot be overridden.

class Animal {
   protected void displayInfo() {
      System.out.println("I am an animal.");
   }
}

class Dog extends Animal {
   public void displayInfo() {
      System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
      Dog d1 = new Dog();
      d1.displayInfo();
   }
}

Java Inheritance

SILAMBARASAN A — Sat, 02 May 2026 05:29:21 +0000

In Java, it is possible to inherit attributes and methods from one class to another. We group the "inheritance concept" into two categories:

subclass (child) - the class that inherits from another class
superclass (parent) - the class being inherited from

To inherit from a class, use the extends keyword.

In the example below, the Car class (subclass) inherits the attributes and methods from the Vehicle class (superclass):

Superclass (Parent): The class whose features are inherited
Subclass (Child): The class that inherits features

class Parent {
    void show() {
        System.out.println("This is parent class");
    }
}

class Child extends Parent {
    void display() {
        System.out.println("This is child class");
    }
}

public class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show();    // inherited method
        obj.display(); // own method
    }
}

Types of Inheritance in Java

Java supports these types:

1. Single Inheritance

One class inherits from one class

class A {}
class B extends A {}

2. Multilevel Inheritance

A chain of inheritance

class A {}
class B extends A {}
class C extends B {}

3. Hierarchical Inheritance

Multiple classes inherit from one parent

class A {}
class B extends A {}
class C extends A {}

Java Packages

SILAMBARASAN A — Tue, 21 Apr 2026 06:32:08 +0000

A package in Java is used to group related classes. Think of it as a folder in a file directory. We use packages to avoid name conflicts, and to write a better maintainable code. Packages are divided into two categories.

Built-in Packages (packages from the Java API)
User-defined Packages (create your own packages) The Java API is a library of prewritten classes, that are free to use, included in the Java Development Environment.

Built-in Packages

The library contains components for managing input, database programming, and much much more. The complete list can be found at Oracles website: https://docs.oracle.com/javase/8/docs/api/.

User-defined Packages

To create your own package, you need to understand that Java uses a file system directory to store them. Just like folders on your computer.

java.lang: This package holds the foundational classes.
java.io: It handles all sorts of input and output operations.
java.awt: This package provides the basic building blocks for creating graphical user interfaces (GUIs).
javax.swing: It is best for more advanced and richer desktop application GUIs due to its comprehensive toolkit.
java.net: It contains classes essential for developing network-aware applications.
java.util: It is a versatile package filled with utility classes, including the powerful Collections Framework.
java.applet: This package includes classes for building applets, which are small applications designed to run in web browsers (though less common now).
java.sql: Here you will find the classes for interacting with databases and processing relational data. above the all to be discussed.

User-defined packages

User-defined packages in Java are not readily available, as their name suggests. These are created by developers to define interfaces and classes according to the application requirements. It is defined using a unique syntax as shown below:


package packageName;

You can see the package keyword in its syntax, it defines the package name. It is important to declare the package just before any import statements of a Java class. It is also important to ensure that all the classes are public so that you can access them from both inside and outside the package.

Java basic program

SILAMBARASAN A — Mon, 20 Apr 2026 03:02:38 +0000

this program helps me to understand Object, method, constructor.

class Dmart{ 

String product_name;
int product_price;
int product_discountpercentage;
int product_discountprice;
int finalprice;


public Dmart(String name ,int price ,int discountpercentage){

this.product_name=name;
this.product_price=price;
this.product_discountpercentage=discountpercentage;
}


public static void main(String[] args){

Dmart product1=new Dmart("shop" , 50 , 8);
Dmart product2=new Dmart("chips" , 30 , 5);
Dmart product3=new Dmart("Choclate" , 200 , 2);
Dmart product4=new Dmart("Biscut"  ,  15 , 7);
Dmart product5=new Dmart("HotChips" , 25 , 12);

product1.buy();
product2.buy();
product3.buy();
product4.buy();
product5.buy();

}
public void buy(){

this.product_discountprice = (this.product_price * this.product_discountpercentage) / 100;
this.finalprice=this.product_price-this.product_discountprice;

System.out.println("productname => "+ this.product_name);
System.out.println("proprice => " + this.product_price);
System.out.println("prodiscountpercentage => " + this.product_discountpercentage);
System.out.println("discountprice => " + this.product_discountprice);
System.out.println("finalprice => " + this.finalprice);

}

}

Pincode validate

SILAMBARASAN A — Sat, 18 Apr 2026 07:03:24 +0000

too be disscused

        const regions = {
    1: "Delhi",
    2: "Uttar Pradesh & Uttarakhand",
    3: "Rajasthan & Gujarat",
    4: "Maharashtra",
    5: "Andhra Pradesh & Telangana",
    6: "Tamil Nadu & Kerala",
    7: "West Bengal & North East",
    8: "Bihar & Jharkhand",
    9: "Army Postal Service"
};

const sub_regions = {
    11: "Delhi Region",
    40: "Mumbai Region",
    60: "Chennai Region",
    70: "Kolkata Region"
};

const districts = {
    110: "Delhi",       111: "Delhi (North)",      112: "Delhi (South)",
    400: "Mumbai",      401: "Mumbai (Suburban)",   402: "Mumbai (West)",
    600: "Chennai",     601: "Tiruvallur",          602: "Kanchipuram",
    700: "Kolkata",     701: "Kolkata (North)",     702: "Kolkata (South)"
};

function getPincodeDetails(pincode) {
    if (!/^\d{6}$/.test(pincode)) {
        console.log("Invalid pincode. Enter exactly 6 digits.");
        return;
    }

    const num        = Number(pincode);
    const firstDigit = Math.floor(num / 100000);
    const firstTwo   = Math.floor(num / 10000);
    const firstThree = Math.floor(num / 1000);

    console.log("Region:     ", regions[firstDigit]   || "Unknown");
    console.log("Sub-region: ", sub_regions[firstTwo] || "Unknown");
    console.log("District:   ", districts[firstThree] || "Unknown");
}

getPincodeDetails(prompt("enter the number"))

Gmail Validation

SILAMBARASAN A — Sat, 18 Apr 2026 06:58:29 +0000

how i validate the given gmail is valid or invalid.

Condition :
Gmail end should end like this "@gmail.com"
so, I first checked last 10 character from given gamil.

If condition is false return"gmail end should end like @gmail.com"

If condition is True, checks the next condition

next take the gmail copy except "@gmail.com"
the gmail copy is only have charactors and numbers and plus and dot.
the condition is true return "valid"
the condition is false return "special charector not allow"

def verify_Gmail(Gmail):
    if Gmail[-10:]=="@gmail.com":
        i=0
        gmailcopy=Gmail[0:len(Gmail)-10]
        while i<len(gmailcopy):
            current=gmailcopy[i]
            i+=1
            if current>="a" and current<="z":
                continue;
            elif current>="A" and current<="Z":
                continue;
            elif current>="0" and current<="9":
                continue;
            elif current=="." or current=="_":
                continue;
            else:
                return "special charector not allow"
        return "valid"
    else:
        return "gmail end like this @gmail.com "

print(verify_Gmail(input("Enter Your Gmail :")))

Constructors in Java

SILAMBARASAN A — Sat, 18 Apr 2026 03:05:54 +0000

constructor in java is a spacial method, that is called when object is created. Its main purpose is to initialize the object. It is used to set default or user-defined values for the object's attributes.

A constructor has the same name as the class.
It does not have a return type, not even void.
It can accept parameters to initialize object properties

Rules of Constructor

Constructor name must be the same as the class name.
Constructors do not have a return type (not even void).
If you add a return type, it becomes a method, not a constructor.
A constructor is called once per object creation (when using new).
If no constructor is defined, Java provides a default no-arg constructor.
If you define any constructor, the default is con't provided.

Default Constructor :

Java provides this automatically if you don’t define any constructor

public class Constructor{
int age=10;
public static void main(String[] args){
Constructor obj = new Constructor();
System.out.println(obj.age);
}
}

No-Argument Constructor

You write it yourself, no parameters.

public class Constructor{
int age=10;
public Constructor(){
System.out.println("no agru constructor");
}
public static void main(String[] args){
Constructor obj = new Constructor();
System.out.println(obj.age);
}
}

Parameterized Constructor

Used to pass values at object creation and set value for arttibutes.

public class Constructor{
int age;
public Constructor(int a){
age=a;
}
public static void main(String[] args){
Constructor obj = new Constructor(19);
System.out.println(obj.age);
}
}

Mobile Number Verify

SILAMBARASAN A — Fri, 17 Apr 2026 19:49:24 +0000

Now my code is 100% Right way to verify mobile number exactly.

I checked some condition to confirm given number is mobile number.

condition 1 :
given numbers must be only 0 to 9 or + or empty space .

above the condition is true, then only checks the next conditions.
otherwise return characters and characters spl are not allow.

i created one function the name of verify. that function checks given given argument is only have 0 To 9.

condition 2 :
my second condition is checks the length of the given numbers, the length should be 10, then only enter in condition 2. else goes the next condition3.

okay, let come's to the condition 2

condition 2 is checks, Given numbers in first number must be greater than or equal to 6 and less than or equal to 9 and calling the verify function and argument is given number.

above the both condition is true, return "Valid Mobile Number"
above the both condition is false, return "check the first digit and space and plush not allowed".

Condition 3 :
condition 3 also checks the length of the given numbers, the length is must be 13, then only enter in condition 3. else goes the next condition 4.

let come's to the condition 3

condition 3 is checks the given first three numbers is == "+91"

Above the condition is False, return "First three number should like +91"
above the condition is true, checks the next condition, next condition is checks the fourth digit is must be greater than or equal to 6 and less than or equal to 9 and calling the verify function and argument is given number except first three index.
- the both condition is true, return "Valid Mobile Number"
- the condition is false, return "check the fourth digit and plus and space not allow between the number"

condition 4 :
condition 4 is similar to condition 3, extra checks space.
condition 4 checks the length of the given numbers, the length is must be 14, then only enter in condition 4. else goes next .

condition 4,
checks the given first four ind is == "+91 "

Above the condition is False, return "First four number should like +91 "
above the condition is true, checks the next condition, next condition is checks the fifth number is must be greater than or equal to 6 and less than or equal to 9 and calling the verify function and argument is given number except first four index.
- the both condition is true, return "Valid Mobile Number"
- the condition is false, return "check the fifth digit and, plus and space not allowed

FINAL :
given number is can't enter in any condition 2,3,4.
return "given number is invalid"

the function is return a string, So function must be call in print.
**
**and this is my code :

def verify(mobnum):
    index=0
    while index<len(mobnum):
        if mobnum[index]>="0" and mobnum[index]<="9":
            index+=1
        else:
            return False
    return True



def mobile(n):
    i=0
    while i<len(n):
        if(n[i]>="0" and n[i]<="9") or (n[i]=="+") or (n[i]==" "):
            i+=1
        else:
            return "characters and special charactors not allowed"

    if len(n)==10:
        if n[0]>="6" and n[0]<="9" and verify(n):
            return "valid";
        else:
            return "incorrect"

    if len(n)==13:
        if n[0:3]=="+91":
            if n[3]>="6" and n[3]<="9" and verify(n[3:]):
                return "valid"
            else:
                return "incorrect"
        return "First three number should like +91"

    if len(n)==14:
        if n[0:4]=="+91 ":
            if n[4]>="6" and n[4]<="9" and verify(n[4:]):
                return "valid"
            else:
                return "incorrect"
        return "First four number should like +91 "
    return "Please Enter Your valid Mobile Number"      
print(mobile(input("Enter Your Mobile  Number : ")));

drop your ideas in comments