DEV Community: Ajay Sundar

Class in java

Ajay Sundar — Wed, 24 Sep 2025 04:12:34 +0000

Class

A class and is a blueprint or template for creating object
Inside a class there will be variables and methods
Without a class we will not be able to create an object

Example for an class

class Car{
         String brand;
         int speed;
         void display();
         System.out.println("Brand:" +"Speed":+Speed);
}
}

Class Explanation

Car is a class
It has two data types which are String and int
It has two variables brand and speed
it has one method (display())

Understanding Java Constructors and the this Keyword — Step‑by‑Step

Ajay Sundar — Wed, 10 Sep 2025 16:13:11 +0000

This() refers to current object.
It is a constructor call in java
this() acts as a current class constructor and is used in parameterized constructor
used to call or execute a current class method
using this with a attribute x

public class Main {
int x;


// Constructor with a parameter
public Main(int x) {
this.x = x;
}


// Call the constructor
public static void main(String[] args) {
Main myObj = new Main(5);
System.out.println("Value of x = " + myObj.x);
}
}

Step by Step Explanation

1) public class Main { — The class declaration

A class is a blueprint for objects. Main is the class name.
public means the class is visible to code in other packages.

2) int x; — Instance field (aka member variable)

x is an instance field of type int. Every Main object will have its own x.
Default value for an int field is 0 until you explicitly assign something.

3) public Main(int x) { ... } — Constructor with a parameter

This is a constructor: a special method that runs when you create an object with new.

Rules for constructors:

         - Same name as the class (Main).
         - No return type (not even void).
         - Can be overloaded (you can have multiple constructors with different parameter lists).

         - The parameter list (int x) declares a local variable x that exists only during the constructor call.

4) this.x = x; — Why this is essential here

x (the parameter) shadows the field x (they have the same name). Without this, references to x inside the constructor refer to the parameter, not the field.

this.x explicitly refers to the instance field x that belongs to the current object.

So this.x = x; reads: assign the value of the parameter x to the object's field x.

If you wrote x = x;, you'd simply assign the parameter to itself and the field would remain unchanged.

5) public static void main(String[] args) { — Program entry point

main is the method the JVM calls to start your program.
static means it belongs to the class, not to any particular object. That’s why you can call it without creating an instance first.
String[] args receives command‑line arguments (not used here).

6) Main myObj = new Main(5); — Object creation and constructor call

new Main(5) does two things:

Allocates memory on the heap for a new Main object and initializes fields to default values (e.g., x = 0).
Calls the constructor Main(int x) with the value 5.

Inside the constructor, this.x = x; sets the object's field x to 5.

The reference to the newly created object is stored in the variable myObj.

7) System.out.println("Value of x = " + myObj.x); — Printing the value

System.out.println(...) prints text to the console followed by a newline.
"Value of x = " + myObj.x concatenates the string with the integer value of myObj.x.
Final output on the console: Value of x = 5

Default constructor in java

Ajay Sundar — Thu, 04 Sep 2025 12:32:43 +0000

What is a default constructor?

A default constructor (often called a no-argument constructor) is a constructor that takes no parameters or if it has parameters,all the parameters have default values.If there is no constructor in a class the compiler automatically creates an default constructor

An Example on Default Constructor

class Animals {
    String breed;
    int age;
    double weight;

    Animals(String breed, int age, double weight) {
        this.breed = breed;
        this.age = age;
        this.weight = weight;
    }

    Animals(String breed, int age) {
        this.breed = breed;
        this.age = age;
    }

    Animals() {
    }

    void Getdata() {
        System.out.println("breed:" + breed);
        System.out.println("age:" + age);
        System.out.println("weight:" + weight);
    }

    public static void main(String[] args) {
        Animals obj = new Animals("Goldenretreiver", 13, 43.0);
        obj.Getdata();
    }
}

OUTPUT

breed:Goldenretreiver
age:13
weight:43.0

1. class Animals { ... }

Declares a class named Animals. A class is a blueprint for objects (instances).

2. String breed; int age; double weight;

These are instance fields (properties) of the class. When an Animals object is created, each instance gets its own breed, age, and weight.

Default values if not explicitly set: breed → null, age → 0, weight → 0.0.

3. Animals(String breed, int age, double weight) { ... }

This is a parameterized constructor that receives three arguments and assigns them to the fields.

4. this.breed = breed;

uses the this keyword to refer to the instance field breed. This disambiguates the field from the parameter with the same name.

