DEV Community: Rifat Khan

Object-Oriented Programming in Java: An Academic Perspective

Rifat Khan — Sun, 31 Aug 2025 00:45:28 +0000

This article presents a comprehensive overview of the principal concepts of Object-Oriented Programming (OOP) in Java. The treatment is designed for academic study, combining theoretical foundations with practical examples to provide a well-rounded understanding. Each section introduces a concept, outlines its syntax, highlights its significance, and offers illustrative code samples.

Introduction to OOP in Java
Constructor and Method Overloading
Method Overriding
Inheritance
Access Modifiers
Returning Objects from Methods
The super Keyword
The this Keyword
The static Keyword
The final Keyword
Dynamic Method Dispatch
Abstract Classes
Interfaces
Summary of Keywords
Which Topic belongs to which Components of OOP?
Best Practices
Exercises for Students
Conclusion

Introduction to OOP in Java

Java was designed with Object-Oriented Programming (OOP) principles at its core. OOP allows developers to model real-world systems through objects, which encapsulate both state (attributes) and behavior (methods). The four fundamental principles of OOP are:

Encapsulation: Grouping data and related behavior while restricting external access.
Abstraction: Exposing essential features while concealing implementation details.
Inheritance: Allowing a new class to acquire the properties and behavior of an existing class.
Polymorphism: Supporting multiple forms of behavior through method overloading and overriding.

✅ Summary Table

OOP Component	Topics Covered
Inheritance	Inheritance, `super`
Polymorphism	Method Overriding, Dynamic Method Dispatch, Constructors & Method Overloading
Encapsulation	Access Modifiers, `this` (indirectly)
Abstraction	Abstract Classes & Interfaces, Returning Objects from Methods

Constructor and Method Overloading

Overloading refers to defining multiple constructors or methods with the same name but different parameter lists. Overloading is resolved at compile time.

Syntax Example

class Student {
    String name;
    int age;

    // Constructor overloading
    Student() { this("Unknown", 0); }
    Student(String name) { this(name, 18); }
    Student(String name, int age) { this.name = name; this.age = age; }

    // Method overloading
    void showInfo() { System.out.println(name + " - " + age); }
    void showInfo(String prefix) { System.out.println(prefix + ": " + name + " - " + age); }
}

Academic Note

Overloading is an example of compile-time polymorphism. It provides flexibility by allowing different parameterizations of methods or constructors.

Method Overriding

Overriding occurs when a subclass provides its own implementation for a method already defined in the superclass. Resolution occurs at runtime.

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

Academic Note

Overriding exemplifies runtime polymorphism, which enables dynamic behavior adjustment.

Inheritance

Inheritance allows classes to reuse fields and methods from other classes using the extends keyword.

class Person {
    String name;
    void greet() { System.out.println("Hello, I am " + name); }
}
class Employee extends Person {
    int salary;
}

Academic Note

Inheritance should represent a true “is-a” relationship. Excessive inheritance hierarchies are discouraged due to maintenance challenges.

Access Modifiers

Access specifiers in Java control the visibility of classes, methods, and variables. There are four types:

Specifier	Scope / Visibility	Syntax Example
`private`	Same class only	`private int age;`
default (no modifier)	Same package only	`int age;`
`protected`	Same package + subclasses	`protected int age;`
`public`	Everywhere (any class)	`public int age;`

Concepts

Private: For encapsulation; restricts access to within the class.
Default: For package-level access; no keyword needed.
Protected: For inheritance; accessible in subclasses and same package.
Public: For global access; accessible from anywhere.

Syntax Examples

class Example {
    private int privateVar;       // accessible only in Example class
    int defaultVar;               // accessible in the same package
    protected int protectedVar;   // accessible in package & subclasses
    public int publicVar;         // accessible everywhere

    public void display() {
        System.out.println(privateVar + " " + defaultVar + " " + protectedVar + " " + publicVar);
    }
}

Returning Objects from Methods

Java methods can return objects, allowing construction of new instances within methods.

class Box {
    int length;
    Box(int length) { this.length = length; }
    Box duplicate() { return new Box(this.length); }
}

