Forem: PRIYA K

How to Create a Supermarket Billing System in Java Using OOPS Concepts

PRIYA K — Tue, 21 Apr 2026 13:46:34 +0000

public class Supermarket {

    String name;
    double mrp;
    boolean discountApplied;
    double discountPercent;

    // Default Constructor
    Supermarket() {
        name = "Unknown";
        mrp = 0.0;
        discountApplied = false;
        discountPercent = 0;
    }

    // Constructor Overloading (without discount)
    Supermarket(String name, double mrp) {
        this.name = name;
        this.mrp = mrp;
        this.discountApplied = false;
        this.discountPercent = 0;
    }

    // Constructor Overloading (with discount)
    Supermarket(String name, double mrp, boolean discountApplied, double discountPercent) {
        this.name = name;
        this.mrp = mrp;
        this.discountApplied = discountApplied;
        this.discountPercent = discountPercent;
    }

    // Method: Billing (no parameters)
    void Billing() {

        double finalPrice = mrp;

        System.out.println("Item Name: " + name);
        System.out.println("MRP Price: ₹" + mrp);
        System.out.println("Discount Applied: " + discountApplied);

        if (discountApplied) {
            double discountAmount = (mrp * discountPercent) / 100;
            finalPrice = mrp - discountAmount;
            System.out.println("Discount Percentage: " + discountPercent + "%");
        } else {
            System.out.println("Discount Percentage: 0%");
        }

        System.out.println("Final Price: ₹" + finalPrice);
        System.out.println("-----------------------------");
    }

    // Method Overloading (optional usage)
    void Billing(boolean discountApplied, double discountPercent) {
        this.discountApplied = discountApplied;
        this.discountPercent = discountPercent;
        Billing(); // reuse main method
    }

    // Main Method
    public static void main(String[] args) {

        // Object without discount
        Supermarket item1 = new Supermarket("Rice", 100);
        item1.Billing();

        // Object with discount
        Supermarket item2 = new Supermarket("Oil", 200, true, 10);
        item2.Billing();

        // Another example
        Supermarket item3 = new Supermarket("Sugar", 50, false, 0);
        item3.Billing();
    }
}

Output

Constructor in Java

PRIYA K — Sat, 18 Apr 2026 04:33:27 +0000

A special method used to initialise objects.
Constructor is a block of code similar to method
Constructor is called when an object of a class is created

All Classes have constructors by 'default'
Java (JDK) creates a Class Constructor ,you need not to create a Class constructor
Accept parameters to initialise Object properties
It is used to set default or user-defined values for the object's attributes
Initialise objects at the time of object creation.

Constructor Syntax

class ClassName {
    // Constructor
    ClassName() {
        // Initialization code
    }

    // Parameterized Constructor
    ClassName(dataType parameter1, dataType parameter2) {
        // Initialization code using parameters
    }

    // Copy Constructor
    ClassName(ClassName obj) {
        // Initialization code to copy attributes
    }
}

Example

class Bike{
    Bike(){
        System.out.println("Bike is created");
    }
    public static void main(String[]args){
        Bike b = new Bike();

    }

}

Output

Rules For Creating Constructor
1.Name Rule
Constructor name must match the Class name
2.Return Type Rule
It cannot have a return type (like void) or explicit return type
if you add a return type,it will become a method not a return type
3.Execution Rule
A constructor is called as per the object creation(New)
4.Default Constructor Rule
No constructor is defined, Java provides a default no-arg constructor.
you can define any constructor, the default is not automatically provided.
5.Access Modifiers Rule
A constructor have modifiers like Private,Public,Protected or default
Private Constructore have used in singleton Design Pattern
to be discussed...
6.Restrictions Rule
A constructor cannot be

static(Belong to Class,not Objects) because Constructor is called using Objects.static is called by class
final(Not Inherited)
abstract(must have a body)
and synchronised to be discussed...

7.Inheritance Rule
Constructor not inherited by SubClass
Call a Parent Constructor using Super()

8.this() and super() Rule
A constructor can call another constructor in the same class using this().
A constructor can call a parent’s constructor using super().
In Java ≤ 24 → must be the first statement.
In Java 25 → can appear anywhere in the constructor.

Types Of Constructor

Default Constructor
Parameterised Constructor
No-argument Constructor

Default Constructor (Implicit)
A constructor doesnot have any parameter
Doesnot defined any constructor
A constructor that is automatically provided by Java if no constructor is written in the class.
It initializes object with default values (0, null, false).

Example
It is called when the object of the class is created

