1. Planning

• The planning phase is where you define the project's goal at a high level.
• Answer the question "What are we building?"

Project Goal: To create a command-line application that performs basic arithmetic on fractions.

Project Scope

• Project scope defines the boundaries of a project, such as what is included and excluded, thereby preventing scope creep and promoting efficient project execution. 

• Answer the question "What is the scope of the project?"

In Scope: The calculator must handle addition, subtraction, multiplication, and division. It must accept valid whole numbers, improper fractions, and mixed numbers (e.g., 3, 5/3, 1 2/3). All results must be simplified and displayed as both an improper fraction (e.g., 5/3) and a mixed number (e.g., ​1 2/3).

Out of Scope: A graphical user interface (GUI) or handling square roots are not part of this initial project.

Feasibility Analysis

• A feasibility analysis is a comprehensive evaluation of a proposed project to determine its viability. It assesses various factors like technical, financial/economic, operational, legal, and market aspects to determine if the project is likely to succeed and if it's worth pursuing. 

• Answer the question, "Is it feasible?"

Technical: Yes, it is possible, as Java has all the necessary tools to handle the arithmetic and user input.

Economic: The primary resources needed are a developer proficient in Java and a computer with a Java Development Kit (JDK). The cost is primarily the developer's time (approximately 8-10 hours). No special software or hardware is needed.

Operational: Once built, this project can be included as part of a suite of mathematical calculators. It will serve its purpose without disrupting any existing workflows.

2. Analysis

• The analysis phase focuses on gathering detailed requirements from stakeholders (e.g., the user or project owner).
• The goal is to understand exactly what the system must do.
• These are broken down into functional and non-functional requirements.

Functional Requirements

• Functional Requirements: (define what the program does)

  1. The system must allow a user to input two fractions and an arithmetic operator (+, -, *, /).

  2. The system must correctly parse various input formats: a/b (e.g., 2/3), a b/c (e.g., 1 1/2), and a (e.g., 4).

  3. The system must perform the specified arithmetic operation. For example: 2/3+11/2 should equal 21/6.

  4. The system must handle and report errors, such as division by zero or invalid input (e.g., "hello").

  5. The final result must always be simplified to its lowest terms. For example, a raw result of 10/6 must be simplified to 5/3.

  6. The final result must be displayed in two formats: as an improper fraction (e.g., 5/3) and as a mixed number (e.g., 1 2/3).

Non-Functional Requirements

• Non-Functional Requirements: (defines how it will be done)

  1. The application must be written in the Java programming language.

  2. It must run as a console (command-line) application.

  3. Calculations must be accurate and computationally efficient.

Software Requirements Specifications (SRS)

• In larger project, this phase produces a Software Requirements Specification (SRS) document, which details everything the final product needs to be and do.

• More information:

  • IEEE

  • GFG

3. Design

• The design phase is where you create the blueprint for the system based on the requirements gathered in the analysis phase.
• This includes defining the system's architecture, data structures, and algorithms.
• This is where tools like UML diagrams and flowcharts are essential.

Model-View-Controller

• MVC architecture is a widely used software design pattern that separates an application into three interconnected packages, making applications more organized, easier to maintain, and testable.
  • The Model manages the application's data and business logic
  • The View handles the user interface and presentation
  • The Controller acts as the intermediary, receiving user input, interacting with the Model, and selecting the appropriate View to display to the user.
• The Laravel PHP framework does a great job of organizing web projects.
  • ​2025 Web Technologies Capstone | Heroku | Digital Ocean
  • 2025 PHP/MySQL II In-Class Project | Shared Hosting
• Jakarta EE requires manual organization
  • 2025 In-Class Project | Exemplary Project | Digital Ocean

Classes

• In object-oriented programming, classes create the blueprint for objects in the system.

• We'll structure this application into two classes:

  • A Fraction class: This will be the core (the model) of our application. It will hold the data for a single fraction (numerator and denominator) and contain the logic for performing arithmetic operations, simplification, and formatting.

  • A Calculator (or Main) class: This will handle getting input from the console (the view) and orchestrate the operations (the controller) by creating Fraction objects and calling their methods.