The `super` Keyword

super refers to the immediate parent class. It is used to:

Invoke parent constructors.
Access parent methods and variables.

class Parent {
    int num = 100;
    void show() { System.out.println("Parent method"); }
}
class Child extends Parent {
    @Override
    void show() {
        super.show();
        System.out.println("Child method, Parent num = " + super.num);
    }
}

The `this` Keyword

this refers to the current object instance.

class Example {
    int x;
    Example(int x) { this.x = x; }
    void display() { System.out.println("Value: " + this.x); }
}

The `static` Keyword

Static members belong to the class rather than an instance.

class Counter {
    static int count = 0;
    Counter() { count++; }
}

Academic Note

Static methods and variables should be used judiciously, as they compromise object-oriented design by introducing global state.

The `final` Keyword

The final keyword prevents modification or extension.

Final variables: cannot be reassigned.
Final methods: cannot be overridden.
Final classes: cannot be inherited.

final class Vehicle {
    final int speedLimit = 100;
    final void displayLimit() { System.out.println("Speed limit: " + speedLimit); }
}

Dynamic Method Dispatch

Dynamic method dispatch resolves overridden methods at runtime.

class A { void show() { System.out.println("A.show"); } }
class B extends A { @Override void show() { System.out.println("B.show"); } }

A ref = new B();
ref.show(); // B.show

Abstract Classes

Abstract classes cannot be instantiated. They may contain both abstract methods (without implementations) and concrete methods.

abstract class Shape {
    abstract double area();
    void describe() { System.out.println("I am a shape"); }
}
class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
}

Interfaces

An interface specifies a contract that a class must implement.

interface Drawable { void draw(); }
class Rectangle implements Drawable {
    public void draw() { System.out.println("Drawing Rectangle"); }
}

Summary of Keywords

Keyword	Primary Function
`this`	Refers to the current object instance.
`super`	Refers to the immediate superclass.
`static`	Defines class-level members.
`final`	Declares constants, immutable methods, and non-inheritable classes.
`abstract`	Declares abstract classes and methods.
`interface`	Declares a contract of methods to be implemented.

Which Topic belongs to which Components of OOP?

1️⃣ Inheritance

Inheritance is about reusing code from parent classes in child classes.

Inheritance ✅ (obviously)
The super keyword ✅ (used to access parent class properties/methods)

2️⃣ Polymorphism

Polymorphism is about one interface, many forms, i.e., the same method behaving differently.

Method Overriding ✅ (runtime polymorphism)
Dynamic Method Dispatch ✅ (runtime method selection, core of polymorphism)
Constructors & Method Overloading ✅ (compile-time polymorphism, also called static polymorphism)

3️⃣ Encapsulation

Encapsulation is about hiding internal data and providing controlled access.

The this keyword ✅ (helps in distinguishing instance variables, indirectly supports encapsulation)
Access Modifiers ✅ (access modifiers like private/public, which are classic examples of encapsulation)
The static keyword ❌ (not directly part of encapsulation, more about class-level variables)
The final keyword ❌ (more about immutability)

4️⃣ Abstraction

Abstraction is about hiding implementation details and showing only functionality.

Abstract Classes & Interfaces ✅ (core of abstraction)
Returning Objects from Methods ✅ (can be used to abstract internal implementation by returning objects instead of exposing fields)

Best Practices

Prefer composition over inheritance for flexibility.
Keep fields private; expose behavior through methods.
Avoid excessive reliance on static members.
Use @Override annotations for clarity and safety.

Exercises for Students

Implement a Logger class with overloaded methods for different input types.
Create a base class Payment and subclasses CardPayment and MobilePayment. Demonstrate overriding and dynamic method dispatch.
Define an abstract class Storage and an interface KeyValueStore. Implement InMemoryStore to combine both.

Conclusion

Object-Oriented Programming in Java provides a robust framework for structuring programs in a modular and maintainable manner. Through the concepts of encapsulation, abstraction, inheritance, and polymorphism, developers can model complex systems effectively. Mastery of keywords such as this, super, static, final, and constructs such as abstract classes and interfaces, is crucial for academic and professional proficiency in Java programming.