class Bike {
    int id;
    String name;

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b = new Bike();   // calls default constructor
        b.display();
    }
}

Output

Purpose Of Default Constructor
Provide Default values to the object like 0,null.depending on their data type.

No-Argument Constructor(User-defined)
user-defined empty constructor
A constructor that is manually written by the programmer with no parameters.
It is used to initialize objects with custom default values.

class Bike {
    int id;
    String name;

    // No-argument constructor
    Bike() {
        id = 101;
        name = "Duke";
    }

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b = new Bike();
        b.display();
    }
}

Output

Parameterised Constructor(Explicit)
A constructor have a any number of parameter
Used to provide different value for objects
Accepts arguments to initialize an object with specific values.
It allows passing values while creating the object.

class Bike {
    int id;
    String name;

    // Constructor only initializes values
    Bike(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Method to display bike details
    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b = new Bike(111, "Duke");
        Bike p = new Bike(122, "Splender");

        b.display();
        p.display();
    }
}

Output

Constructor OverLoading
Allows to create multiple constructors in the same class with different parameter and different data type
It can be overloaded like Java Methods
You can define all type of Constructors like no-argument and parameterised constructor.

Example

class Bike {
    int id;
    String name;

    // 1. Constructor with no parameters
    Bike() {
        id = 0;
        name = "Null";
    }

    // 2. Constructor with one parameter
    Bike(int id) {
        this.id = id;
        this.name = "Default Bike";
    }

    // 3. Constructor with two parameters
    Bike(int id, String name) {
        this.id = id;
        this.name = name;
    }

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b1 = new Bike();              // calls 1st constructor
        Bike b2 = new Bike(111);           // calls 2nd constructor
        Bike b3 = new Bike(122, "Duke");   // calls 3rd constructor

        b1.display();
        b2.display();
        b3.display();
    }
}

Output

What is this() in java 25 Upadte
It is used to call another Constructor with the same class(Constructor Chaining)
The restriction this() and super() used as first statement in constructor is removed.
Place them anywhere inside a constructor
this() and super()=>they enable clean and flexible initialization.

Copy Constructor
A constructor that creates a new object by copying values from an existing object of the same class.
It is used to duplicate objects.

class Bike {
    int id;
    String name;

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

    // Copy constructor
    Bike(Bike b) {
        this.id = b.id;
        this.name = b.name;
    }

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b1 = new Bike(111, "Duke");

        Bike b2 = new Bike(b1);  // copy constructor

        b1.display();
        b2.display();
    }
}

Output

Do You Know?
1.this Keyword (Avoid confusion)
Used when class variable and parameter have same name
this refers to current class constructor
this refers to current object
this() calls another constructor in the same class .This technique is called Constructor Chaining

Example:

class Bike {
    int id;
    String name;

    Bike(int id, String name) {
        this.id = id;      // class variable = parameter
        this.name = name;
    }
}

Explanation
this.id → object’s variable
id → constructor parameter

Without this, Java gets confused

2.Constructor Chaining (this())

One constructor calling another constructor
Simple idea:
“Reuse constructor instead of writing same code again”

Example:

class Bike {
    int id;
    String name;

    Bike() {
        this(0, "Unknown");  // calls another constructor
    }

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

Bike() → calls Bike(int, String)
Saves duplicate code

3.Immutable Object (Fixed data)

Once object is created, you cannot change its values
Means
“Lock the object after creation "

Example:

class Student {
    private final String name;
    private final int age;

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

