DEV Community: Srivalli Yaarlagadda

OOP (Object-Oriented Programming).

Srivalli Yaarlagadda — Tue, 11 Aug 2026 08:34:19 +0000

We’ll learn it in the correct order because the concepts depend on each other:

Java OOP
│
├── 1. Class
├── 2. Object
├── 3. Constructor
├── 4. this keyword
├── 5. Instance vs static
├── 6. Encapsulation
├── 7. Inheritance
├── 8. Polymorphism
└── 9. Abstraction

Class Definition

A class is a blueprint/template that defines the properties and behaviors that objects can have.

A class itself is not usually the actual thing. It describes what an object should contain and do.

Real-time example

Think about a Car.

A car has:

Properties:

color
brand
speed
model

Behaviors:

start()
stop()
accelerate()
brake()

We can represent that with a Java class:

class Car {

String color;
String brand;
int speed;

void start() {
    System.out.println("Car started");
}

void stop() {
    System.out.println("Car stopped");
}

void accelerate() {
    speed += 10;
    System.out.println("Speed: " + speed);
}

}

Here:

Car
│
├── Properties
│ ├── color
│ ├── brand
│ └── speed
│
└── Behaviors
├── start()
├── stop()
└── accelerate()

The class is basically a design/template.

Object Definition

An object is an actual instance of a class.

This distinction is extremely important:

Class → Blueprint
Object → Actual thing created from blueprint
Real-time example

Think about a building blueprint.

Blueprint
↓
HOUSE

From that blueprint, you can build multiple houses:

     HOUSE BLUEPRINT
            ↓
   ┌────────┼────────┐
   ↓        ↓        ↓
House A  House B  House C

Similarly:

Car car1 = new Car();
Car car2 = new Car();
Car car3 = new Car();

Here:

Car
↓
Class

car1
car2
car3
↓
Objects

Each object can have its own values.

car1.color = "Red";
car1.brand = "Toyota";

car2.color = "Blue";
car2.brand = "BMW";

Now:

car1
┌────────────────┐
│ color = Red │
│ brand = Toyota │
└────────────────┘

car2
┌────────────────┐
│ color = Blue │
│ brand = BMW │
└────────────────┘

Both are Car objects, but their data is different.

What does new mean?

You will see this constantly in Java:

Car car = new Car();

The important part is:

new Car()

It creates a new object of the Car class.

Conceptually:

Car class
↓
new Car()
↓
Object created
↓
car reference

So:

Car car = new Car();

means:

Create a new Car object and store a reference to it in car.

Calling object methods

Once you have an object:

Car car = new Car();

you can access its properties and methods using:

called the dot operator.

Example:

car.color = "Red";

car.start();
car.accelerate();

The flow is:

car
↓
.
↓
start()

or:

car
↓
.
↓
color

Complete example
class Car {

String color;
String brand;
int speed;

void start() {
System.out.println("Car started");
}

void accelerate() {
speed += 10;
System.out.println("Speed: " + speed);
}
}

public class Main {

public static void main(String[] args) {

    Car car = new Car();

    car.color = "Red";
    car.brand = "Toyota";

    System.out.println(car.color);
    System.out.println(car.brand);

    car.start();

    car.accelerate();
    car.accelerate();
}

}

Output:

Red
Toyota
Car started
Speed: 10
Speed: 20

Constructor

Now we come to another very important concept.

Definition

A constructor is a special member of a class that is automatically called when an object is created.

Example:

Car car = new Car();

When new Car() executes, Java calls the constructor.

Why do we need constructors?

Suppose you have:

Car car = new Car();

car.color = "Red";
car.brand = "Toyota";
car.speed = 0;

That's repetitive.

Instead, we can initialize the object when creating it.

Car car = new Car("Red", "Toyota");

Create the constructor:

class Car {

String color;
String brand;

Car(String color, String brand) {
    this.color = color;
    this.brand = brand;
}

}

Now:

Car car = new Car("Red", "Toyota");

creates an object that is already initialized.

Constructor rules

A constructor:

Has the same name as the class
class Car {

Car() {

}

}

Class:

Car

Constructor:

Car()
Has no return type

Correct:

Car() {

}

Incorrect:

void Car() {

}

The second one is actually a method, not a constructor.

Real-time constructor example

Imagine creating users in an application.

Without a constructor:

User user = new User();

user.name = "John";
user.email = "john@gmail.com";
user.age = 25;

