TUGAS 3 PRAKTIKUM PEMOGRAMAN BERBASIS DESKTOP

Summary

This transcript outlines an object-oriented program for managing a menu and customer orders. The system involves classes for menu items, food, drinks, discounts, and orders, with methods to add, display, save, and load items. Users can interact with the program through a console menu to manage their menu, take orders, calculate totals (including discounts), and generate receipts. The program supports file operations to save and load menu data. The transcript also includes examples of menu interactions, from item entry to order processing, with clear explanations of the underlying logic and flow.

Takeaways

• 😀 The script describes a restaurant menu management system based on object-oriented programming (OOP) concepts.
• 😀 The system uses abstract classes and inheritance to manage different menu items like food and drinks.
• 😀 The `MenuItem` class is abstract and includes common attributes such as name, price, and category.
• 😀 The `Food` and `Drink` classes inherit from `MenuItem` and implement a `displayMenu` method specific to their type.
• 😀 A `Discount` class extends `MenuItem`, adding a discount attribute to apply discounts to menu items.
• 😀 The `Menu` class manages a collection of menu items and provides methods to add, display, and save items.
• 😀 The `Order` class allows customers to place orders, calculate total costs (including discounts), and print a receipt.
• 😀 The system uses a loop in the main class for user interaction, offering options to add items, display the menu, and manage orders.
• 😀 The menu can be saved to and loaded from a file, ensuring persistent storage of menu items and orders.
• 😀 The script includes an example of interacting with the system, showing how to add items, place an order, and manage the menu through a user interface.

Q & A

What is the purpose of an abstract class in the menu item structure?

An abstract class serves as a template for other classes to inherit from. It defines common attributes like name, price, and category, and provides a method (e.g., `tampilMenu`) that must be implemented in subclasses for specific functionality.

How do the food and drink classes relate to the menu item class?

The food (`Makanan`) and drink (`Minuman`) classes inherit from the `MenuItem` abstract class. This inheritance allows them to share the common attributes and methods of `MenuItem`, but each can implement specific details like displaying the menu for food or drinks.

What role does the `Diskon` (discount) class play in the program?

The `Diskon` class extends the `MenuItem` class and adds an attribute for storing the discount value. It overrides the `tampilMenu` method to display item-specific details, including the discount, along with other attributes like name, price, and category.

How does the `Menu` class manage the list of menu items?

The `Menu` class holds all menu items in an ArrayList. It provides methods to add items (`tambahItem`), display the entire menu (`tampilkanMenu`), retrieve items by index (`getItem`), get the total number of items (`jumlahItem`), and save/load the menu to/from a file.

What functionality does the `Pesanan` (order) class provide?

The `Pesanan` class stores all items that a customer orders. It includes methods like `tambahItem` to add items to the order, `hitungTotal` to calculate the total price (including any discounts), and `tampilkanStruk` to print out the order receipt.

What does the `tampilkanStruk` method in the `Pesanan` class do?

The `tampilkanStruk` method generates a receipt for the customer's order. It outputs the total cost of the order, including any discounts, and provides a summary of the ordered items.

How does the main program interact with the user to manage the menu and orders?

The main program uses a menu interface with options like adding items, displaying the menu, accepting orders, saving the menu to a file, and loading it from a file. It uses a `do-while` loop to keep presenting the menu until the user chooses to exit.

What is the purpose of the `switch-case` structure in the main program?

The `switch-case` structure processes the user's menu choice and directs the program to the corresponding function, such as adding a menu item, displaying the menu, accepting orders, or saving/loading the menu from a file.

How does the program handle saving and loading the menu from a file?

The program provides methods in the `Menu` class to save the menu to a file (`simpanMenuFile`) and load the menu from a file (`muatMenuDariFile`). This allows the user to store and retrieve the menu data as needed.

What is the flow of operations when a user places an order in the program?

When the user selects the 'Terima Pesanan' (Accept Order) option, the program displays the menu, allows the user to add items, calculates the total price including any discounts, and then prints a receipt with the total cost. The user can also save or load the menu as required.