DEV Community: Murali Rajendran

What is Array in Java

Murali Rajendran — Tue, 11 Nov 2025 12:39:13 +0000

Array is a collection of similar data types stored in under a common name.

*Its stored homogeneous data into array.

*It helps you store multiple values in a single variable instead of declaring separate variables for each value.

*Array value store in heap memory

*Here JVM will manage to create the memory for the Array object.

*It is a index based.

*The starting index will be 0.

*Each element is accessed by its index, starting from 0.

*In Java, the size of an array cannot change once it is created.

*You can modify the elements inside it, but not the length.

*No import is needed for arrays in Java.Arrays are built into the Java language itself — they are part of the core language.

If you want to use these methods Arrays.sort(), Arrays.toString() should import this package **import java.util.Arrays;*.

— but it can store both primitive and non-primitive values inside it.

WHY WE USE ARRAY:

*We use arrays in Java because they let us store and manage multiple values efficiently using a single variable name — instead of creating many separate variables.

*Store multiple values together
Instead of many variables, one array holds many items.

*Easy looping
We can access all elements using a loop.

*Fast access by index
Access any element directly using its index (like marks[2]).

*Memory efficiency
Elements are stored contiguously in memory.

ARRAY SYNTAX:

Declaration and then creation
dataType[] arrayName = new dataType[size];

Example:

int[] numbers = {10, 20, 30, 40, 50};

Declare the size of the Array:
int[] numbers; // Declaration
numbers = new int[3]; // Creation
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

Getting array size:
System.out.println(numbers.length); // prints number of elements

Advantages of arrays:

*Stores multiple values in a single variable.

*Easy access using index.

*Useful for calculations and data analysis.

*Memory efficiency.

Simplifies code.
*
Disadvantages of arrays:**

*Fixed size.

*Once an array is created, its size cannot be changed.

*Can store only one data type.

*3️⃣ No built-in methods for easy operations

Arrays do not have built-in methods for:

Adding or removing elements

Searching specific items

Checking if an element exists.

*Wastage or shortage of memory

Because size is fixed:

If you allocate too large, memory is wasted.

If you allocate too small, it can’t hold all data.

🔄 Polymorphism in Java

Murali Rajendran — Tue, 04 Nov 2025 10:13:40 +0000

1.Its that allows objects to behave differently based on their specific class type.

2.In Java, polymorphism allows the same method or object to behave differently based on the context, specially on the project's actual runtime class.

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

Consider a person who plays different roles in life, like a father, a husband, and an employee. Each of these roles defines different behaviors of the person depending on the object calling it.

Example

// Base class Person
class Person {

// Method that displays the 
// role of a person
void role() {
    System.out.println("I am a person.");
}

}

// Derived class Father that
// overrides the role method
class Father extends Person {

// Overridden method to show 
// the role of a father
@Override
void role() {
    System.out.println("I am a father.");
}

}

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

    // Creating a reference of type Person 
    // but initializing it with Father class object
    Person p = new Father();

    // Calling the role method. It calls the 
    // overridden version in Father class
    p.role();  
}

}

**
Types of Polymorphism in Java**
In Java Polymorphism is mainly divided into two types:

1.Compile-Time Polymorphism (Static)-Method overloading
2.Runtime Polymorphism (Dynamic)-Method overriding

1. Compile-Time Polymorphism
1.Compile-Time Polymorphism in Java is also known as static polymorphism and also known as method overloading. This happens when multiple methods in the same class have the same name but different parameters.
2.Functions can be overloaded by changes in the number of arguments or/and a change in the type of arguments.
3.Occurs when multiple methods have the same name but different parameters (number, type, or order).
Decided at compile time.

Example:

// Method overloading By using
// Different Types of Arguments

// Class 1
// Helper class
class Helper {

// Method with 2 integer parameters
static int Multiply(int a, int b)
{
    // Returns product of integer numbers
    return a * b;
}

// Method 2
// With same name but with 2 double parameters
static double Multiply(double a, double b)
{
    // Returns product of double numbers
    return a * b;
}

}

// Class 2
// Main class
class Geeks
{
// Main driver method
public static void main(String[] args) {

    // Calling method by passing
    // input as in arguments
    System.out.println(Helper.Multiply(2, 4));
    System.out.println(Helper.Multiply(5.5, 6.3));
}

}

2. Runtime Polymorphism

1.Method overriding in Java means when a subclass provides a specific implementation of a method that is already defined in its superclass.
2.Occurs when a subclass provides its own version of a method already defined in its superclass.
Decided at runtime using method overriding and dynamic method dispatch.

class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}

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

public class Main {
public static void main(String[] args) {
Animal obj = new Dog(); // reference of parent, object of child
obj.sound(); // Output: Dog barks
}
}

✅ Why Use Polymorphism?

Increases code reusability
Makes code flexible and maintainable
Enables dynamic behavior of objects at runtime

Example

class Payment {
void pay() { System.out.println("General payment"); }
}

