Why object-oriented programming is used in Java - Why It Works This Way

Overview - Why object-oriented programming is used

What is it?

Object-oriented programming (OOP) is a way to write software by organizing code into objects. Each object represents a thing or concept with its own data and actions it can perform. This approach helps programmers model real-world ideas in code more naturally. It uses ideas like classes, objects, inheritance, and methods to build programs.

Why it matters

OOP exists to make complex software easier to build, understand, and maintain. Without it, programs would be long lists of instructions that are hard to change or reuse. OOP helps break problems into smaller pieces, making teamwork and updates simpler. It also helps prevent bugs by keeping data and actions bundled together.

Where it fits

Before learning OOP, you should understand basic programming concepts like variables, data types, and functions. After OOP, learners often explore design patterns, software architecture, and advanced Java features like interfaces and generics.

Mental Model

Core Idea

OOP organizes code by bundling data and related actions into objects that model real-world things, making programs easier to build and change.

Think of it like...

Think of OOP like building with LEGO blocks, where each block is a self-contained piece with its own shape and function. You can combine blocks to build complex structures, and if you want to change something, you swap or modify just the blocks involved.

┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│   Class       │      │   Object      │      │  Interaction  │
│ (Blueprint)   │─────▶│ (Instance)    │─────▶│  Methods call │
│ - Attributes  │      │ - Data        │      │  between objs │
│ - Methods     │      │ - Behaviors   │      │               │
└───────────────┘      └───────────────┘      └───────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding Classes and Objects

Concept: Introduce the basic building blocks of OOP: classes as blueprints and objects as instances.

In Java, a class defines a template with variables (attributes) and functions (methods). An object is created from a class and holds actual data. For example, a class 'Car' might have attributes like color and speed, and methods like drive(). Creating an object 'myCar' from 'Car' lets you use these features.

Result

You can create multiple objects from one class, each with its own data but sharing the same structure and behavior.

Understanding that classes are blueprints and objects are real examples helps you see how OOP models real-world things in code.

2

Foundation

Encapsulation: Bundling Data and Actions

Concept: Show how OOP keeps data and methods together and controls access to data.

Encapsulation means putting variables and methods inside a class and hiding the details from outside code. In Java, you use 'private' to hide data and 'public' methods to access or change it safely. This protects data from accidental changes and keeps code organized.

Result

Data is safe inside objects, and other parts of the program interact only through defined methods.

Knowing encapsulation prevents bugs by controlling how data is accessed and changed.

3

Intermediate

Inheritance: Reusing and Extending Code

🤔Before reading on: do you think inheritance copies all code from one class to another, or just shares some features? Commit to your answer.

Concept: Inheritance lets a new class use features from an existing class and add or change them.

In Java, a class can inherit from another using 'extends'. For example, 'ElectricCar' can inherit from 'Car' and add battery features. This avoids rewriting code and helps organize related classes in a hierarchy.

Result

You create specialized classes that reuse common code and add unique features.