    public String getName() {
        return name;
    }
}

final → cannot change value
No setter methods → data is fixed

4. Exception Handling in Constructor
Handle errors while creating object
stop invalid object creation

Means
“If object is wrong, stop it immediately”

Example:

class Student {
    int age;
    Student(int age) {
        if (age < 0) {
            throw new Illegal ArgumentException("Age cannot be negative");
        }
        this.age = age;
    }
}

If invalid data comes → constructor blocks it
Object is created only if data is correct

Installation vs Deployment

PRIYA K — Mon, 13 Apr 2026 02:43:21 +0000

What is Installation?

Installation means setting up software on a system so that it can run.
It is the process where required files, dependencies, and configurations are placed on a device (like your laptop or server).

Example:
When you install:
Node.js
Python
React app using npm install
You are preparing your environment to run the application.

Points to Remember
Happens on a local system or server
Focus is on setup
Includes dependencies, libraries, and configurations
Done by developers or users

What is Deployment?
Deployment means making your application available for users to access.
It is the process of moving your application from your local system to a live server or production environment.

Example:
Uploading your React app to Netlify
Hosting a website on AWS
Publishing an app so users can access it online

Points to Remember
Happens on a production server
Focus is on making the app live
Includes hosting, domain, and server configuration
Done by developers or DevOps teams

Simple Flow
Install → Setup environment
Develop → Build your application
Deploy → Make it live for users

Real-Life Analogy
Think of it like cooking:
Installation = Buying ingredients & setting up kitchen
Deployment = Serving the food to customers

Installation and deployment are both important steps in software development:
Without installation, your app won’t run
Without deployment, users can’t access it
Understanding this difference helps you work better in development and production environments.

Selenium Basics

PRIYA K — Mon, 13 Apr 2026 02:42:25 +0000

Testing web applications manually can be time-consuming and error-prone.

What is Selenium?
Selenium is an open-source tool used for automating web browsers.
It allows developers and testers to write scripts that simulate real user actions like:
Clicking buttons
Entering text
Navigating pages

Why Selenium is Used?
Selenium is mainly used for testing web applications automatically.

Key Reasons:
Reduces manual testing effort
Saves time
Improves accuracy
Supports multiple browsers

Components of Selenium
Selenium is not just one tool—it has multiple components:

Selenium WebDriver Most important part Directly interacts with browser Supports languages like Java, Python, JavaScript
Selenium IDE Browser extension (Chrome/Firefox) Record and playback tool Beginner-friendly
Selenium Grid Used for running tests on multiple machines Supports parallel testing

How Selenium Works?
Selenium works by controlling the browser using code.

Write test script
WebDriver sends commands
Browser executes actions
Result is returned

Supported Browsers
Selenium works with:
Chrome
Firefox
Edge
Safari

Advantages of Selenium
Open-source (free)
Supports multiple languages
Cross-browser testing
Large community support

Limitations of Selenium
Only for web applications (not desktop apps)
Requires programming knowledge
No built-in reporting

Real-Time Use Case
Imagine you built a login page. Instead of testing it manually every time:
Selenium can:
Enter username/password
Click login
Verify success message
Automatically

Simple Analogy
Think of Selenium like a robot user
It behaves exactly like a human using a browser—but faster and without mistakes.

Selenium is a powerful tool for automating web testing. Learning its basics is a great step for anyone interested in software testing, QA, or automation engineering.

Self-Introduction

PRIYA K — Thu, 09 Apr 2026 21:53:56 +0000

This is Priya, and I’m from Chennai.

I have completed my Bachelor of Technology in Artificial Intelligence and Data Science from Rajalakshmi Institute of Technology .

Coming to my technical skills, I have a strong foundation in HTML, CSS, and JavaScript, and I also have practical knowledge of React.js for building responsive and user-friendly web applications. I am also familiar with tools like Git, GitLab, and VS Code.

I completed an internship as a Data Science Intern at Unified Mentor, where I worked on data cleaning, exploratory data analysis, and data visualization using Python. I also developed recommendation systems and machine learning models for classification tasks.

For my projects, I developed an Interactive Quiz Web Application using React.js. In this project, I used React Hooks like UseState, UseEffect, and UseContext, and implemented React Router for smooth navigation. This helped me strengthen my Front-end development skills.

I also worked on a major project titled Skin Disease Classification using deep learning. I used CNN models like Alex Net and U-Net and achieved around 91.95% accuracy. I also developed a Django-based web application for real-time disease detection and treatment suggestions.

Additionally, I presented this project in a conference, which helped me improve my communication and presentation skills.

I am a quick learner, passionate about web development and AI, and always interested in learning new technologies. I am looking for an opportunity where I can improve my skills, gain real-time experience, and contribute to the organization.

Method in java

PRIYA K — Thu, 09 Apr 2026 05:11:04 +0000

Void Method(with return type)
example

public class Display{
    public static void main(String[]args){
        Display casio = new Display();
        casio.add();
    }
    public void add(){
        return;
    }
}

Flow of execution
main()
│
│ create object
▼
Display casio = new Display()
│
│ method call
▼
casio.add()
│
▼
add() method executes
│
▼
return;
│
▼
control returns to main()
│
▼
program ends

Marks Calculation

Example

public class Marks{

    public static void main(String[] args){
        int total = sumMarks(100,98,78,95,91);
        int avg = average(total);
        grade(avg);
    }

    public static int sumMarks(int m1,int m2,int m3,int m4,int m5){
        int total = m1 + m2 + m3 + m4 + m5;
        return total;
    }