With a constructor:

User user = new User(
"John",
"john@gmail.com",
25
);

Class:

class User {

String name;
String email;
int age;

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

}

This is much closer to how you'll see objects initialized in real Java applications.

The this keyword

This is another important concept.

Look at:

class User {

String name;

User(String name) {
    this.name = name;
}

}

We have two names:

name
↓
constructor parameter

this.name
↓
object's variable

So:

this.name = name;

means:

Assign the constructor parameter name to the current object's name property.

Real-time analogy

Imagine two labels:

Object's name
↓
this.name

Incoming value
↓
name

So:

this.name = name;

means:

object's name ← incoming name

Why is this called "current object"?

Suppose:

User user1 = new User("Alice");
User user2 = new User("Bob");

When constructing user1:

this → user1

When constructing user2:

this → user2

So this always means:

The current object whose method or constructor is executing.

Instance variables

Consider:

class Student {

String name;
int age;

}

name and age belong to each individual object.

Student s1 = new Student();
Student s2 = new Student();

s1.name = "Alice";
s2.name = "Bob";

Memory conceptually looks like:

s1
┌─────────────┐
│ name=Alice │
│ age=0 │
└─────────────┘

s2
┌─────────────┐
│ name=Bob │
│ age=0 │
└─────────────┘

These are called instance variables because every object gets its own instance data.

static

Now something different.

Suppose every Student belongs to the same school.

You don't want every object to maintain a separate copy of:

schoolName

Instead:

class Student {

String name;

static String schoolName = "ABC School";

}

Now:

Student s1 = new Student();
Student s2 = new Student();

s1.name = "Alice";
s2.name = "Bob";

Both share:

schoolName = ABC School

Conceptually:

         Student class
              │
      schoolName = ABC
              │
      ┌───────┴───────┐
      ↓               ↓
    s1              s2
  Alice             Bob

Instance vs Static

This distinction is important for interviews and real Java development.

Instance

Belongs to an object.

String name;

Access:

student.name
Static

Belongs to the class.

static String schoolName;

Access:

Student.schoolName

Easy way to remember:

instance → each object has its own copy

static → shared at class level

Static method

You can also have static methods.

class MathUtil {

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

}

You don't need to create an object:

int result = MathUtil.add(10, 20);

Instead of:

MathUtil obj = new MathUtil();
obj.add(...);

This is useful for utility-type operations.

Now the actual OOP pillars

Once you understand:

Class
Object
Constructor
this
Instance
static

you're ready for the four major OOP concepts.

         OOP
          │
┌─────────┼─────────┐
↓         ↓         ↓

Encapsulation Inheritance Polymorphism
│
Abstraction

The next concept is Encapsulation.

Encapsulation Definition

Encapsulation is the practice of bundling data and the methods that operate on that data inside a class, while controlling direct access to the data.

The key idea is:

Don't allow outside code to freely modify important internal data.

Bad example

Imagine a bank account:

class BankAccount {

double balance;

}

Then anyone can do:

account.balance = -500000;

That's dangerous.

You don't want outside code directly changing the balance.

Encapsulation using private

Instead:

class BankAccount {

private double balance;

}

Now this won't be allowed from outside:

account.balance = 5000;

because balance is private.

Instead, provide controlled methods:

class BankAccount {

private double balance;

public void deposit(double amount) {

    if (amount > 0) {
        balance += amount;
    }
}

public double getBalance() {
    return balance;
}

}

Now:

BankAccount account = new BankAccount();

account.deposit(5000);

System.out.println(account.getBalance());

Output:

5000.0

Real-time example — Bank ATM

Think about an ATM.

You don't directly access the bank's database and do:

balance = 100000

Instead, you interact through controlled operations:

ATM
│
├── deposit()
├── withdraw()
└── checkBalance()

The actual balance is protected internally.

That's the basic idea of encapsulation.

Outside world
│
▼
┌─────────────────────┐
│ BankAccount │
│ │
│ private balance │
│ │
│ deposit() │
│ withdraw() │
│ getBalance() │
└─────────────────────┘

Why encapsulation matters in backend development

You'll use this concept constantly when building Java backend applications.

For example:

class User {

private String password;

public void setPassword(String password) {
    // validation / hashing
}

public boolean verifyPassword(String password) {
    // verification
}

}

You don't want code throughout your application freely manipulating sensitive internal state.