Feel free to stay connected on LinkedIn ^_^

Inheritance with access-specifier in cpp

Rifat Khan — Thu, 18 Jan 2024 04:42:23 +0000

When inheriting from a base class, the choice of access specifier determines how the members of the base class will be inherited and what their access level will be in the derived class. The syntax for inheritance is as follows:

class ChildClass : [access-specifier] ParentClass {
    // ...code...
};

Let's dive into the lines of codes:

class Parent
{
private:
    int pvt = 12;

protected:
    int prot = 42; // A protected member of the Base class

public:
    int pub = 16;
};

class Child1 : public Parent
{
public:
    int getProt()
    {
        return prot;
    }
};

class Child2 : protected Parent
{
public:
    int getProt()
    {
        return prot;
    }
};

class Child3 : private Parent
{
public:
    int getProt()
    {
        return prot;
    }
};

As you can see we have made three different children of the same parent class namely Parent. Now, the question is :

What are the differences between these classes though they contain the exactly same lines of code inside them?

In the provided code, there are three classes: Child1, Child2, and Child3, each inheriting from the Parent class with different access specifiers. The access specifiers (public, protected, and private) determine the visibility of the base class members in the derived class. Let's explore the differences between these classes:

Child1: Public Inheritance

class Child1 : public Parent
{
public:
    int getProt()
    {
        return prot;
    }
};

In this case, Child1 publicly inherits from Parent. The protected member_ prot_ of the Parent class is accessible in Child1 through its public member function getProt(). Objects of Child1 can access the protected member directly.

Usage example:

Child1 child1Obj;
int value = child1Obj.getProt(); // This is valid because getProt() is a public member function.

Child2: Protected Inheritance

class Child2 : protected Parent
{
public:
    int getProt()
    {
        return prot;
    }
};

In this case, Child2 inherits from Parent with a protected specifier. This means that the protected and public members of the Parent class become protected members in_ Child2_. Outside the Child2 class, the protected members are not accessible.

Usage example:

Child2 child2Obj;
int value = child2Obj.getProt(); // This is valid because getProt() is a public member function.


// Accessing prot directly outside the class is not allowed.
// int protValue = child2Obj.prot; // This would result in a compilation error.

Child3: Private Inheritance

class Child3 : private Parent
{
public:
    int getProt()
    {
        return prot;
    }
};

In this case, Child3 inherits from Parent with a private specifier. This means that both the protected and public members of the Parent class become private members in Child3. Outside the Child3 class, the inherited members are not accessible.

Usage example:

Child3 child3Obj;
int value = child3Obj.getProt(); // This is valid because getProt() is a public member function.

// Accessing prot directly outside the class is not allowed.
// int protValue = child3Obj.prot; // This would result in a compilation error.

To summarize, the main difference lies in the accessibility of the inherited members outside the derived classes. Public inheritance allows access to the inherited members, protected inheritance restricts access to the outside world, and private inheritance makes all inherited members private to the derived class.

Let's get connected on Linkedin ^_^

DEV Community: Rifat Khan

Object-Oriented Programming in Java: An Academic Perspective

Table of Contents

Introduction to OOP in Java

✅ Summary Table

Constructor and Method Overloading

Syntax Example

Academic Note

Method Overriding

Academic Note

Inheritance

Academic Note

Access Modifiers

Concepts

Syntax Examples

Returning Objects from Methods

The super Keyword

The this Keyword

The static Keyword

Academic Note

The final Keyword

Dynamic Method Dispatch

Abstract Classes

Interfaces

Summary of Keywords

Which Topic belongs to which Components of OOP?

1️⃣ Inheritance

2️⃣ Polymorphism

3️⃣ Encapsulation

4️⃣ Abstraction

Best Practices

Exercises for Students

Conclusion

Inheritance with access-specifier in cpp

Child1: Public Inheritance

Child2: Protected Inheritance

Child3: Private Inheritance

The `super` Keyword

The `this` Keyword

The `static` Keyword

The `final` Keyword