5. Animals(String breed, int age) { ... }

This is an overloaded constructor that accepts only breed and age. It sets these fields and leaves weight with its default value 0.0.

6. Animals() { }

This is an explicit no-argument constructor (explicit default). Because you have other constructors, this explicit no-arg constructor is required if you want to be able to do new Animals() elsewhere. It does nothing, so fields keep their default values.

7. void Getdata() { ... }

A method that prints the current values of the fields. Minor issues to note:

Naming convention: Java methods typically use camelCase and start with a lowercase letter (e.g., getData() or printData() is preferred).
Formatting: System.out.println("weight" + weight); produces weight43.0 (no colon or space). Better would be "weight: " + weight.

8.public static void main(String[] args) { ... }

Program entry point. This line creates a new Animals object using the three-argument constructor:

new Animals("Goldenretreiver", 13, 43.0); — calls the 3-parameter constructor, so breed, age, and weight are all set.

Then obj.Getdata(); prints those values.

Expected Output

breed:Goldenretreiver
age:13
weight:43.0

Constructor in java

Ajay Sundar — Thu, 04 Sep 2025 07:40:18 +0000

A constructor is a special block of code that is called when an object is created. Its main job is to initialize the object, to set up its internal state, or to assign default values to its attributes.

Characteristics of constructors

Same Name as the Class: A constructor has the same name as the class in which it is defined.
No Return Type: Constructors do not have any return type, not even void. The main purpose of a constructor is to initialize the object, not to return a value.
Automatically Called on Object Creation: When an object of a class is created, the constructor is called automatically to initialize the object’s attributes.
Used to Set Initial Values for Object Attributes: Constructors are primarily used to set the initial state or values of an object’s attributes when it is created.

An example of constructor

class Market {
    String groceries;
    String color;
    double weight;
    int rate;

   Market (String groceries,String color,double w,int rate) {
       //this. is current object
       this.groceries = groceries;
       this.color = color;
       this.weight = w;
       this.rate = rate;
   }
       void groceries(){
           System.out.println("groceries:"+groceries);
       }
       void color(){
           System.out.println("Color:" +color);
       }
       void weight(){
           System.out.println("weight:"+weight);
       }
       void amount(){
           System.out.println("rate:"+rate);
       }

    public static void main(String[] args){
       Market obj= new Market("Sugar","White",54,78);


       obj.groceries();
       obj.color();
       obj.weight();
       obj.amount();

    }
}

OUTPUT

groceries:Sugar
Color:White
weight:54.0
rate:78

Polymorphism in Java

Ajay Sundar — Tue, 02 Sep 2025 13:45:29 +0000

What is Polymorphism ?

Polymorphism in Java is one of the core concepts in object-oriented programming (OOP) that allows objects to behave differently based on their specific class type. The word polymorphism means having many forms, and it comes from the Greek words poly (many) and morph (forms), this means one entity can take many forms.

Key Features of java

Multiple Behaviors: The same method can behave differently depending on the object that calls this method.
Method Overriding: A child class can redefine a method of its parent class.
Method Overloading: We can define multiple methods with the same name but different parameters.
Runtime Decision: At runtime, Java determines which method to call depending on the object's actual class.

Reference : https://www.geeksforgeeks.org/java/polymorphism-in-java/

Overloading in Polymorphism


public class Sum {

    public int sum(int x, int y) { 
    return (x + y); }

    public int sum(int x, int y, int z)
    {
        return (x + y + z);
    }

    public double sum(double x, double y)
    {
        return (x + y);
    }


    public static void main(String args[])
    {
        Sum s = new Sum();
        System.out.println(s.sum(10, 20));
        System.out.println(s.sum(10, 20, 30));
        System.out.println(s.sum(10.5, 20.5));
    }
}

OUTPUT

30
60
31.0

Line by Line Explanation

public class Sum { ... }

Declares a public class named Sum. Because the class is public, the source file must be named Sum.java.

public int sum(int x, int y)

A method named sum that accepts two int parameters and returns an int. The body returns the sum x + y.

public int sum(int x, int y, int z)

Another sum method with three int parameters. This is overloading — same method name but different parameter list (arity).

public double sum(double x, double y)

Another overloaded sum that accepts two doubles and returns a double. Because parameter types differ from the int version, Java considers it a different method.

