Building a Simple E-Commerce Ordering System in Java Using OOP

Applying OOP Principles to a Realistic E-Commerce Scenario in Java

Introduction

In our previous article, we explored the foundational principles of Object-Oriented Programming (OOP) — encapsulation, inheritance, polymorphism, and abstraction — and how they help you write cleaner, more maintainable Java code. Now it’s time to put those ideas into practice. Instead of talking about OOP in the abstract, let’s apply it to a scenario you might actually encounter as a developer: building a simple online store’s ordering system.

We’ll break our system down into objects like Customer, Product, Order, and PaymentMethod, each with its own responsibilities. Along the way, you’ll see how OOP principles guide your design decisions and make your code easier to adapt as requirements change.

The Scenario: A Simplified Online Store

Imagine you’re building a basic e-commerce platform. Your system should:

• Represent customers with their personal information.
• Manage a catalog of products (both physical and digital).
• Handle orders that track which products the customer bought.
• Process payments without tying the system to one payment method.

This might not be a complete, production-ready application, but it’s realistic enough to illustrate how OOP principles help you structure your code.

1. Encapsulation: Keeping Data and Logic Together

Goal: Make sure each class manages its own data in a controlled way, preventing unintended changes from outside.

Example: Customer Information

A Customer needs to store details like name, email, and address. Instead of making these fields public, we’ll keep them private. This way, we have full control over how other parts of the program update a customer’s information.

public class Customer {
    private String name;
    private String email;
    private String address;

    public Customer(String name, String email, String address) {
        this.name = name;
        this.email = email;
        this.address = address;
    }

    public void updateAddress(String newAddress) {
        if (newAddress == null || newAddress.trim().isEmpty()) {
            System.out.println("Invalid address. Please provide a valid address.");
        } else {
            this.address = newAddress;
            System.out.println("Address updated to: " + newAddress);
        }
    }

    public String getName() { return name; }
    public String getEmail() { return email; }
    public String getAddress() { return address; }
}

Encapsulation Benefit: If, in the future, you need to validate or transform the address data (e.g., normalize capitalization or check a database of valid postal codes), you can do it all within updateAddress() without modifying code all over your project.

2. Inheritance: Reusing and Specializing Classes

Goal: Avoid repeating code by defining common functionality in a superclass and extending it in specialized subclasses.

Example: Physical vs. Digital Products

Your store sells both physical items (like laptops) and digital items (like e-books). Both share common attributes (like name and price), so we start with a Product superclass. Physical products need shipping calculations, while digital products don’t.

public abstract class Product {
    protected String name;
    protected double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public double getPrice() { return price; }
    public String getName() { return name; }
    public abstract double getShippingCost();
}

public class PhysicalProduct extends Product {
    private double weight;

    public PhysicalProduct(String name, double price, double weight) {
        super(name, price);
        this.weight = weight;
    }

    @Override
    public double getShippingCost() {
        return 5.0 + (0.5 * weight);
    }
}

public class DigitalProduct extends Product {
    public DigitalProduct(String name, double price) {
        super(name, price);
    }

    @Override
    public double getShippingCost() {
        return 0.0; // Digital products have no shipping cost
    }
}

Inheritance Benefit: Both product types share common fields and methods, making your code less repetitive.

Adding another product type (e.g., a subscription) is straightforward: just extend Product and implement getShippingCost() appropriately.

3. Polymorphism: Treating Different Objects Uniformly

Goal: Write code that interacts with objects through a shared interface or superclass, letting you handle new or different types of objects without changing the code that uses them.

Example: Calculating Order Totals

When a customer places an order, it can contain any combination of physical and digital products. From the order’s perspective, a product is just something that has a getPrice() and a getShippingCost(). Whether it’s digital or physical, we just treat it as a Product.

import java.util.ArrayList;
import java.util.List;

public class Order {
    private Customer customer;
    private List<Product> products = new ArrayList<>();
    private boolean paid = false;

    public Order(Customer customer) {
        this.customer = customer;
    }

    public void addProduct(Product product) {
        products.add(product);
    }

    public double calculateTotalCost() {
        double subtotal = 0.0;
        double shippingTotal = 0.0;

        for (Product p : products) {
            subtotal += p.getPrice();
            shippingTotal += p.getShippingCost(); 
        }

        return subtotal + shippingTotal;
    }

    public void markAsPaid() {
        this.paid = true;
    }

    public boolean isPaid() {
        return paid;
    }
}

Polymorphism Benefit: The order code doesn’t need to know whether a product is digital or physical. It relies on the Product class’s method signatures. This makes the Order class flexible and easy to extend if you add more product types later.

4. Abstraction: Focusing on What Objects Do, Not How They Do It