Understanding inheritance saves time and keeps code DRY (Don't Repeat Yourself), making programs easier to maintain.

4

Intermediate

Polymorphism: One Interface, Many Forms

🤔Before reading on: do you think polymorphism means objects change their type at runtime, or that they can be treated as their parent type? Commit to your answer.

Concept: Polymorphism allows objects of different classes to be treated as objects of a common parent class, enabling flexible code.

In Java, you can write methods that accept a parent class type but work with any subclass object. For example, a method that takes 'Car' can accept 'ElectricCar' or 'GasCar'. The actual method called depends on the object's real type at runtime.

Result

Code can work with different objects through a common interface, making it more flexible and extensible.

Knowing polymorphism lets you write code that adapts to new types without changing existing code.

5

Advanced

Why OOP Improves Software Maintenance

🤔Before reading on: do you think OOP makes changing software easier because it isolates changes, or because it makes code longer? Commit to your answer.

Concept: OOP structures code so changes affect only small parts, reducing bugs and effort.

Because data and behavior are grouped in objects, changing one part usually means updating only that class. Inheritance and polymorphism let you add new features without rewriting old code. Encapsulation hides details, so internal changes don't break other parts.

Result

Software becomes easier to update, fix, and extend over time.

Understanding how OOP isolates changes explains why large software projects rely on it for long-term success.

6

Expert

Common OOP Pitfalls and Design Tradeoffs

🤔Before reading on: do you think using too many classes always improves code, or can it sometimes make it harder to understand? Commit to your answer.

Concept: OOP can lead to overly complex designs if not used carefully, and understanding tradeoffs is key.

Creating too many small classes or deep inheritance trees can confuse developers and slow performance. Sometimes simpler procedural code is better. Experts balance OOP principles with practical needs, using design patterns and principles like SOLID to guide structure.

Result

You learn when to apply OOP and when to choose simpler approaches for clarity and efficiency.

Knowing OOP's limits and tradeoffs helps avoid over-engineering and keeps software maintainable.

Under the Hood

At runtime, Java uses objects as blocks of memory holding data and references to methods. The JVM manages these objects, their lifecycles, and method calls. Inheritance is implemented by linking classes in a hierarchy, allowing method calls to resolve dynamically based on the actual object's class. Encapsulation is enforced by access modifiers checked at compile time and runtime.

Why designed this way?

OOP was designed to mirror how humans think about the world: as objects with properties and behaviors. Early programming was hard to manage as programs grew, so OOP introduced structure and reuse. Java adopted OOP to improve code clarity, reuse, and safety, balancing performance with flexibility.

┌───────────────┐
│   JVM Heap    │
│ ┌───────────┐ │
│ │ Object A  │ │
│ │ - data    │ │
│ │ - methods │ │
│ └───────────┘ │
│       ▲       │
│       │       │
│ ┌───────────┐ │
│ │ Object B  │ │
│ │ - data    │ │
│ │ - methods │ │
│ └───────────┘ │
└───────────────┘

Method calls resolve at runtime based on object type.

Myth Busters - 4 Common Misconceptions

Quick: Does inheritance mean copying all code from parent to child class? Commit to yes or no.

Common Belief: Inheritance copies all code from the parent class into the child class.

Reality: Inheritance creates a link between classes; the child class reuses the parent's code without copying it, allowing dynamic method resolution.

Why it matters: Believing inheritance copies code can lead to misunderstanding memory use and bugs when overriding methods.

Quick: Is polymorphism about objects changing their type at runtime? Commit to yes or no.

Common Belief: Polymorphism means objects change their type during program execution.

Reality: Polymorphism means treating objects as their parent type, while the actual method called depends on the object's real class, not changing the object's type.

Why it matters: Misunderstanding polymorphism can cause confusion about how method calls work and lead to incorrect code assumptions.

Quick: Does encapsulation mean hiding all data from outside code? Commit to yes or no.

Common Belief: Encapsulation means making all data private and inaccessible outside the class.

Reality: Encapsulation means controlling access to data, usually via public methods, not hiding data completely; some data must be accessible safely.

Why it matters: Thinking data must be fully hidden can lead to overly restrictive designs that are hard to use or extend.

Quick: Does using many small classes always make code better? Commit to yes or no.

Common Belief: More classes always mean better organized and clearer code.

Reality: Too many small classes or deep inheritance can make code complex and hard to understand.

Why it matters: Overusing OOP can cause confusion and maintenance problems, defeating its purpose.

Expert Zone

1

Inheritance can cause tight coupling, making changes ripple through the class hierarchy unexpectedly.

2

Polymorphism relies on dynamic method dispatch, which can impact performance and debugging complexity.

3

Encapsulation is not just about hiding data but about defining clear interfaces that evolve independently.

When NOT to use

OOP is not ideal for simple scripts or performance-critical code where procedural or functional styles are clearer and faster. Alternatives include functional programming for stateless logic or procedural code for straightforward tasks.

Production Patterns

In real-world Java projects, OOP is combined with design patterns like Factory, Singleton, and Observer to solve common problems. Large systems use layered architectures where OOP helps separate concerns and manage complexity.

Connections

Functional Programming

Contrasting paradigm emphasizing stateless functions over objects

Understanding OOP's focus on state and behavior helps appreciate functional programming's benefits in immutability and simpler reasoning.

Human Cognitive Models

OOP mirrors how humans categorize and interact with the world

Knowing that OOP reflects natural human thinking explains why it feels intuitive and helps design software that matches real-world concepts.

Modular Design in Engineering

Both break complex systems into manageable, reusable parts

Seeing OOP as modular design connects software to physical engineering, highlighting the importance of clear interfaces and encapsulation.

Common Pitfalls

#1 Creating deep inheritance trees that are hard to understand and maintain.

Wrong approach:

class Animal {}
class Mammal extends Animal {}
class Dog extends Mammal {}
class Puppy extends Dog {}
class BabyPuppy extends Puppy {}

Correct approach:

Use composition or interfaces instead of deep inheritance:
class Animal {}
interface Pet {}
class Dog extends Animal implements Pet {}

Root cause:

Misunderstanding inheritance leads to overusing it for code reuse instead of simpler alternatives.

#2 Exposing internal data directly instead of using methods.

Wrong approach:

public class Car {
public int speed;
}

Correct approach:

public class Car {
private int speed;
public int getSpeed() { return speed; }
public void setSpeed(int s) { speed = s; }
}

Root cause:

Not applying encapsulation principles causes unsafe data access and bugs.

#3 Assuming polymorphism means changing an object's class at runtime.

Wrong approach:

Car myCar = new Car();
myCar = new ElectricCar(); // thinking this changes the object type dynamically

Correct approach:

Car myCar = new ElectricCar(); // object is created as ElectricCar from start

Root cause:

Confusing polymorphism with dynamic type mutation rather than subtype substitution.

Key Takeaways

Object-oriented programming organizes code into objects that combine data and behavior, making software easier to understand and maintain.

Encapsulation protects data by controlling access through methods, preventing accidental misuse.

Inheritance and polymorphism enable code reuse and flexibility by allowing classes to share and override behavior.

OOP improves software maintenance by isolating changes and supporting extensibility, but overusing it can cause complexity.

Knowing when and how to apply OOP principles is key to writing clear, efficient, and scalable Java programs.