    public static int average(int total){
        int avg = total/5;
        return avg;
    }

    public static void grade(int avg){
        if(avg>=90){
            System.out.println("A");
         }
        else if(avg>=80){
            System.out.println("B");
         }
        else if(avg>=70){
            System.out.println("C");
         }
        else if(avg>=60){
            System.out.println("D");
         }
        else if(avg>=50){
            System.out.println("E");
         }
        else{
            System.out.println("Fail");
        }
    }
}

Flow of Execution

Program starts in main()
sumMarks() is called
Total marks calculated → 462
average() is called
Average calculated → 92
grade() is called
Condition checked → 92 ≥ 90
Grade printed → A

Constructor in JavaScript

PRIYA K — Thu, 09 Apr 2026 05:10:32 +0000

A constructor function is a special function used to create many objects with the same structure.
Curly braces represent an object.
Create many Objects easily.
Each Key-value pair is called Property
Instead of writing many objects manually, we create a blueprint
name constructor functions with an upper-case first letter.

constructor()
Special method inside a class
Runs automatically when object is created

function Person(name, age) {

Explanation
function Person(name, age)

function → keyword to define a function
Person → constructor name
name, age → parameters

Understanding this
this.name = name;
this=>refers to the current object being created

this.name=>creates a property called name inside the object

= name(assigns the value received from the parameter)

Example :

{
   name : "Priya"
}

this.age = age;
creates an age property
stores the value passed to the constructor

object becomes:

{
name : "Priya",
age : 21
}

Steps:

Creates an empty object { }
Sets this to point to that object
Calls the constructor function
Assigns values (name, age)
Returns the object

Instantiating an object constructor
There are two ways to instantiate object constructor,

const object_name = new Object(); 
const object_name = { };

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
}

// Create a Person object
const myFather = new Person("John", "Doe", 50, "blue");
const myMother = new Person("Saraswathi","g",42,"black")
console.log(myFather.age)

Explanation
In constructor function,'this' has no value
this value = new object value

Property Default Value

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
  this.nationality = "English";
}

// Create 2 Person objects
const myFather = new Person("John", "Doe", 50, "blue");
const myMother = new Person("Sally", "Rally", 48, "green");
console.log(myMother.nationality)

Adding Property to an Object

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
}

// Create 2 Person objects
const myFather = new Person("John", "Doe", 50, "blue");
const myMother = new Person("Sally", "Rally", 48, "green");

// Add nationality to first object
myFather.nationality = "English";
console.log(myFather.nationality)

Adding Property to Constructor

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
}

// Create 2 Person Objects
const myFather = new Person("John", "Doe", 50, "blue");
const myMother = new Person("Sally", "Rally", 48, "green");

// Will Not Work
Person.nationality = "English";
console.log(Person.nationality)

Add a new property add it to constructor function prototype

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
}

// Create 2 Person Objects
const myFather = new Person("John", "Doe", 50, "blue");
const myMother = new Person("Sally", "Rally", 48, "green");

// Add a new Property
Person.prototype.nationality = "English";
console.log(myFather.nationality)

Explanation
Person.nationality =>Property belongs to constructor only.
Person.prototype.nationality => Property shared by all objects.

Constructor Function Methods
can have methods

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
  this.fullName = function() {
    return this.firstName + " " + this.lastName
  };
}

// Create a Person object
const myFather = new Person("John", "Doe", 50, "blue");
console.log(myFather.fullName())

Adding method to an object

function Person(first, last, age, eye) {
  this.firstName = first;
  this.lastName = last;
  this.age = age;
  this.eyeColor = eye;
}

// Create 2 Person objects
const myFather = new Person("John", "Doe", 50, "blue");
const myMother = new Person("Sally", "Rally", 48, "green");

// Add a Name Method
myMother.changeName = function (name) {
  this.lastName = name;
}

// Change Name
myMother.changeName("Doe");
console.log(myMother.lastName)

Output
Doe

Calling the Method

p1.sayHello();

Output:
My name is Priya and I am 21 years old.

Adding a Method to a Constructor
Adding a new method to a constructor must be done to the constructor function prototype:

function Person(firstName,lastName,age,eyeColor) {
  this.firstName = firstName;
  this.lastName = lastName;
  this.age = age;
  this.eyeColor = eyeColor;
}

// Create a Person Object
const myMother = new Person("Sally","Rally",48,"green");

Person.prototype.changeName = function (name) {
  this.lastName = name;
}

// Change Name
myMother.changeName("Doe");
console.log(myMother.lastName)