Goal: Define a contract that multiple classes can fulfill in their own way, so you can switch implementations without rewriting the code that uses them.

Example: Payment Methods

You might want to support multiple payment methods (credit card, PayPal, cryptocurrency, etc.). Instead of hard-coding payment logic into the Order class, use an interface PaymentMethod to define what it means to “process a payment.” Each payment class handles the details differently.

public interface PaymentMethod {
    boolean processPayment(double amount);
}

public class CreditCardPayment implements PaymentMethod {
    private String cardNumber;
    private String cardholderName;
    private String expiry;
    private String cvv;

    public CreditCardPayment(String cardNumber, String cardholderName, String expiry, String cvv) {
        this.cardNumber = cardNumber;
        this.cardholderName = cardholderName;
        this.expiry = expiry;
        this.cvv = cvv;
    }

    @Override
    public boolean processPayment(double amount) {
        System.out.println("Processing credit card payment of $" + amount + " for " + cardholderName);
        // Here you'd integrate with a real payment gateway.
        return true; 
    }
}

public class PaypalPayment implements PaymentMethod {
    private String email;

    public PaypalPayment(String email) {
        this.email = email;
    }

    @Override
    public boolean processPayment(double amount) {
        System.out.println("Processing PayPal payment of $" + amount + " for " + email);
        return true;
    }
}

Abstraction Benefit: The order doesn’t care how payments are processed. It just needs to call processPayment() on something that implements PaymentMethod. This makes it easy to add or change payment options down the road.

Putting It All Together

Now let’s see how our classes interact. We’ll create a customer, add products to an order, calculate the total, and pay using a chosen method.

public class Main {
    public static void main(String[] args) {
        // Creating a customer encapsulates the customer's data and logic in one class (Encapsulation).
        Customer customer = new Customer("Alice", "alice@example.com", "123 Apple St");
        
        // Creating an Order for that customer shows how objects collaborate.
        Order order = new Order(customer);

        // Product is an abstract class. PhysicalProduct and DigitalProduct are subclasses.
        // This uses Inheritance (PhysicalProduct and DigitalProduct inherit from Product).
        // It also shows Polymorphism: both products are treated as Products.
        Product laptop = new PhysicalProduct("Laptop", 999.99, 2.0);
        Product eBook = new DigitalProduct("E-Book: Java for Beginners", 9.99);

        // Adding products to the order: the order doesn't care if they're physical or digital.
        // This is Polymorphism in action, as Order interacts with them through the Product interface.
        order.addProduct(laptop);
        order.addProduct(eBook);

        // Calculating total relies on Product’s getPrice() and getShippingCost() methods.
        // Different product types implement these differently (Polymorphism).
        double total = order.calculateTotalCost();
        System.out.println("Order Total: $" + total);

        // PaymentMethod is an interface (Abstraction). CreditCardPayment is one implementation.
        // Another payment class could be substituted without changing this code (Polymorphism + Abstraction).
        PaymentMethod payment = new CreditCardPayment("4111111111111111", "Alice", "12/25", "123");
        boolean success = payment.processPayment(total);

        if (success) {
            order.markAsPaid();
            System.out.println("Order paid successfully!");
        } else {
            System.out.println("Payment failed. Please try another method.");
        }
    }
}

Why This Matters

In a real-world project, requirements change all the time. Maybe you need to add a discount system for certain products, or a new payment gateway. By applying OOP principles:

• Encapsulation keeps data management inside each class, making it easier to evolve logic without breaking other parts of the code.
• Inheritance allows you to create new product types or vehicle types (if you expand to delivery drones!) without duplicating code.
• Polymorphism ensures your methods can handle new product types or payment methods seamlessly.
• Abstraction separates the idea of payment from the payment method’s internal workings, allowing you to swap implementations easily.

This flexibility is exactly what makes OOP a powerful approach. Your codebase can grow with new features and handle changing requirements with less pain and confusion.

Next Steps

Experiment with the code yourself. Try adding:

• A GiftCardPayment class that checks if the customer has enough balance on a gift card.
• A SubscriptionProduct that has a monthly fee and no shipping cost.
• A DiscountedPhysicalProduct that applies a 10% discount before adding shipping.

The more you practice thinking in terms of objects, the more natural OOP design will become — and the easier it will be to build robust, scalable applications in Java.

Conclusion

By building a small e-commerce ordering system, we’ve seen how OOP principles guide the design of a codebase that’s modular, maintainable, and ready to adapt to future changes. Understanding these principles in theory is one thing, but seeing them in action helps you appreciate their value.

As you continue learning Java, keep exploring OOP’s potential. The skills you develop now will serve as a strong foundation for tackling more complex projects down the road.

Happy coding!