This becomes especially important when you later learn:

Java
↓
Spring Boot
↓
REST APIs
↓
Services
↓
Repositories
↓
Database

Java Fundamentals — Part 1

Srivalli Yaarlagadda — Tue, 11 Aug 2026 04:58:54 +0000

**1. What is Java?
**Definition

Java is a high-level, object-oriented, class-based programming language designed to be portable across different operating systems.

Java was originally developed at Sun Microsystems and is now maintained by Oracle and the broader Java community.

The famous idea associated with Java is:

Write Once, Run Anywhere.

For example, you can write:

System.out.println("Hello Java");

and compile it into Java bytecode.

That bytecode can run on different operating systems as long as the appropriate JVM is available.

*2. Why is Java called platform-independent?
*
Suppose you write a Java program on Windows:

Java Code
↓
Java Compiler
↓
Bytecode
↓
.class file

That .class file can then run through a JVM on:

Windows
Linux
macOS

The flow is:

         Java Code
             │
             ▼
       Java Compiler
             │
             ▼
         Bytecode
             │
   ┌─────────┼─────────┐
   ▼         ▼         ▼
Windows    Linux      macOS
  JVM        JVM        JVM

That's the basic reason Java is considered platform-independent.

*3. JDK vs JRE vs JVM
*
This is one of the most important Java fundamentals.

People often confuse these three.

JVM
Definition

JVM (Java Virtual Machine) is the runtime environment that executes Java bytecode.

Think:

.class file
↓
JVM
↓
Program runs

The JVM is responsible for things such as:

executing bytecode
memory management
garbage collection
runtime checks
**4. JRE
**Definition

JRE (Java Runtime Environment) provides the environment required to run Java applications.

Conceptually:

JRE
│
├── JVM
└── Java runtime libraries

So:

JRE = JVM + libraries needed to run Java applications

**5. JDK
**Definition

JDK (Java Development Kit) provides the tools required to develop Java applications.

Conceptually:

JDK
│
├── JRE
│ └── JVM
│
└── Development tools
├── javac
├── java
├── javadoc
└── other tools

So the easy relationship is:

JDK
↓
JRE
↓
JVM
Easy memory trick
JDK → Develop
JRE → Run
JVM → Execute

Your first Java program

Create:

HelloWorld.java

Write:

public class HelloWorld {

public static void main(String[] args) {

    System.out.println("Hello Java");

}

}

Output:

Hello Java

Now let's understand every single part.

**7. public
**public class HelloWorld

public is an access modifier.

It means that the class can be accessed from outside its package.

Don't worry about packages yet. We'll cover them later.

For now remember:

public → accessible from other classes
**8. class
**class HelloWorld

A class is a blueprint/template for creating objects.

For example:

Car

could be a class.

It can describe:

Properties:
color
model
speed

Behavior:
start()
stop()
accelerate()

We'll go deeply into classes when we reach OOP.

**9. HelloWorld
**class HelloWorld

This is the class name.

Java convention:

ClassName

uses PascalCase.

Examples:

Student
Employee
BankAccount
PaymentService
UserController
*10. main()
*
This is extremely important.

public static void main(String[] args)

The main() method is the entry point of a traditional Java application.

When the JVM starts your application, it looks for the appropriate main method.

Think:

Program starts
↓
main()
↓
Rest of your code executes
**11. System.out.println()
**System.out.println("Hello Java");

This prints text to the console.

For example:

System.out.println("Hello");
System.out.println("Welcome");
System.out.println(100);

Output:

Hello
Welcome
100
*12. Java Variables
*
Now we get into actual programming.

Definition

A variable is a named memory location used to store a value.

Example:

int age = 25;

Think of it like a labelled box:

┌───────────────┐
│ age │
│ │
│ 25 │
└───────────────┘

Here:

int → data type
age → variable name
25 → value
*13. Data Types
*
Java has two broad categories:

Data Types
│
├── Primitive
│
└── Reference
*14. Primitive Data Types
*
Java has 8 primitive data types:

byte
short
int
long
float
double
char
boolean

These are fundamental built-in types.

int

Used for whole numbers.

int age = 25;

Examples:

int count = 100;
int salary = 50000;
int marks = 85;
double

Used for decimal numbers.

double price = 99.99;

Example:

double temperature = 36.5;
char

Stores a single character.

char grade = 'A';

Notice:

'A'

uses single quotes.