What is UML?

• UML is the “Unified Modeling Language”
• Standard modeling language for software development
• Maintained by Object Management Group
• Made up of pseudo-code, notations, pictures, diagrams, etc
• Describes the system we want to develop
• The UML textbook is optional for this class, but may be required for other classes.
  • If you have a copy of the UML textbook, today's lesson covers Modules 3 and 6.
  • If you don't have a copy of the UML textbook, consider reading tutorials like these:
    • https://agilemodeling.com/artifacts/classdiagram.htm
    • https://developer.ibm.com/articles/the-class-diagram/
• I am considering this book for Java III.

• Class diagrams show the classes of the system, their relationships, and the attributes and operations (methods).

• Classes form the main building blocks of an object-oriented application.

Class Diagrams

Three Boxes

• Classes are depicted as boxes with three sections:
  • The top box indicates the name of the class. The name is typically a singular noun. Write class names in UpperCamelCase.
  • The middle box lists the attributes of the class (the information stored about an object)
  • The bottom box lists the methods (the operations an object or class do).

Access Modifiers

• The + symbol represents a public access modifier, meaning all other classes have access.
• The - symbol represents a private access modifier, meaning only the current class has access.
• The / symbol (not shown) represents a derived modifier - a value not stored but is calculated from other attributes when needed
  • ​For example, GPA could be derived from a list of grades
• The # symbol (not shown) represents a protected access modifier, meaning other classes in the same package has access to the attribute.

Data Types, Parameters, and Return Types

• Method parameters are shown inside parentheses.
  • ​Getter methods and the toString method have no parameters.
  • Setter method parameters will typically match the attribute data type.
• Method return types are shown after the colon.
  • Getter methods will always return the attribute data type.
  • Setter methods will always return void.
  • The toString method will always return a String.

Fraction Class Diagram

• The numerator is the top number of the fraction
• The denominator is the bottom number of
  the fraction
• Attributes should typically have private access
• Write non-constant attribute names in lowerCamelCase.
• There is a default and parameterized constructor
• Methods most often have public access.
  Write method names in lowerCamelCase.
• The value(s) inside the parenthesis are the input parameter(s) and their data types.
  Write parameters in lowerCamelCase.
• The values after the parenthesis are the return types.
• The first methods are the constructors. The next set of methods are the getters and setters. Always include a toString method.

Class Diagrams

• From the previous slide:
  • toString() will return a string like "5/3"
  • compareTo() can be used to sort a List of Fraction objects
  • gcd() is a private helper method to get the greatest common denominator of two integers
  • lcm() is a private helper method to get the least common multiple of two integers
  • simplify() is a private helper method to reduce the fraction
  • toMixedNumberString() will return a string like "1 2/3"

Mermaid Syntax

• Mermaid is a tool used to create and modify diagrams using Markdown-inspired pseudocode text.
  • Flowcharts, sequence diagrams, class diagrams, and more.
• Mermaid syntax can be processed in their online editor or in app.diagrams.net by clicking Arrange > Insert > Mermaid.
• Mermaid diagrams can be embedded into HTML files.
• Consider using the Mermaid plugin for IntelliJ.

Mermaid Class Diagram

• Here is an example of a single class with no related classes.

Mermaid Flowchart

• Here are two examples of top-down flowcharts. Note how both examples are different, but they result in the same output
  • Circles are used to indicate the start and end
  • A parallelogram is used to indicate input
  • A diamond is used for decision making
  • Rectangles are used for process steps

In-Class Group Activity

• In groups of 2 to 3 students, create a flowchart for two of the other method operations.
  • simplify -> Convert 48/27 to 16/9, Convert 1/-2 to -1/2
  • toMixedNumberString() -> Convert 16/9 to 1 7/9, Convert 2/1 to 2, Convert 0/2 to 0
  • subtract(Fraction other) :: Fraction
  • multiply(Fraction other) :: Fraction
  • divide(Fraction other) :: Fraction