DEV Community: Deva I

String Scenario Questions

Deva I — Wed, 29 Jul 2026 06:15:13 +0000

Replace "spring Boot" instead of "Java" in the sentence

public class SpringBoot
{
public static void main(String[] args){
String str = "I love Java Programming";
String text = str.replace("Java","Spring Boot");
System.out.println(text);
}
}

Validate Mobile No(10 digits only)

public class MobileNo
{
public static void main(String[] args){
String mobile = "9360257399";

if(mobile.matches("\\d{10}")){
System.out.println("Valid mobile number");

}
else{
System.out.println("Invalid mobile number");

}
}
}

Split and store into array the given string

import java.util.Arrays;
public class Fruits

{
public static void main(String[] args){
String str = "apple#banana#mango";
String [] fruits = str.split("#");
System.out.println(Arrays.toString(fruits));
}
}

Interface in Java

Deva I — Tue, 21 Jul 2026 06:33:07 +0000

An interface in Java is a reference type that acts as a blueprint for a class by defining a strict contract of behaviors without specifying how they are implemented.

It is declared using the interface keyword.

It is primarily used to achieve total abstraction and multiple inheritance in Java.

Key Characteristics

Abstract methods: Interface methods by default they are abstract.

Constants: Any variables declared inside are implicitly public static final.

No Instantiation: You cannot create objects directly from an interface.

Keywords: A class uses implements to adopt an interface, while an interface uses extends to inherit another interface.

Code Example

interface DeliveryPartner
{
    void deliverOrder(String restaurant, String customer);
}

class SwiggyDelivery implements DeliveryPartner
{
    public void deliverOrder(String restaurant, String customer)
    {
        System.out.println("Swiggy is delivering food from " + restaurant);
        System.out.println("Customer: " + customer);
    }
}

class ZomatoDelivery implements DeliveryPartner
{
    public void deliverOrder(String restaurant, String customer)
    {
        System.out.println("Zomato is delivering food from " + restaurant);
        System.out.println("Customer: " + customer);
    }
}

public class FoodDeliveryApp
{
    public static void main(String[] args)
    {
        DeliveryPartner partner1 = new SwiggyDelivery();
        partner1.deliverOrder("A2B Restaurant", "Deva");

        System.out.println();

        DeliveryPartner partner2 = new ZomatoDelivery();
        partner2.deliverOrder("Domino's Pizza", "Rahul");
    }
}

Output

Abstraction in Java

Deva I — Thu, 16 Jul 2026 14:54:19 +0000

Abstraction in Java is the process of hiding internal implementation details and exposing only the essential functionality to the user.

Java provides two mechanisms to achieve abstraction:

Abstract Classes: Achieves partial abstraction (0% to 100%).
Interfaces: Achieves total abstraction (100%). (TO BE DISCUSSED)

Abstract Classes (Partial Abstraction)

An abstract class is a restricted class declared with the abstract keyword that cannot be instantiated directly.

It serves as a blueprint for subclasses and can contain a mix of both abstract methods (without bodies) and concrete methods (with bodies).

Key Rules

If a class contains at least one abstract method, the class itself must be declared abstract.

Subclasses must override all inherited abstract methods,otherwise its declared itself also abstract.

Code Example

Shopping Cart Example

public abstract class ShoppingCart 
{
public abstract void buyNow();

public void details(){
System.out.println("Type your delivery address and Contact information");
}

public void payment(){
System.out.println("Pay using via credit card, UPI or select cash on delivery");
}

public void confirm(){
System.out.println("Place the Order");
}
}

public class AmazonShopping extends ShoppingCart {


public static void main(String[] args){

 AmazonShopping buyProduct = new  AmazonShopping();
 buyProduct.buyNow();
 buyProduct.details();
 buyProduct.payment();
 buyProduct.confirm();
}
public void buyNow(){
System.out.println("Open Amazon app and click the football jersey");

}
}

Output

Encapsulation in Java

Deva I — Wed, 15 Jul 2026 15:43:42 +0000

Encapsulation in Java is the Object-Oriented Programming (OOP) principle of bundling variables (data) and methods (behavior) together into a single unit (a class) while restricting direct access to the internal state.

How to Achieve Encapsulation

✓ Declare class variables as private to hide them from direct outside manipulation.

✓ Provide public getter and setter methods to allow controlled read and write operations.

Key Rules:

Declare data as private: Hide the class data so it cannot be accessed directly from outside the class.

Use getters and setters: Keep variables private and provide public getter and setter methods for controlled access and safe modification.