boolean

Stores:

true
false

Example:

boolean isLoggedIn = true;

This is extremely common in real applications.

For example:

boolean isAdmin = false;
*15. Reference Types
*
Reference types can refer to objects.

Examples:

String name = "Srivalli";
int[] numbers = {10, 20, 30};
Student student = new Student();

We'll learn objects and references properly when we reach OOP.

*16. Operators
*
Operators allow you to perform operations.

Arithmetic operators

+

*
/
%

Example:

int a = 10;
int b = 3;

System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
System.out.println(a % b);

Output:

13
7
30
3
1

Notice:

10 / 3

with two integers gives:

not 3.333....

*17. Comparison Operators
*
Used to compare values.

<

<=

!=

Example:

int age = 25;

System.out.println(age >= 18);

Output:

true
*18. Logical Operators
*
The main ones are:

&& AND
|| OR
! NOT

Example:

int age = 25;
boolean hasId = true;

if (age >= 18 && hasId) {
System.out.println("Allowed");
}

Both conditions must be true.

*19. Conditional Statements
*
Now Java can make decisions.

if
int age = 20;

if (age >= 18) {
System.out.println("Adult");
}

Flow:

age >= 18?
│
┌──┴──┐
YES NO
│ │
▼ ▼
Adult Nothing
**20. if-else
**int age = 16;

if (age >= 18) {
System.out.println("Adult");
} else {
System.out.println("Minor");
}

Output:

Minor
*21. Real-world example
*
Imagine login:

boolean loggedIn = true;

if (loggedIn) {
System.out.println("Show dashboard");
} else {
System.out.println("Show login page");
}

This is exactly the type of logic you'll eventually use in backend development.

For example:

User request
↓
Is authenticated?
↓
YES ───→ Dashboard/API response
NO ───→ Unauthorized
*22. Loops
*
Loops repeat code.

Suppose you want:

Hello
Hello
Hello
Hello
Hello

Instead of:

System.out.println("Hello");
System.out.println("Hello");
System.out.println("Hello");
System.out.println("Hello");
System.out.println("Hello");

use a loop.

**23. for loop
**for (int i = 0; i < 5; i++) {
System.out.println("Hello");
}

Flow:

i = 0
↓
condition?
↓
true
↓
print
↓
i++
↓
condition?
↓
...
↓
i = 5
↓
false
↓
STOP

Output:

Hello
Hello
Hello
Hello
Hello
*24. Real-time example — Display users
*
Suppose:

String[] users = {
"Alice",
"Bob",
"Charlie"
};

You can loop:

for (int i = 0; i < users.length; i++) {
System.out.println(users[i]);
}

Output:

Alice
Bob
Charlie

This becomes very useful when working with collections and database results.

**25. Arrays
**Definition

An array is a fixed-size collection of elements of the same type.

Example:

int[] marks = {80, 90, 75, 88};

Visual:

Index: 0 1 2 3
↓ ↓ ↓ ↓
┌────┬────┬────┬────┐
marks = │ 80 │ 90 │ 75 │ 88 │
└────┴────┴────┴────┘

Important:

Java array indexes start at 0.

So:

marks[0] → 80
marks[1] → 90
marks[2] → 75
marks[3] → 88

Methods Definition

A method is a block of code that performs a specific task and can be called when needed.

Example:

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

Call it:

greet();

Output:

Hello!

Methods with parameters static void greet(String name) { System.out.println("Hello " + name); }

Call:

greet("Srivalli");

Output:

Hello Srivalli

Here:

name

is the parameter.

**28. Methods with return values
**static int add(int a, int b) {
return a + b;
}

Use:

int result = add(10, 20);

System.out.println(result);

Output:

Flow:

10 + 20
↓
add()
↓
return 30
↓
result
*29. The foundation of Java OOP
*
Everything we've covered so far prepares you for the biggest part of Java:

Object-Oriented Programming

The four major OOP concepts are:

OOP
│
├── Encapsulation
├── Inheritance
├── Polymorphism
└── Abstraction

But before these four, you need to understand:

Class
Object
Constructor

For example:

class Car {

String color;
int speed;

void drive() {
    System.out.println("Car is driving");
}

}

Create an object:

Car car = new Car();

Now:

Class
↓
Car
↓
Blueprint

Object
↓
car
↓
Actual instance

You can then do:

car.color = "Red";
car.speed = 100;

car.drive();