Java Object-Oriented Programming Portfolio

Student: Kha Anh (Lisa) Nguyen
Student ID: 103814796
Course Grade: 95/100
Course Year: Sem 2, 2024

Portfolio Overview

This portfolio demonstrates comprehensive understanding of Java programming fundamentals, object-oriented programming principles, and software design patterns through three major projects:

1. Cinema Booking System (Assignment 1, Task 1)
2. Insurance Management System (Assignment 1, Task 2)
3. Travel Ticket Booking System (Assignment 2)

Key Learning Outcomes Demonstrated

Programming Language Syntax

• Java Fundamentals: Variables, data types, control structures, arrays, and collections
• Exception Handling: Custom exceptions (InsuranceRequiredException) and try-catch blocks
• File I/O Operations: Object serialization for data persistence using ObjectOutputStream and ObjectInputStream
• Input Validation: Comprehensive user input validation with loops and error checking

Object-Oriented Programming Principles

1. Encapsulation

• Private Fields: All class attributes are properly encapsulated with private access modifiers
• Getter/Setter Methods: Controlled access to object state through public methods
• Data Hiding: Internal implementation details are hidden from external classes

2. Inheritance

• Abstract Base Classes: dayTours abstract class defines common tour functionality
• Class Hierarchies:
  • CityTour, Attractions → dayTours
  • Queensland, International → Attractions → dayTours
• Method Overriding: Abstract method requiresInsurance() implemented differently in each subclass

3. Polymorphism

• Runtime Polymorphism: Different tour types handled uniformly through base class references
• Method Overloading: Multiple constructors and methods with different parameter signatures
• Interface Implementation: applyInsurance interface for insurance functionality

4. Abstraction

• Abstract Classes: dayTours provides common structure while allowing specialization
• Interfaces: applyInsurance defines contract for insurance-related operations
• Abstract Methods: requiresInsurance() must be implemented by concrete classes

Object-Oriented Design

1. Design Patterns

• Factory Pattern: Tour creation based on type selection
• Strategy Pattern: Different insurance requirements for different tour types
• Template Method: Common booking process with tour-specific variations

2. Class Relationships

• Composition: Tickets contains dayTours references
• Aggregation: Customer contains collections of Policy objects
• Association: User objects associated with ticket sales

3. SOLID Principles

• Single Responsibility: Each class has a focused purpose
• Open/Closed: Extensible design allowing new tour types without modification
• Liskov Substitution: Subclasses can replace base classes without breaking functionality
• Interface Segregation: Focused interfaces like applyInsurance
• Dependency Inversion: High-level modules depend on abstractions

Project Details

Assignment 1: Task 1 - Cinema Booking System

Files: Task1.java, Task1Test.java

Features:

• 2D array-based seat management (8×10 grid)
• Auto-assignment and manual seat selection
• Ticket tracking with unique IDs
• Real-time availability checking
• Comprehensive input validation

OOP Concepts:

• Static methods and variables for system-wide state
• Encapsulation in Ticket class
• Array-based data structures for seat management

Assignment 1: Task 2 - Insurance Management System

Files: Task2.java, Task2Test.java

Features:

• Customer and policy management
• Enum types for Type and Plan
• Policy modification and deletion
• Total coverage value calculation
• Input validation for positive values

OOP Concepts:

• Enum usage for type safety
• Composition relationship between Customer and Policy
• Method chaining and fluent interfaces

Assignment 2: Travel Ticket Booking System

Files: stageD.java, stageDTest.java

Features:

• Multi-tier tour system (City, Attractions, Queensland, International)
• Insurance requirements based on tour type
• User authentication and role-based access
• Data persistence through serialization
• Complex pricing with discounts and service fees
• Customer detail management for flight bookings

Advanced OOP Concepts:

• Abstract classes and interfaces
• Exception handling with custom exceptions
• File I/O with object serialization
• Generic methods for data persistence
• Complex inheritance hierarchies
• Polymorphic behavior based on tour types

Testing Strategy

Unit Testing with JUnit 5

• Comprehensive Test Coverage: Each project includes dedicated test classes
• Test Categories: Valid inputs, invalid inputs, edge cases
• Assertion Methods: assertEquals, assertTrue, assertFalse, assertNotNull
• Test Setup: @BeforeEach for consistent test initialization

Test Case Examples:

• Valid Input Testing: Normal operation scenarios
• Invalid Input Testing: Error handling and edge cases
• Boundary Testing: Capacity limits and constraint validation
• Integration Testing: Multi-component interaction testing

Technical Skills Demonstrated

Data Structures

• Arrays: 2D arrays for seat management, 1D arrays for collections
• Collections: ArrayList, HashMap, TreeMap for dynamic data management
• Generic Types: Type-safe collections and methods

Advanced Java Features

• Serialization: Object persistence to files
• Scanner Class: Interactive user input handling
• String Manipulation: Complex string formatting and parsing
• Static Methods: Utility functions and system-wide operations

Software Engineering Practices

• Code Documentation: Comprehensive comments and method descriptions
• Error Handling: Graceful failure management
• User Experience: Intuitive menu systems and clear feedback
• Data Validation: Input sanitization and constraint checking

Code Quality Features

Clean Code Principles

• Meaningful Names: Descriptive variable and method names
• Small Methods: Focused, single-purpose functions
• Consistent Formatting: Proper indentation and spacing
• Comment Documentation: Clear explanation of complex logic

Reusability

• Generic Methods: saveFile() and loadFile() for data persistence
• Utility Functions: Common operations extracted into reusable methods
• Modular Design: Independent components that can be easily modified

Documentation

UML plan, documentation and test cases are available in the PDF files:

• 103814796_assignment_1/103814796_assignment_1.pdf - Assignment 1 documentation
• 103814796_assignment_2/103814796_assignment_2-2.pdf - Assignment 2 documentation