Apply proper access modifiers: Use private for data hiding and
public for methods that provide access.

Example Code

public class ATM
{

private int money = 20000;

public int getMoney(){
return this.money;
}

public void setMoney(int money){
if(money <= 20000){
this.money = money;
System.out.println("Withdrawal Sucessfull.");
}
else{
 System.out.println("Withdrawal failed! Maximum withdrawal limit is ₹20,000 per transaction.");
}

}
}

public class User
{
public static void main(String[] args) {
ATM atm = new ATM();
System.out.println("Withdrawal limit per transaction: ₹" +atm.getMoney());

atm.setMoney(21000);
System.out.println("Your Withdrawal Money only 20000 or below 20000: ₹" +atm.getMoney());

}
}

Output

public class User
{
public static void main(String[] args) {
ATM atm = new ATM();
System.out.println("Withdrawal limit per transaction: ₹" +atm.getMoney());

atm.setMoney(15000);
System.out.println("Your Withdrawal Money is only 20000 or below 20000: ₹" +atm.getMoney());

}
}

Output

Method Overriding in Java

Deva I — Tue, 14 Jul 2026 17:24:36 +0000

Method overriding in Java allows a subclass to provide a specific implementation of a method that is already defined in its parent class.

It is the core mechanism behind runtime polymorphism, to decide at runtime which method version to execute based on the actual object type.

Core Rules

Same method name.
Same no of Arguments- Argument must be same as the parent class method.
Same return type- Must be same as the parent method's return type.
Access Modifiers- The child class's method cannot be more restrictive than the parent's method (e.g., if the parent method is public, the child method cannot be private or protected)
Inheritance- It can only be used on inherited methods.

Example Code

public class MSDhoni
{
public void giveCaptaincy(){
System.out.println("MSDhoni gives the Test Captaincy to Virat Kohli");

}
}

public class ViratKohli extends MSDhoni
{

public static void main(String[] args)
{
MSDhoni testcaptain = new MSDhoni();
testcaptain.giveCaptaincy();

ViratKohli testCaptain = new ViratKohli();
testCaptain.giveCaptaincy();
}

public void giveCaptaincy() {
        System.out.println("Virat Kohli is the Test captain and Want Whiteball captaincy too.");
}
}

Output

Inheritence in Java

Deva I — Tue, 14 Jul 2026 17:23:35 +0000

Inheritance in Java allows one class to acquire the properties (fields) and behaviors (methods) of another class.

Superclass(Parent/Base Class): The existing class.

Subclass (Child/Derived Class): The new class that inherits features from the superclass. It can reuse, modify, or add its own variables and methods.

extends Keyword: The Java keyword used to create a subclass.

Types of Inheritance

Single Inheritance : A subclass inherits from exactly one superclass.

EX: Class A → Class B

Multilevel Inheritance : A class inherits from a subclass, creating a chain of inheritance.

EX: Class A → Class B → Class C

Hierarchical Inheritance : Multiple subclasses inherit from the same single superclass.

EX: Class A → Class B & Class C

Example Code

// Superclass(Parent/Base Class)

package thanjavur;
public class RajaRajaChola
{
public void abdication(){
System.out.println("The king gives the throne to Prince");

}
}

// Subclass (Child/Derived Class)

package gangaikondaCholapuram;
import thanjavur.RajaRajaChola;
public class RajendraChola extends RajaRajaChola
{
public static void main(String[] args)
{
RajendraChola coronation = new RajendraChola();
coronation.abdication();

}
}

Output

Access Modifier. When to Use and When Not to Use for class, method, variable and constructors.

Deva I — Mon, 13 Jul 2026 14:31:29 +0000

Definition :

✓ Access modifiers in Java are keywords that set the visibility and accessibility of classes, constructors, methods, and variables.

The Four Access Modifiers

1.Private :

✓ The code is accessible only within the same class.

✓ It cannot be accessed by any outside class, even the same package.

2.Default (Package level access Modifier) :

✓ This not have any specify keyword,Java automatically applies the default access modifier.(No keyword)

✓ Components are accessible only within the same package.

✓ Cannot access the different package, even they have the child class.

3.Protected :

✓ Accessible within the same package and by subclasses.

✓ Also access the different package sub class(child class).

✓ Cannot access the different package non-sub class only.

4.Public :

✓ Components are accessible from anywhere in the program.

1. Access Modifiers for Classes

Only public and default can be used for top-level classes.