Built-in JavaScript Constructors

JavaScript has built-in constructors for all objects:
new Object() // A new Object object
new Array() // A new Array object
new Map() // A new Map object
new Set() // A new Set object
new Date() // A new Date object
new RegExp() // A new RegExp object
new Function() // A new Function object

Example

 "";           // primitive string
0;            // primitive number
false;        // primitive boolean

{};           // object object
[];           // array object
/()/          // regexp object
function(){}; // function

Need to Rememeber

The Math() object is not in the list. Math is a global object. The new keyword cannot be used on Math.
Use object literals {} instead of new Object().
Use array literals [] instead of new Array().
Use pattern literals /()/ instead of new RegExp().
Use function expressions () {} instead of new Function().

** Simple Real-Life Example**

Constructor = factory machine
Person constructor
|
|---- Person1
|---- Person2
|---- Person3
Each object has same structure but different values.

Why Constructors are Useful
Without constructor:

object1
object2
object3

You must write many objects manually.

With constructor:
Person() → blueprint
|
|---- p1
|---- p2
|---- p3
You can easily create many objects.

Constructor Using Class (Modern Way)

class Student {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}

let student = new Student("Priya", 22);
console.log(Student);

Constructor Function (Old Way)
Before ES6, constructors were written like this:

function Student(name, age) { 
    this.name = name; 
    this.age = age; 
} 

let student = new Student("Priya", 22);

This still works, but modern JS prefers class syntax.

Concept Meaning
Object Collection of properties
Constructor Blueprint to create objects
this Refers to current object
new Creates a new object
Method Function inside object

Method OverLoading

PRIYA K — Thu, 09 Apr 2026 05:10:15 +0000

1. What is Method Overloading?
Method Overloading is a feature in Java

where multiple methods have the same method name and same number of parameters,arguments but different parameters , different data type in the same class.
It is the one of the Polymorphism called the Compile-Time Polymorphism
The methods differ by:
Number of parameters
Type of parameters
Order of parameters

Example

public class Sample{
    public static void main(String[]args){
        Sample casio = new Sample();
        casio.add(10,20);
        casio.add(10,20,30);
        casio.add();
    }
    public void add(int no1,int no2){
        System.out.println("2 arguments");
    }
    public void add(){
        System.out.println("0 arguments method");
    }
    public void add(int no1,int no2,int no3){
        System.out.println("3 arguments");
    }
}

Output

2.Rules of Method Overloading

Not Change the Number of Parameters

class SumExample {

    int sum(int a, int b) {
        return a + b;
    }

    int sum(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        SumExample obj = new SumExample();

        System.out.println(obj.sum(10, 20));
        System.out.println(obj.sum(10, 20, 30));
    }
}

Output

Not Change the Data Type of Parameters

class PrintExample {

    void print(int a) {
        System.out.println("Integer: " + a);
    }

    void print(String a) {
        System.out.println("String: " + a);
    }

    public static void main(String[] args) {
        PrintExample obj = new PrintExample();

        obj.print(100);
        obj.print("Java");
    }
}

Output

Not Change the Order of Parameters

class ShowExample {

    void show(int a, String b) {
        System.out.println(a + " " + b);
    }

    void show(String b, int a) {
        System.out.println(b + " " + a);
    }

    public static void main(String[] args) {
        ShowExample obj = new ShowExample();

        obj.show(10, "Java");
        obj.show("Hello", 20);
    }
}

Output

Changing only the return type is NOT allowed in Java.
Example

class Calculator {

    int multiply(int a, int b){
        return a * b;
    }

    int multiply(int a, int b, int c){
        return a * b * c;
    }

    double multiply(double a, double b){
        return a * b;
    }

    public static void main(String[] args){

        Calculator obj = new Calculator();

        System.out.println(obj.multiply(5, 4));
        System.out.println(obj.multiply(2, 3, 4));
        System.out.println(obj.multiply(2.5, 4.0));
    }
}

Output

3. Step-by-Step Execution
Program starts from the main() method
Object of the class is created
Method is called using the object
Java compares the arguments with method parameters
The correct overloaded method runs
Output is displayed

4.Advantage Of Method OverLoading
Keep code clean and readable
Use the same method name for similar operations
Avoid creating many method names
Make programs easier to maintain

5. Simple Real-Life Idea
Think of a mobile phone camera:

Same button → Camera
Different modes:
Photo
Video
Portrait

Same name, different behavior depending on input.

String Programs

PRIYA K — Wed, 08 Apr 2026 09:13:25 +0000