public static void main(String args[])
The JVM looks for this method to start the program. static means it runs without creating an instance of Sum.
Sum s = new Sum();
Creates a new Sum object and stores its reference in variable s.
System.out.println(s.sum(10, 20));
Calls the sum(int, int) method. Integer literals 10 and 20 are of type int by default. The method returns 30, which println prints.
System.out.println(s.sum(10, 20, 30));
Calls the sum(int, int, int) method. Returns 60.
System.out.println(s.sum(10.5, 20.5));
Calls the sum(double, double) method. Decimal literals like 10.5 are double by default. Returns 31.0.

Method overriding example with a car race

class Vehicles {
    void Car(){
        System.out.println("Vehicles are faster");
    }
}
class Race extends Vehicles {
     void Car(){
        System.out.println("Porsche is ready for the car race");
    }
}
class Slowrace extends Vehicles {
     void Car(){
        System.out.println("Benz is ready for the slow race");
    }
}
public class Tokyo {
    public static void main(String[] args){
        Vehicles vehicle1 = new Vehicles();
        Race vehicle2 = new Race();
        Slowrace vehicle3 = new Slowrace();

        vehicle1.Car();
        vehicle2.Car();
        vehicle3.Car();



    }
}

OUTPUT

Vehicles are faster
Porsche is ready for the car race
Benz is ready for the slow race

Learning some basic concepts in Java

Ajay Sundar — Mon, 01 Sep 2025 17:04:16 +0000

Today i got an oppurtunity to learn the basic concepts in java and it was interesting to learn and was a bit easily understandable.

CALCULATION OF THE AREA OF THE CIRCLE USING JAVA

Using the java programming language we know calculate the area of circle

public class Area{
    void AreaofCircle(){
        double pi = 3.14;
        double radius = 5;
        double r = radius * radius;
        System.out.println(pi * r);
    }

    public static void main(String[] args){
        Area obj = new Area();
        obj.AreaofCircle();
    }
}


OUTPUT
78.5

Step by step Explanation

1. Class Declaration

public class Area {

The class is named Area, which contains methods related to calculating the area.

2.Creating a Method

void AreaofCircle(){
    double pi = 3.14;
    double radius = 5;
    double r = radius * radius;
    System.out.println(pi * r);
}

void AreaofCircle() is a method that performs the task of calculating the area of a circle.
double pi = 3.14; stores the value of π (pi).
double radius = 5; is the radius of the circle.
double r = radius * radius; calculates the square of the radius.
Finally, System.out.println(pi * r); prints the area of the circle using the formula π × r².

3.Main Method

public static void main(String[] args){
    Area obj = new Area();
    obj.AreaofCircle();
}

Every Java program starts execution from the main method.
Area obj = new Area(); creates an object of the Area class.
obj.AreaofCircle(); calls the method to perform the calculation and display the result.

OUTPUT

when you run this program, the output will be:

78.5

This is the area of a circle with a radius of 5 units.

How to calculate Simple Interest using Java

The formula for calculating simple interest is:

              SI = P*N*R/100

Where:

P = Principal amount
N = Number of years
R = Rate of interest

class Simple{
    void Simpleinterest(){
        int P = 500;
        int N = 200;
        int R = 100;
        int SI = (P * N * R / 100);
        System.out.println(SI);
    }