public- Accessed anywhere in the program.
default- Only inside the same package can use it.
protected and private cannot used in top level classes, they only used in nested classes.

2. Access Modifiers for Variables

Variables can use all four modifiers.

public- Accessed anywhere in the program.
protected- Accessed by same class, same package, different package child class. cannot access different package non-child class.
default- Accessible only within the same package.Different package can't access it even they have child class.
private- Only accessible within the same class.

3. Access Modifiers for Methods

Methods can support all four modifiers.

public- Accessed anywhere in the program.
protected- Accessed by same class, same package, different package child class. cannot access different package non-child class.
default- Accessible only within the same package.Different package can't access it even they have child class.
private- Only accessible within the same class.

4. Access Modifiers for Constructors

Constructors can also use all four modifiers.

public- When any class from any package should be able to create objects.
protected- Use when object creation should be limited to Same package, Subclasses in other packages.
default- Only classes in the same package can create objects.
private- Use when you don't want anyone outside the class to create objects directly.

Java Package and Import Example

Deva I — Thu, 09 Jul 2026 15:24:32 +0000

What is package

✓ A package in Java is a mechanism used to group related classes, interfaces and sub-packages together.

Key Benefits

Prevents Naming Conflicts: Two classes can have the same name if they live in different packages.
Easier Maintainability.
Better Access Control.

How to Create a Package

package chennai.south;
public class KoyambeduMarket
{
public static void main(String[] args)
{

}
public void buyVeg(){
System.out.println("Buy vegetables at low cost");
}
}

The class KoyambeduMarket created by package chennai and exist in sub package south.

├── KoyambeduMarket.java
└── chennai
└── south
└── KoyambeduMarket.class

package chennai.north;
public class KasimeduMarket
{
public static void main(String[] args){
}
public void buyFish(){
System.out.println("Buy fishes at low cost");
}
}

├── KasimeduMarket.java
└── chennai
├── north
│ └── KasimeduMarket.class
└── south
└── KoyambeduMarket.class

Import and how to call a method in differrent package

CODE EXAMPLE

package chennai.north;
import chennai.south.KoyambeduMarket;
public class Anna_Nagar
{
public static void main(String[] args){

KoyambeduMarket vegetables = new KoyambeduMarket();
vegetables.buyVeg();

KasimeduMarket fish = new KasimeduMarket();
fish.buyFish();
}
}

Java
├── Anna_Nagar.java
├── KoyambeduMarket.java
├── KasimeduMarket.java
└── chennai
├── north
│ ├── Anna_Nagar.class
│ └── KasimeduMarket.class
└── south
└── KoyambeduMarket.class

Working Flow of the code

STEP 1. Create Package :
package chennai.north;

STEP 2. Import statement :
import chennai.south.KoyambeduMarket;

✓ Because java dosen't know the KoyambeduMarket class its exist in sub-package south, its know the same sub-package classes only

