E Shopping Store

Introduction

The E Shopping Store is a university level e-commerce simulation project designed to demonstrate how real world shopping systems can be built using object oriented programming principles. Instead of focusing only on user interface and basic functionality, the main goal of this project is to apply core OOP concepts in a structured backend design while integrating it with a simple web based frontend.

The system simulates an online shopping experience where users can browse products, interact with a catalog, and perform basic shopping actions. Underneath this flow, the application is designed using Java as the core backend language to enforce proper object oriented design practices.

Object Oriented Design Approach

The entire system is structured around object oriented programming principles such as encapsulation, abstraction, inheritance, and polymorphism.

Encapsulation is applied by grouping related data and behaviors into classes such as Product, User, and Order. Each class is responsible for managing its own state while restricting direct external access to internal data. This ensures data integrity and reduces unintended modifications.

Abstraction is used to hide complex implementation details from the user interface layer. For example, shopping operations such as adding products to a cart or processing an order are handled internally within backend classes, exposing only necessary methods to the frontend.

Inheritance is applied to create reusable and extendable class hierarchies. Common properties shared between different entities are defined in base classes and extended by specialized classes where needed. This reduces code duplication and improves scalability.

Polymorphism is demonstrated through method overriding and flexible object handling, allowing the system to process different types of objects through a unified interface. This makes the application easier to extend without modifying existing logic.

Product and Catalog Structure

Products in the system are represented as objects with clearly defined attributes such as name, price, description, and identifier. Each product instance is managed through dedicated classes that handle product-related operations.

The catalog system organizes these product objects and provides methods for retrieving and displaying product information. This object based approach ensures that product data is not just static information but part of an active system with defined behaviors.

Shopping Cart and Order Management

The shopping cart is implemented as a separate object that manages a collection of product instances. It provides methods to add, remove, and update items while maintaining internal state consistency.

Order processing is handled through dedicated order classes that take cart data and convert it into structured order objects. This separation between cart and order follows proper OOP design by distinguishing between temporary user selections and finalized transactions.

Backend Design with Java

The backend is implemented using Java to take advantage of its strong object oriented programming capabilities.

Java classes are used to model real world entities such as users, products, carts, and orders. Each class is responsible for its own behavior, ensuring high cohesion and low coupling between system components.

The backend logic is structured in a way that aligns with enterprise level design principles, where each module has a clearly defined responsibility. This makes the system easier to maintain, test, and extend in the future.

Frontend Interaction Layer

The frontend is built using HTML, CSS, and JavaScript and acts as the presentation layer of the system.

It communicates with the backend logic to display product information and handle user interactions. While the frontend remains simple, it is designed to reflect the behavior of a real e-commerce system by interacting with backend objects and methods indirectly.

System Architecture

The system follows a layered architecture where the frontend handles presentation and the Java backend handles business logic using object oriented principles.

This separation ensures that the core logic of the application is independent of the user interface, allowing the system to be modified or extended without affecting other layers.

The architecture strongly emphasizes modularity, reusability, and maintainability, which are key advantages of object oriented design.

Learning Outcome

This project provides practical experience in applying object oriented programming concepts to a real world inspired system. It demonstrates how encapsulation, inheritance, abstraction, and polymorphism can be used together to build a structured and scalable application.

It also reinforces the importance of designing systems around objects and responsibilities rather than procedural logic.

Conclusion

The E Shopping Store project highlights how object oriented programming can be used to design a clean and maintainable backend for an e-commerce system. By modeling real world entities as objects and applying OOP principles consistently, the project achieves a structured and extensible architecture suitable for future expansion.