    public static void main(String[] args){
        Simple obj = new Simple();
        obj.Simpleinterest();
    }
}

OUTPUT

100000

Step by Step Explanation

1.Class Declaration

class Simple {

The class is named Simple, which contains all the logic for calculating simple interest.

2.Method for Calculation

void Simpleinterest(){
    int P = 500;
    int N = 200;
    int R = 100;
    int SI = (P * N * R / 100);
    System.out.println(SI);

void Simpleinterest(): This method calculates the simple interest.
int P = 500; → Principal amount is set to 500.
int N = 200; → Time period (years) is set to 200.
int R = 100; → Rate of interest is set to 100.
int SI = (P * N * R / 100); → Formula applied for calculation.
System.out.println(SI); → Displays the result on the console.

3.Main Method

public static void main(String[] args){
    Simple obj = new Simple();
    obj.Simpleinterest();
}

Entry point of the Java program.
Simple obj = new Simple(); → Creates an object of class Simple.
obj.Simpleinterest(); → Calls the method to calculate and print the simple interest.

OUTPUT

When you run this program, the output will be:

Like Father Like Son : A Begginer's Guide to Java Inheritance

Ajay Sundar — Fri, 29 Aug 2025 19:17:36 +0000

Inheritance is one of the core pillars of Object-Oriented Programming (OOP). It allows one class (child/subclass) to acquire the properties and behaviors (fields and methods) of another class (parent/superclass).

Single Inheritance

A subclass inherits from one superclass

Multilevel Inheritance

A class is derived from another class, which is also derived from another class.

Hierarchical Inheritance
Multiple classes inherit from the same parent class

Multiple Inheritance

Java doesn’t allow multiple inheritance with classes (to avoid conflicts).
But it supports multiple inheritance with interfaces.

Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance.
Java does not support hybrid inheritance with classes, but it can be achieved using interfaces.

Real world example using inheritance
In Object-Oriented Programming (OOP), inheritance is one of the most powerful features. It allows a class (child) to acquire the properties and methods of another class (parent). This helps in code reusability and makes the program more structured.

To understand this better, let’s look at a real-world example — a training institute called Payilagam.

class Institute {
    void Morning() {
        System.out.println("Morning session starts at 9:00AM");
    }
    void Afternoon() {
        System.out.println("Afternoon session starts at 2:00PM");
    }
    void Communication() {
        System.out.println("Communication starts at 3:30PM");
    }
    void Aptitude() {
        System.out.println("Aptitude starts at 4:30");
    }
}

Here, the Institute class is the parent (superclass).
It defines common sessions like Morning, Afternoon, Communication, and Aptitude.

The Derived Classes – Students, Teachers, Facilities

Students Class

class Students extends Institute {
    void MorningSession() {
        System.out.println("Morning Session is always productive");
    }
    void Lunch() {
        System.out.println("Lunch is a time where we get time to interact");
    }
    void EveningSession() {
        System.out.println("Evening session feels tired because of after lunch");
    }
}

Students inherit all sessions from Institute.
They also describe their own experiences like MorningSession, Lunch, and EveningSession.

Teachers Class

class Teachers extends Institute {
    void MuthuSir() {
        System.out.println("Muthu sir is a great speaker when it comes about life");
    }
    void PrithviSir() {
        System.out.println("Prithvi sir is our Java Trainer");
    }
    void SalmanSir() {
        System.out.println("Salman sir Communication class is very interactive");
    }
}

Teachers too inherit sessions from Institute.
They add specific methods that describe different trainers.

3.Facilities Class

class Facilities extends Institute {
    void Airconditioner() {
        System.out.println("The AirConditioner is great at Payilagam");
    }
    void InternetAccess() {
        System.out.println("The internet access is medium at Payilagam");
    }
    void Waterfacilities() {
        System.out.println("The water facilities is great at payilagam");
    }
}

Facilities also extend Institute.
This class focuses on infrastructure features like air conditioning, internet, and water.

The Driver Class – Payilagam

public class Payilagam {
    public static void main(String[] args) {
        Institute obj = new Institute();
        Teachers obj1 = new Teachers();
        Students obj2 = new Students();
        Facilities obj3 = new Facilities();

        obj.Morning();
        obj.Afternoon();
        obj.Communication();
        obj.Aptitude();

        obj2.MorningSession();
        obj2.Lunch();
        obj2.EveningSession();

        obj1.MuthuSir();
        obj1.PrithviSir();
        obj1.SalmanSir();

        obj3.Airconditioner();
        obj3.InternetAccess();
        obj3.Waterfacilities();
    }
}

Here, we:

Created objects of Institute, Teachers, Students, and Facilities.
Called methods to display their respective messages.

OUTPUT

Morning session starts at 9:00AM
Afternoon session starts at 2:00PM
Communication starts at 3:30PM
Aptitude starts at 4:30
Morning Session is always productive
Lunch is a time where we get time to interact
Evening session feels tired because of after lunch
Muthu sir is a great speaker when it comes about life
Prithvi sir is our Java Trainer
Salman sir Communication class is very interactive
The AirConditioner is great at payilagam
The internet access is medium at Payilagam
The water facilities is great at payilagam

Key Takeaways

Inheritance in Action: All classes extend Institute, reusing its session methods.
Code Reusability: Instead of redefining sessions for each class, they are inherited.
Real-World Mapping: Students, Teachers, and Facilities represent real entities in an institute.
Scalability: We can easily add new classes like Events or Exams in the future without changing the existing code.

Finding My Path: Why I Chose Full Stack Development as a Career

Ajay Sundar — Thu, 28 Aug 2025 07:53:44 +0000

The Time Where Life Hit Hard

Life after graduation is often filled with uncertainty, especially when the big question arises: “What next?”

After completing my B.Tech in Information Technology, I found myself standing at a crossroads. On one side was the stability of a bank job, on the other, the ever-evolving world of the tech industry. Both paths looked promising, but I lacked one important thing — the right skills.

The Pressure of Time and Uncertainty

The clock had started ticking. Months went by, and I was actively attending interviews. I had the eagerness to learn and the ambition to succeed, but without strong technical skills, each attempt felt incomplete. The pressure was high — from society, from family, and most of all, from within.

This phase was difficult. It wasn’t just about finding a job; it was about shaping a career and a life direction.

Every Road Led Back to Tech

Interestingly, whenever I tried to explore opportunities outside the tech industry, life had a way of redirecting me back. It felt like destiny was taking me toward technology.

No matter what I did, the path circled back to software development. That’s when I realized: “Maybe this is where I am meant to be.”

Why Full Stack Development?

The tech industry is vast — AI, cloud, cybersecurity, data science — but what caught my attention was Full Stack Development.

Why? Because being a full stack developer means:

Building end-to-end applications (both front-end and back-end).

Understanding how different parts of a project connect.

Having the flexibility to work on multiple layers of technology.

It’s a role that offers both creativity (front-end design) and logic (back-end problem solving). For someone like me, who wants to see a complete picture of what they build, it felt like the right fit.

Taking the First Step

With clarity in mind, I decided to invest in myself. I enrolled in a Full Stack Development course to bridge the gap between ambition and skill. My focus now is to:

Gain practical, hands-on coding experience.

Build real-world projects to showcase my skills.

Secure an entry-level role that allows me to grow and contribute.

This is no longer about just finding a job — it’s about building a career in technology.

Closing Thoughts

Looking back, I realize that uncertainty, interviews, and even family pressure were all part of the process that led me here.

Sometimes, destiny speaks not through success, but through redirection. And every redirection in my journey pointed me toward Full Stack Development.

Now, with clarity and determination, I’m ready to take the next step — to learn, grow, and become a full stack developer in the tech industry.

To anyone reading this who feels lost after graduation: it’s okay to not have all the answers immediately. Explore, fail, learn, and listen to the path life is guiding you toward. The important part is not giving up.

The Coffee Shop Story - Understanding Java Operators

Ajay Sundar — Thu, 28 Aug 2025 06:54:17 +0000

When you enter into the basics of java operators play a role in the learning process of java .

The Coffee Shop Story

Imagine you are going out on a coffee date with your life partner. Java operators are just like the rules the shop uses to serve you.

Arithmetic Operators:

You order a coffee and your life partner orders 2. The cashier adds them:

1+2 = 3 coffees

That’s arithmetic—used for adding, subtracting, multiplying, or dividing.

Relational Operators

The waiters checks do you both have the same number of coffees?

If yes → true. If not → false.
These operators compare values.

Logical Operators

The manager says: “If BOTH of you pay (AND), you’ll get the order. If EITHER of you pays (OR), it still works.”

Logical operators help make decisions.

Assignment operators

The cashier writes your bill:

Bill = 200

Later, you add a sandwich:

Bill += 50 → 250

Assignment operators set or update values.

Ternary Operator

Finally, the waiter asks: “Are you a member? If yes → discount, else → full price.”
This is the ternary operator, a shortcut for quick decisions.

Just like the coffee shop runs smoothly with these rules, your Java program runs smoothly with operators—the symbols that calculate, compare, assign, and decide.

Now that you have got an basic understanding in java operators we will go through a real world example for a bit more clarification.

A person buys 4 Packets of bread at ₹25 each and 2 milk packets at ₹30 each. Find the total bill.

public class GroceryBill {
    public static void main(String[] args) {
        int bread = 4 * 25;   
        int milk = 2 * 30;    
        int total = bread + milk;
        System.out.println("Total GroceryBill = ₹" + total);
    }
}


OUTPUT
Total Grocery Bill = ₹160

Step-by-Step Explanation

Multiplication (*)

int bread = 4 * 25;

Here, the person buys 4 loaves of bread.

Each bread costs ₹25.

Total bread cost = 4 * 25 = 100.

int milk = 2 * 30;

The person buys 2 packets of milk.

Each milk costs ₹30.

Total milk cost = 2 * 30 = 60.

Addition (+)

int total = bread + milk;

We add the bread cost (₹100) and milk cost (₹60).

Total = 100 + 60 = 160.

Output (System.out.println)

System.out.println("Total Grocery Bill = ₹" + total);

Total Grocery Bill = ₹160

What did we learn ?

(multiplication) helps calculate total cost when buying multiple items.
(addition) helps sum up the total bill.

Real-world shopping calculations can easily be represented in Java using arithmetic operators.

The Secret Agents of Java : Methods

Ajay Sundar — Wed, 27 Aug 2025 17:32:09 +0000

The Magic Toolbox: How Java Methods Solve Problems

Imagine you are an engineer in a huge workshop. You have a big task: fixing different types of machines. Every time a machine breaks down, you could grab all the tools lying around, figure out how to fix it from scratch, and waste a lot of time.

But luckily, you own a magic toolbox.

Inside this toolbox, each drawer is already prepared with the right tools for a specific task. One drawer fixes engines, another repairs belts, and another one polishes gears acting as a secret agent in Java. Instead of starting over each time, you simply open the correct drawer, use it, and the problem is solved quickly.

In the world of Java, this magic toolbox is nothing but Methods.

A method is like a drawer in your toolbox.

Each method is designed to perform one specific job.

Whenever you face a problem, instead of writing the entire solution again, you just “call” the method.

What is a Method in Java ?

A method is a block of code that performs a specific task.
Instead of repeating code multiple times, you can write it once inside a method and then reuse it whenever needed.

Understanding Methods by Arithmetic operations

now we will learn how to declare and call a method in java by using arithmetic operators

public class Main  {
    public  static void main (String[] args){
        Addition();
    }
    public static void Addition(){
        int a= 200;
        int b= 100;
        int c= 50;
        int d=a+b+c;
        System.out.println("Addition of the numbers :"+a + "+" +b + "+" +c + "=" +d);

        subtraction();
    }

    public static void subtraction(){
        int a=500;
        int b=100;
        int c=50;
        int d=a-b-c;
        System.out.println("Subtraction of the numbers :"+a +"-" +b +"-" +c + "=" +d);

        multiplication();
    }
    public static void multiplication(){
        int a=100;
        int b=100;
        int c=100;
        int d=a*b*c;
        System.out.println("Multiplication of the  numbers :"+a +"*" +b +"*" +c +"=" +d);

    division();
}
    public static void division(){
    int a=30;
    int b=5;
    int c=2;
    int d=a/b/c;
    System.out.println("Division of  numbers :"+a +"/" +b +"/" +c +"=" +d);

    modulus();
}
   public static void modulus(){
    int a=30;
    int b=5;
    int c=2;
    int d=a%b%c;
    System.out.println("Modulus of numbers :"+a +"%" +b +"%" +c +"=" +d);
    }
}

OUTPUT

Addition of the numbers :200+100+50=350
Subtraction of the numbers :500-100-50=350
Multiplication of the  numbers :100*100*100=1000000
Division of  numbers :30/5/2=3
Modulus of numbers :30%5%2=0

Understanding Method Declaration and Method Calling in Java

In Java, methods allow us to organize code into reusable blocks that perform specific tasks. This improves code readability, reduces redundancy, and makes debugging easier. In this example, we demonstrate how to declare methods and call them from one another using basic arithmetic operations: addition, subtraction, multiplication, division, and modulus.

Final Thoughts

Methods help you structure your Java programs logically. By declaring and calling methods, you can avoid redundancy, improve readability, and build scalable applications.

"Big Fish, Small Pond: Understanding Type Casting in Java"

Ajay Sundar — Tue, 26 Aug 2025 12:24:33 +0000

When you are journey starts in java you will obviously come across the concept of type casting in java.

Big Fish in a Small Pond: A Tale of Type Casting in Java

Imagine there’s a big fish swimming in the ocean. The ocean is huge, just like the double data type in Java—it can hold really large and very precise values.

One day, this big fish wants to visit his relatives in a small pond. But here’s the problem: the pond isn’t as big as the ocean. It’s like a int or a byte in Java—it has limited space.

Now, if the big fish (say, a double) wants to squeeze into the small pond (say, an int), he has to shrink himself. This shrinking process is what we call type casting.

Type casting is the process of converting a variable of one datatype to another datatype in simple words, it is a conversion of one data type to another data type.

For Example :

Converting an int into a double
Converting a double into int

Type casting is of two types:

Widening
Narrowing

Widening

Widening happens when a smaller data type is converted into a larger Data type.
It is safe no data type is lost.

public class WideningExample {
public static void main(String[] args) {
int num = 20;
double result = num;
System.out.println("Integer: " + num);
System.out.println("Double: " + result);
}
}


OUTPUT

Integer: 20
Double: 20.0

Widening order in Java

byte → short → int → long → float → double

Narrowing

Narrowing Happens when we convert an larger data type into a smaller data type

It needs to be done in a manual manner in parantheses because there is a chance in data loss

public class NarrowingExample {
    public static void main(String[] args) {
        double num = 45.89;
        int result = (int) num; // double → int
        System.out.println("Double: " + num);
        System.out.println("Integer: " + result);
    }
}




OUTPUT

Double: 45.89
Integer: 45

Here the decimal part (.89) is lost.

Type casting With Characters

Characters in java are stored as Unicode values (which are integers). This means you can cast between char and int simple and useful.

public class CharCasting {
    public static void main(String[] args) {
        char letter = 'A';
        int ascii = letter; // char → int
        System.out.println("Character: " + letter);
        System.out.println("ASCII Value: " + ascii);
    }
}




OUTPUT

Character : A
ASCII Value : 65

Here do not get confused how the output of the ASCII Value becomes 65 .
The output is 65 because The Character 'A' has a numeric code of 65.

https://www.ascii-code.com/

The above link is the ASCII table. It gives an better understanding on the ASCII values.

Now that you have got an better idea on type casting let us solve an real world example on type casting for better understanding.

Real World Examples of Type Casting

Imagine you are building an E-Commerce application.Prices are stored as double for accuracy,but when displaying rounded values you may want to show them as int.

public class ShoppingCart {
    public static void main(String[] args) {
        double price = 199.99;
        int roundedPrice = (int) price; // double → int
        System.out.println("Original Price: " + price);
        System.out.println("Rounded Price: " + roundedPrice);
    }
}



OUTPUT


Original Price: 199.99  
Rounded Price: 199

Here it is converted from double to int using the process of type casting

Here in the above real world example of type casting it is a narrow type casting because we are converting from double to int.

double - 8 byte
int - 4 byte

We have seen what is type casting and its types now we will see why it is important.

Importance of Type Casting

Ensures similarity between different data types
Commonly used in real world applications like unit conversions, money calculation, or working with APIs

API- Application programming interface

Final Thoughts

Type casting in Java is a simple but important concept that ensures smooth interaction between different data types. Whether you’re dealing with mathematical calculations, character values, or application data, mastering type casting will make you a better Java programmer.

Start practicing with different data types (int, double, char, float) and see how casting behaves. With practice, you’ll gain confidence in using type casting effectively in your programs.

Learning the Basic programming concepts of java

Ajay Sundar — Wed, 13 Aug 2025 11:39:46 +0000

Learning the basics

Everyday is a learning process. The more i learn a skill the more I get improved and acheive my short term goal which is to get a job as a fresher in the information technology industry.

So I started my learning process by learning some very basics stuffs which is the concept of "Hello World".

public Class main{
public static void main(String[]args){
System.out.println("Hello World!");
}
}

From the above code we get the result as:

output

Hello world !

The other basic feature that i learnt is that

Java is Case Sensitive
"MyClass" and "myclass" has different meaning
Every program must have an main() method.

System.out.println
Inside every main() method we can use the println() method to print a line.
we can print how much ever println() method we want

Public class Main(){
public static void main(String[]args){
System.out.println("Hello World!");
System.out.println("I am learning Java");
System.out.println("It is new and fun");
}
}

Here for the above code the result will be

output

Hello World!
I am learning Java
It is new and fun

System.out.print

This function is similar to println() function
The only difference is that it does not print a new line.

System.out.print("Hello!");
System.out.print("My name is Ajay");

Here for the above code the result will be

output

Hello! My name is Ajay

Java output numbers

We use the println() methods to print the numbers
We do not need double Quotations to print the numbers.

System.out.println(30)
System.out.println(300)
System.out.println(3000)

For the above code the result will be

output

30
300
3000

Conclusion
Today was an important day because it takes a big steps towards my learning progress in java

Here are the things that I learnt today :

How to print a simple Hello World Program
mastering the basic of println() method
mastering the print() method
Learnt how to print output numbers using the println() methods