Example its know the all classes existing in north,beacuse Anna_Nagar class existing innorth`.

✓ Java brings the KoyambeduMarket class from another package (chennai.south) into this file.

STEP 3. Create first object :
KoyambeduMarket vegetables = new KoyambeduMarket();

✓ Memory is allocated for a KoyambeduMarket object.

✓ Variable vegetables stores in the object.

STEP 4. Call the method :
vegetables.buyVeg();

✓ The buyVeg() method executes and prints the message
"Buy vegetables at low cost"

STEP 5. Create second object :
KasimeduMarket fish = new KasimeduMarket();

✓ A new KasimeduMarket object is created and variable fish stored in the object .

STEP 6. Call second method :
fish.buyFish();

✓ The buyFish() method executes and prints the message
"Buy fishes at low cost"

Output

Constructor Method and Constructor Overloading in Java

Deva I — Wed, 08 Jul 2026 15:45:55 +0000

Features of a Constructor

🔹 Automatically called when an object is created.

🔹 Has the same name as the class.(Instead of giving another name java consider it method and ask a return type)

🔹 Does not have a return type.

🔹 Used to initialize object specific values.

Types of Constructors

Default Constructor (Implicit)

🔹 If you do not write any constructor in your class, the Java compiler automatically inserts a blank, no-argument constructor during compilation.

🔹 This constructor keeps by Java virtual Machine.

2.No-Argument Constructor (Explicit)

🔹 A constructor written by the programmer with no parameters.

🔹 This constructor is created by user.

public MobilePhone(){
System.out.println("No arguments Constructor");
}

3.Parameterized Constructor

🔹 A constructor that accepts parameters to initialize objects with specific values.

public  MobilePhone(String name,int price,int battery){
this.name = name;
this.price = price;
this.battery = battery;
}

Constructor Overloading

🔹 Constructor overloading is the process of defining two or more constructors in the same class with different parameter lists.

🔹 The compiler decides which constructor to call, based on the number or type of arguments passed when creating an object.

public  MobilePhone(String name,int battery){
this.name = name;
this.battery = battery;
}

Code example

public class MobilePhone
{
String name;
int price;
int battery;

public MobilePhone(){
System.out.println("No arguments Constructor");
}

public  MobilePhone(String name,int price,int battery){
this.name = name;
this.price = price;
this.battery = battery;
}

public  MobilePhone(String name,int battery){
this.name = name;
this.battery = battery;
}

public static void main(String[] args)
{
   // No argument constructor
   MobilePhone brand = new MobilePhone();

   //Parameterized Constructor
   MobilePhone brand1 = new MobilePhone("Samsung s25 ultra",120000,5000);
   MobilePhone brand2 = new MobilePhone("Realmep4 power",28000,10000);

   //Constructor overloading(Two parameters)
   MobilePhone brand3 = new MobilePhone("Vivo t5x",7200);

   System.out.println("BrandName :" + brand1.name);
   System.out.println("Price :" + brand1.price);
   System.out.println("BrandName :" + brand2.name);
   System.out.println("Price :" + brand2.price);
   System.out.println("Battery :" + brand2.battery);
   System.out.println("BrandName :" + brand3.name);
   System.out.println("Battery :" + brand3.battery);
}
}

Output

Method Overloading in Java

Deva I — Tue, 07 Jul 2026 17:31:27 +0000

=> Method Overloading in Java allows a class to have same method name with different number of arguments or with type of arguments.

=> It is a core concept of oop used to achieve compile-time polymorphism.

=> Compile-time polymorphism means the Java compiler determines exactly which method to execute during compilation based on the method signature.

Code Example

public class Calculator
{
  public static void main(String[] args)
  {
  Calculator casio= new Calculator();
  casio.add(10,5);
  casio.add(1000);
  casio.add(3,3,3);
  casio.add(10.5f,9.5f);
  casio.add('a');
  }

   public void add(int i){
  System.out.println(i+500);

  }

  public void add(int i, int j){
  System.out.println(i+j);

  }

  public void add(int i, int j, int k){
  System.out.println(i*j*k);

  }

  public void add( float i, float j){
  System.out.println(i+j);

  }
}

3 Ways to Overload a Method

Number of parameters.
Data types of parameters.
Order of parameters.

Number of parameters: Having a different count of inputs.

 casio.add(10,5);
 casio.add(1000);
 casio.add(3,3,3);

// One integer and add 500

 public void add(int i){
  System.out.println(i+500);

  }


  // Add two integer, two different parameters

  public void add(int i, int j){
  System.out.println(i+j);

  }

  // Add three integers, three different parameters in one method 'add'

  public void add(int i, int j, int k){
  System.out.println(i*j*k);

  }

Data types of parameters: Having the same count but different variable types((e.g., int vs float)

casio.add(10.5f,9.5f);

public void add( float i, float j){
  System.out.println(i+j);

  }

widening conversion

 casio.add('a');

   public void add(int i){
  System.out.println(i+500);

  }

=> A char can be automatically type converted to an int.

=> The character 'a' has the Unicode/ASCII value = 97.

=> (i+500).i is 97+500 = 597.

Output

Java Program to Demonstrate Objects, Static and Non-static Variables and this Keyword

Deva I — Mon, 06 Jul 2026 18:09:10 +0000

◾ In the previous blog our problem is the Building class is to store 3 different students information in a single object.

◾ So, using the below method to overcome this problem.

CODE :

public class SuperMarket
{
static String Shopname = "Food India";
String name;
int price;
public static void main(String[] args)
{
SuperMarket product1= new SuperMarket();
product1.name = "Rice";
product1.price = 1500;

SuperMarket product2= new SuperMarket();
product2.name = "Eggs";
product2.price = 100;

SuperMarket product3= new SuperMarket();
product3.name = "Ice cream";
product3.price = 150;
product1.buy();
product2.buy();
product3.buy();

}
public void buy(){
System.out.println("Shop Name : " + Shopname);
System.out.println("Product   : " + this.name);
System.out.println("Price : " + price);

}
}

WORKING :

◾First create a class and I give the class name SuperMarket.

◾Then create static Variable, we need only one copy of this variable and all objects share the same Shopname Food India.

🔹Because all products are belongs to the same shop name.but the products have different names, So, use non-static variables for products names.

If all objects should share the same value => use a static variable.
If each object should have its own value => use an non-static variable.

🔹Every object should have its own values. so, create non-static variables like,

String name;
int price;

🔹This tells every SuperMarket object have a name and a price.

🔹Then, when we create objects, java automatically allocates space for each objects.

◾Next create a objects what count you want.I create 3 objects product1,product2 and product3.Example in the above program I take product1 object.

SuperMarket product1= new SuperMarket();

🔹The non-static variable allocate the space for each objects you create.

◾Then you assign your values,

product1.name = "Rice";
product1.price = 1500;

◾The same process happens for product2 and product3

◾Then define the method to call the objects.

public void buy(){

}

In javascript we use the function for event or actions,to define function give function keyword.
In java give a method name diretly buy().
In java we give return method, its not compulsary in javascript to give a return method.
But, in java must give void, if you not return anything.

◾Then call the buy() method on inside the main block.if you call the method on the anywhere of program without main method, java dosen,t know that.

🔹Because, JVM only runs on main method.

🔹If you give buy()inside the main, while call the buy() method when main method called.

You call the any methods on main method.
But, you won't define or create methods inside the main method or any method you create.

◾Then print the products name and price use this

this refers to current object.

 System.out.println(this.name);

◾In this program price works without this.

System.out.println(price);

🔹Java automatically assumes the above line like System.out.println(this.price);

Using this is optional because this working on implicit from backround.
In non-static method this works on internally without giving it.
But in static not using this keyword because, this keyword refers to object.
Using class name for static methods.

System.out.println("Shop Name : " + Shopname);

🔹In this line Shopname is a static variable. but there is only one copy of Shopname, and it belongs to the class, not to any object.

🔹I give that line inside the buy() method.

public void buy() {
    System.out.println("Shop Name : " + Shopname);
}

◾Java looks for Shopname and finds it in the class.

🔹When the buy() method is called it prints the Shopname.

🔹In every time prints the Shopname name when the each buy() method calls, in this code buy() method called by 3 times. so, it prints Shopname 3 times.

If you give this.Shopname java give a error message.because thisrefers to the current object.

OUTPUT :

Static Variable vs Non-Static Variable(Instance Variable)

Deva I — Fri, 03 Jul 2026 06:58:26 +0000

Static Variable

Static refers to class specific information.
Declared using the static keyword.
It belongs to the Class.
Only one copy exists, shared by all objects.
Memory is allocated once when the class is loaded.
Accessed directly via the Class Name (ClassName.variable).
EX : The company name on an employee badge same for everyone.

Non-Static Variable(Instance Variable).

Non-Static refers to object specific information.
Declared without the static keyword.
Every object gets its own unique copy.
Memory is allocated every time a new object is created.
Requires an Object Reference (objectName.variable).
EX : The employee's specific name or ID number.

Example program

public class Building
{
static int age= 10;
static String name="Payilagam";


String studName1="mohan";
int studAge1= 22;

String studName2="deva";
int studAge2= 23;

String studName3="madhavan";
int studAge3= 24;

public static void main(String[] args)
{
Building student1= new Building();
Building student2= new Building();
Building student3= new Building();


System.out.println(Building.name);
System.out.println(Building.age);

System.out.println(student1.studName1 +" "+student1.studAge1);
System.out.println(student1.studName2 +" "+student1.studAge2);
System.out.println(student1.studName3+" "+student1.studAge3);


}
}

=> In this program static variable using class name.because the static variable accessed by class name Building. `System.out.println(Building.name);

=> A static method cannot directly access non-static variables because those variables belong to objects.

=> If you give non-static variable using class name java give error like,
non-static variable studName2 cannot be referenced from a static context.

=> So, first create a object using new keyword like,
Building student1= new Building();

=> Then access the variable through that object.
System.out.println(student1.studName2);

=> student is the the object.
studName2 that object's value.

=> I created the three students information but, each object still contains all three students' information.

System.out.println(student1.studName1 +" "+student1.studAge1); System.out.println(student1.studName2 +" "+student1.studAge2); System.out.println(student1.studName3+" "+student1.studAge3);

=> I use the same object name student1 to print all students information.because the student1,student2, and student3each object have all three students information.

=> Logically one object own one student information, not multiple students.

=> To overcome this problem using Constructor method.(TO BE DISCUSSED).