A String is a collection of characters stored together to represent text in a program.

These characters can be letters, numbers, symbols, or spaces.
String is immutable

Example:

"Priya"
"Hello World"
"12345"
"Java@2026"

All of these are strings because they store text inside quotes.
Accessing the First Character of a String
Python

name = "priya"
print(name[0])

In JavaScript

const name = "priya"

console.log(name[0])

Accessing the middle Character of a String
Python

name = "priya"

# Find the middle index
middle_index = len(name) // 2

# Print the middle character
print(name[middle_index])

JavaScript

const name = "priya";

// Find the middle index
const middleIndex = Math.floor(name.length / 2);

// Print the middle character
console.log(name[middleIndex]);

Accessing the last Character of a String
Python

name = "priya"
print(name[-1])

JavaScript

const name = "priya";

// Get the last character
console.log(name[name.length - 1]);  // Output: "a"

capitalize the first letter of a string
In Python

name = "priya"

# Capitalize only the first letter
result = name[0].upper() + name[1:]

print(result)

In JavaScript

let name = "priya";

// Capitalize only the first letter
let result = name[0].toUpperCase() + name.slice(1);

console.log(result);

Java

Changing Case of Specific Characters in a String
In Python

name = "priya"
length = len(name)

result = (
    name[0].upper() +                       # First character uppercase
    name[1:length // 2] +                    # Characters from 1 to middle-1 unchanged
    name[length // 2].upper() +              # Middle character uppercase
    name[length // 2 + 1:length - 1] +       # Characters after middle to second last unchanged
    name[length - 1].upper()                 # Last character uppercase
)

print(result)

In JavaScript

let name = "priya";
let len = name.length;

let result =
    name[0].toUpperCase() +
    name.substring(1, Math.floor(len / 2)) +
    name[Math.floor(len / 2)].toUpperCase() +
    name.substring(Math.floor(len / 2) + 1, len - 1) +
    name[len - 1].toUpperCase();

console.log(result);

Java

public class ChangeCase {
    public static void main(String[] args) {
        String name = "priya";
        int len = name.length();
        int mid = len / 2;

        // Build the new string
        String result = 
            name.substring(0, 1).toUpperCase() +          // First character uppercase
            name.substring(1, mid) +                      // Characters from 1 to middle-1 unchanged
            name.substring(mid, mid + 1).toUpperCase() + // Middle character uppercase
            name.substring(mid + 1, len - 1) +           // Characters after middle to second last unchanged
            name.substring(len - 1).toUpperCase();       // Last character uppercase

        System.out.println(result);
    }
}

ASCII

PRIYA K — Wed, 08 Apr 2026 09:11:36 +0000

ASCII Letters – Why They Are Used in English and Other Languages

In the world of computers, everything works with numbers. Computers understand only 0's and 1's.Computers do not understand letters like A, B, C or symbols directly. Instead, they use a special system called ASCII to represent characters.

What is ASCII?

ASCII stands for American Standard Code for Information Interchange.
It is a character encoding system that assigns a numeric value to each letter, number, and symbol so that computers can understand and process text.

How Computer Understands it
Step 1: ASCII given number
'A'-> 65
'B'-> 66

Step 2: Computer converts number to Binary
65-> 1000001
66-> 1000010

So when you type A on the keyboard, the computer actually stores the number 65 internally.

ASCII Range
Total Characters = 128
Range Description
0–31 Control characters(not Printable =we cannot use them)
0 for 'Null',8 for 'Backspace',9 for 'Tab',10 for 'New Line'
32 for 'space'
33–47 Symbols(!,&,%)
48–57 Numbers
58-64(:,;,<,>,=,?,@)
65–90 Uppercase letters
91-96 More Symbols([],^,-,')
97–122 Lowercase letters
123-126 More Symbols({'} ~)
127 Delete(Non Printable)

Why Other Languages Need More Than ASCII
Languages like:
Tamil
Hindi
Chinese
Japanese
Arabic
have many more characters than English.
Since ASCII supports only 128 characters, it cannot represent these languages properly.
To solve this problem, a new system called Unicode was introduced.

Unicode – The Modern Solution
UTF-8(Unicode Transformation Format 8-Bit)
Unicode is a universal character encoding system that supports almost all languages in the world.
~1.1 Million Characters
UTF-8 is a way computers understand and store text.
UTF-8 does not convert Binary later
It already gives Binary values directly.

Steps
Every Character has a Unicode code Point
Example
A-> ut0041
e->ut20AL
UTF-8 converts that Unicode number into a binary format(bytes)
These UTF-8 bytes are already in 0's and 1's ,so the computer stores them directly

7-Bit(7 Binary Digit)
A->65-1000001
B->66-1000010

2^7 = 128 Combinations(0-127)
1 Byte = 8Bits(01000001)
2 Bytes = 16 bits
3 Bytes = 24 bits
4 Bytes = 32 bits

UTF-8 is a modern encoding system that includes ASCII and supports many more characters from all languages.

Examples:
Character Unicode
A U+0041
தமிழ் Supported
हिंदी Supported
中文 Supported

Unicode can represent over 143,000 characters from different languages.

Where ASCII Is Still Used
Even today, ASCII is widely used in:
Programming languages
Text files
Network communication
Data encoding
File formats
Many modern systems like UTF-8 are actually based on ASCII compatibility.

Why ASCII Was Created
In the early days of computing, different computers used different systems to represent text. This created communication problems between machines.

ASCII was created to:
Standardize text representation
Allow computers to exchange information easily
Make programming and data processing simpler

Why ASCII Is Mainly Based on English
ASCII was developed in the United States, so it mainly supports:

English letters (A–Z, a–z)
Numbers (0–9)
Common punctuation marks
Basic control characters

Because of this, the original ASCII table contains 128 characters only.

ASCII PROGRAM
In JavaScript,using While Loop

name="silambu9391a@gmail.com"
index=0
while (index < name.length) {
    console.log(name[index]+ " = " + name.charCodeAt(index));
    index+=1
}

Output

![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ozh9ev9u0t1vfeggofpw.png)

In JavaScript,using For Loop

let name = "silambu9391a@gmail.com"
for(let i = 0;i < name.length; i++){
    console.log(name[i] + " " + name.charCodeAt(i));
}

In Python

name = "silambu9391a@gmail.com"
for ch in name:
    print(ch,ord(ch))

Parameters,Arguments,Return Type

PRIYA K — Wed, 08 Apr 2026 02:28:01 +0000

Parameters

Parameters are the variables declared in the method definition that receives the values.
Information passed to method as parameter.
Parameter are specified after the method name,inside the parentheses.

Example

public class Main {
  static void myMethod(String fname) {
    System.out.println(fname + " Refsnes");
  }

  public static void main(String[] args) {
    myMethod("Liam");
    myMethod("Jenny");
    myMethod("Anja");
  }
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes

Method Parameters
Add as many parameters,and separate them with a commas.

public class Example {
    static void add(int a, int b) {   // a and b are parameters
        System.out.println(a + b);
    }

    public static void main(String[] args) {
        add(10, 20);
    }
}

Explanation
int a ,int b => are parameters

Arguments
Arguments are the actual values passed to the method when calling it.

Example

public class Example {
    static void add(int a, int b) {
        System.out.println(a + b);
    }

    public static void main(String[] args) {
        add(10, 20);   // 10 and 20 are arguments
    }
}

Explanation
10 and 20 are arguments

Return Type
• Return type defines what value a method returns
• void → no return value
• Other types (int, String, double, boolean) must use return statement
• Returned value goes back to the calling method
• Execution always starts from main()
• Without return type you cannot send data back

A return type in Java is the data type of the value that a method sends back to the calling method after execution.
When a method finishes its work, it can return a value using the return keyword.

Syntax

returnType methodName(parameters) {
    // code
    return value;
}

Explanation

returnType → int, double, String, boolean, etc.
methodName() → name of the method
parameters → input values
return value; → sends the result back to the caller

Flow of Execution
Example:

class Demo {

    int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {

        Demo obj = new Demo();

        int result = obj.add(5, 3);

        System.out.println(result);
    }
}

Step-by-Step Execution
Program starts from main()
Object is created
Demo obj = new Demo();
Method call happens
obj.add(5, 3)
Control goes to add() method
Calculation happens
5 + 3 = 8
return 8 sends value back
Value stored in result
Printed on screen

Output
8

Why Return Type is Used ?
- To Send Result Back

class Demo {

    static int add() {
        return 5 + 3;
    }

    public static void main(String args[]) {

        int result = add();

        System.out.println(result);
    }
}

Output

Here:

add() returns 8
main() receives it
Result is printed

1.Int Return Type
Returns an integer value.

public class Demo {
    static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(add(5, 3));
    }
}

Output
8

2.Double Return Type
Returns a decimal number(Double Precision)

Example

public class Demo {
    static double divide(double a, double b) {
        return a / b;
    }

    public static void main(String[] args) {
        System.out.println(divide(10.5, 2.0));
    }
}

Output
5.25

3.Float Return Type
Returns a floating point number

Example

public class Demo {
    static float multiply(float a, float b) {
        return a * b;
    }

    public static void main(String[] args) {
        System.out.println(multiply(2.5f, 3.0f));
    }
}

Output
7.5

4.Char Return Type
Returns a single character

Example

public class Demo {
    static char getLetter() {
        return 'A';
    }

    public static void main(String[] args) {
        System.out.println(getLetter());
    }
}

Output
A

5.Boolean Return Type
Returns true or false

Example

public class Demo {
    static boolean isEven(int n) {
        return n % 2 == 0;
    }

    public static void main(String[] args) {
        System.out.println(isEven(6));
    }
}

Output
true

6.String Return Type
Returns a string(text)

Example

public class Demo {
    static String greet() {
        return "Hello Priya";
    }

    public static void main(String[] args) {
        System.out.println(greet());
    }
}

Output
Hello Priya

7.Void Return Type(No return type)
Method does not return any value

Example

public class Demo {
    static void message() {
        System.out.println("Welcome to Java");
    }

    public static void main(String[] args) {
        message();
    }
}

Example
Welcome to Java

Types Of Methods

1. Method with No Parameter and No Return Value
No input,does not return anything

class Demo {
    void greet() {
        System.out.println("Hello Priya");
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d.greet();
    }
}

Output
Hello Priya

Explanation
No Parameter inside ()
No Return Statement
Uses Void

2.Method with Parameter and No Return Value
takes input,does not return anything

class Demo {
    void add(int a, int b) {
        System.out.println(a + b);
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d.add(5, 3);
    }
}

Output
8

Explanation
Takes parameter a and b
Prints result directly
Uses Void

3.Method with Parameter and Return Value
Takes input and return a value

class Demo {
    int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        int result = d.add(5, 3);
        System.out.println(result);
    }
}

Output
8

Explanation
Takes parameter
Returns result using return

4.Method with No Parameter but Return Value
Takes no input , return value

class Demo {
    int number() {
        return 10;
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        int value = d.number();
        System.out.println(value);
    }
}

Output
10

Methods in Java

PRIYA K — Tue, 07 Apr 2026 05:40:25 +0000

Methods

Performs a specific task,Improves Readability,Allows code reuse
Can take Parameters and Return a value
Can be Static or Instance
Supports Method Overloading

Basic Syntax

returnType methodName(parameters) {
    // method body
    // code to execute
    return value; // optional
}

Create a Method

A method declared inside a class.
Defined with name of the method ,followed by the parentheses()

public class Main{
   static void myMethod(){
        //code to be executed
   }
}

Explanation
myMethod() => name of the method
void => does not return a value
static => method belongs to main class ,but not object of the main class

Call a Method
write method's name followed by parentheses() and semicolon;

Example

public class Main{
   static void myMethod{
      system.out.println("working as software developer")
   }
   public static void main(String[]args){
      myMethod();
   }
}

A method can be called multiple times

public class Main{
   static void myMethod{
      system.out.println("working as software developer")
   }
   public static void main(String[]args){
      myMethod();
      myMethod();
   }
}

Types of Methods in Java
1. Predefined Methods

These are already available in Java libraries.
Example of Predefined Methods
System.out.println()

Program Example:

System.out.println("Hello");

Here, println() is a predefined method.

2. User-defined Methods

Methods created by the programmer.

Example:

int add(int a, int b) {
    return a + b;
}

- Method Parameters
Methods can accept input values.

void add(int a, int b) {
    System.out.println(a + b);
}

Explanation
a and b are parameters

- Return Type
A method can return a value using return

Example:

int add(int a, int b) {
    return a + b;
}

Usage:
int result = add(5,3);
System.out.println(result);

Output
8

3.Method Without Return Value (void)
If a method does not return anything, we use void.

Example:

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

4.Static Methods
Belong to the class,not to the object

class Test {
    static void show() {
        System.out.println("Static Method");
    }

    public static void main(String[] args) {
        show();
    }
}

Hence no object is required

5.Instance Methods
Requires an object to call them

class Test {
    void display() {
        System.out.println("Instance Method");
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.display();
    }
}

6.Method Overloading
Allows multiple methods with the same name but different parameters.

int add(int a, int b){
    return a+b;
}

int add(int a, int b, int c){
    return a+b+c;
}

7.Method can call other methods

void greet(){
    System.out.println("Hello");
}

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