class CreditCard extends Payment {
void pay() { System.out.println("Paid using Credit Card"); }
}

class PayPal extends Payment {
void pay() { System.out.println("Paid using PayPal"); }
}

class Test {
public static void main(String[] args) {
Payment p = new PayPal();
p.pay(); // Output: Paid using PayPal
}
}

➡️ Same method pay() acts differently depending on the payment type.

Interface in Java

Murali Rajendran — Tue, 04 Nov 2025 09:51:46 +0000

🧠 What is an Interface?

1.An interface in Java is a blueprint of a class that defines a set of abstract methods (no body) which must be implemented by any class that uses (implements) the interface.
2.It is used to achieve abstraction and multiple inheritance.
3.Bydefault all methods are abstract method.
4.Its a set of rules and interface is a Keyword
5.Implementation: To implement an interface, we use the keyword implements

interface Animal {
void eat(); // abstract method
void sleep(); // abstract method
}

class Dog implements Animal {
public void eat() { System.out.println("Dog is eating..."); }
public void sleep() { System.out.println("Dog is sleeping..."); }
}

✅ What You Can Do with Interfaces

✔️ Define abstract methods (implicitly public and abstract).

✔️ Define public static final constants (variables).

✔️ Provide default methods (with body) using default keyword.

✔️ Provide static methods (with body).

✔️ Achieve multiple inheritance (a class can implement multiple interfaces).

✔️ Achieve 100% abstraction (if only abstract methods are used).

interface Vehicle {
void start();
default void stop() { System.out.println("Vehicle stopped"); }
static void info() { System.out.println("Vehicle interface"); }
}

❌ What You Cannot Do with Interfaces

❌ Cannot have instance variables (only public static final).

❌ Cannot have constructors (cannot create object directly).

❌ Cannot contain method implementations (except default and static).

❌ Cannot extend classes (but can extend other interfaces).

❌ Cannot maintain state — only define behavior.

interface A { void show(); }
interface B { void display(); }

class C implements A, B {
public void show() { System.out.println("Show from A"); }
public void display() { System.out.println("Display from B"); }
}

Example

Let’s consider the example of Vehicles like bicycles, cars and bikes share common functionalities, which can be defined in an interface, allowing each class (e.g., Bicycle, Car, Bike) to implement them in its own way. This approach ensures code reusability, scalability and consistency across different vehicle types.

🧬 Types of Inheritance in Java

Murali Rajendran — Tue, 04 Nov 2025 09:29:28 +0000

Inheritance in Java allows one class to acquire properties and behaviors (fields and methods) of another class. It promotes code reusability and method overriding.

Types:
1.1. Single Inheritance

A subclass inherits from one superclass.

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

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

2.2. Multilevel Inheritance

A chain of inheritance.

// Parent class
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}

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

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

// Child class
class Cow extends Animal {
void sound() {
System.out.println("Cow moos");
}
}

// Main class
public class Geeks {
public static void main(String[] args) {
Animal a;
a = new Dog();
a.sound();

    a = new Cat();
    a.sound(); 

    a = new Cow();
    a.sound();  
}

}

3.3. Hierarchical Inheritance

Multiple subclasses inherit from one superclass.
In hierarchical inheritance, more than one subclass is inherited from a single base class. i.e. more than one derived class is created from a single base class.

class Vehicle {
Vehicle() {
System.out.println("This is a Vehicle");
}
}

class Car extends Vehicle {
Car() {
System.out.println("This Vehicle is Car");
}
}

class Bus extends Vehicle {
Bus() {
System.out.println("This Vehicle is Bus");
}
}

public class Test {
public static void main(String[] args) {
Car obj1 = new Car();
Bus obj2 = new Bus();
}
}

4.Multiple Inheritance (via Interface)

Java doesn’t support multiple inheritance with classes — to avoid ambiguity —
The interfaces allow it.
The Java does not support multiple inheritances with classes. In Java, we can achieve multiple inheritances only through Interfaces.

interface A { void show(); }
interface B { void display(); }

class C implements A, B {
public voiIt is a mix of two or more of the above types of inheritance. In Java, we can achieve hybrid inheritance only through Interfaces d show() { System.out.println("Show"); }
public void display() { System.out.println("Display"); }
}

5.Hybrid Inheritance

Combination of more than one type (e.g., multiple + multilevel).
Achieved using interfaces only..
It is a mix of two or more of the above types of inheritance. In Java, we can achieve hybrid inheritance only through Interfaces

Type Example Supported by
Single A → B Classes
Multilevel A → B → C Classes
Hierarchical A → B, A → C Classes
Multiple A, B → C Interfaces
Hybrid Combination Interfaces

🧬 What Is Inheritance?

Murali Rajendran — Tue, 04 Nov 2025 09:01:43 +0000

1.Inheritance is when one class acquires the properties and behaviors (fields and methods) of another class.
2.It helps you reuse code, avoid duplication, and organize your program logically.
👉 In simple words:
3.A child class (subclass) can inherit from a parent class (superclass).
4.A class which is inherits from another class. A child class/subclass behave like a parent class or base class.
4.The class that inherits from another class. It can also be called a derived class or extended class.

extends keyword: Used to establish the inheritance relationship. A subclass uses extends to inherit from a superclass.

What is a Constructor?

Murali Rajendran — Tue, 04 Nov 2025 09:00:27 +0000

A constructor is like a “welcome setup” that runs automatically when an object is created.
Think of it like a welcome gift pack 🛍️ — whenever you create a new object, Java runs the constructor to set up initial values.
🔹 Syntax:
class ClassName {
ClassName() {
// setup code (like a welcome gift)
}
}

🧩 3 Types of Constructors:

Type Example Description

Default constructor SuperMarket() {}
Created automatically by Java if you don’t make one yourself. It sets default values (0, null, false).
No-parameter constructor

SuperMarket() { groceryProductPrice = 50; }
You create it manually. It has no parameters but assigns custom default values.
Parameterized constructor

SuperMarket(int groceryProductPrice, int choc) { ... }
You pass values while creating an object.

🧠 2. this Keyword — “I belong to this object”
👉 Think of this as “me” inside the class.
When a local variable name is same as an instance variable name, this helps Java understand which one belongs to the object.

🎁 5. Wrapper Classes

Murali Rajendran — Tue, 04 Nov 2025 08:58:03 +0000

Wrapper classes “wrap” primitive data types into objects (useful for collections, null handling, etc.)
Primitive Wrapper Class
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Example:

int age = 10;
Integer age1 = Integer.valueOf(age); // boxing
🧩 Memory tip:
“Wrapper = gift box for primitive” 🎁

Access Modifier #public#private#protected#default

Murali Rajendran — Tue, 04 Nov 2025 08:50:31 +0000

🌟 What is Access Modifier in Java?

1.Access modifiers control the visibility (or accessibility) of classes, methods, and variables in Java.
2.They define who can access what — inside or outside a class, package, or subclass.

define how the members of a class, like variables, methods, and even the class itself, can be accessed from other parts of our program
Access modifiers control the visibility of classes, methods, and variables. Types: • public:
The public access modifier is specified using the keyword public.
Public members are accessible from everywhere in the program.
The member is accessible from any other class.
Typical Use-Common for APIs or utility classes

class Vehicle {
public int speed; // public member
}

• protected:
1.The member is accessible within its own package and by subclasses.
2.The protected access modifier is specified using the keyword protected.

The methods or data members declared as protected are accessible within the same package or subclasses in different packages.

class Vehicle {
protected int speed; // protected member
}
• default (no keyword): The member is accessible only within its own package.

When no access modifier is specified for a class, method, or data member, it is said to have the default access modifier by default.
This means only classes within the same package can access it.
Members with default access cannot be accessed from classes in a different package.

• private: The member is accessible only within its own class.

The private access modifier is specified using the keyword private.
The methods or data members declared as private are accessible only within the class in which they are declared.

class Person {

// private variable
private String name;

public void setName(String name)  {

    this.name = name; // accessible within class
}

Switch case

Murali Rajendran — Sat, 11 Oct 2025 14:45:36 +0000

it is used since java version 1.0.
These are the primitive data types not supported in switch.

1.long
2.float
3.double
4.boolean

it does not accept duplicate case.

These are the primitive data types supported in switch.

1.int
2.char
3.short
4.byte

@ switch case used minimal code using arrow version 14 and above this .when we use arrow no need to use break .

arrow symbol

int tamil = 50;
switch(tamil)//Expression
{
case 50 -> System.out.println("A Grade");
case 60 -> System.out.println("b Grade");
case 100 -> System.out.println("O Grade");
default -> System.out.println("No Grade");
};

Switch case in Java

Murali Rajendran — Sat, 11 Oct 2025 14:36:30 +0000

It is used to check some valid expression like Traffic light real world example.

SYNTAX:

String day="laundry";
switch(day)
{
case "hr":
System.out.println("hr department");
break;
case "laundry":
System.out.println("laundry department");
break;
case "laundry1":
System.out.println("laundry department");
case "front office":
System.out.println("front king department");
default:
System.out.println("hi welcome");

Java Translator

Murali Rajendran — Sat, 11 Oct 2025 14:29:06 +0000

These are Java major Role play.
JDK-->JRE-->JVM-->JIT

*when compile the java code if no error JDK will create a .class file (byte code)then pass to JRE it create environment for run the code .Then JVM manage garbage and memory management. Finally JIT convert byte code into BInary code.

JDK-platform independent.
JRE-platform dependent.

Data Types

Murali Rajendran — Sat, 11 Oct 2025 14:19:37 +0000

Types
1.Primitive data types-Primitive data types store value to Stack in RAM.
2.Non- Primitive data types- store value to Heap in RAM.
Primitive data types:
1.int
2.char
3.byte
4.short
5.long
6.double
7.boolean
8.float
Good Developers must know how to use data type in efficient way to manage memory allocation.