Question

Create a class called Invoice that a hardware store might use to represent an invoice for an item sold at the store. An Invoice should include four pieces of information as instance variables - a part number (type String), a part description (type String), a quantity of the item being purchased (type int) and a price per item (double). Your class should have a constructor that initializes the four instance variables. Provide a set and a get method for each instance variable. In addition, provide a method named getInvoiceAmount that calculates the invoice amount (i.e., multiplies the quantity by the price per item), then returns the amount as a double value. If the quantity is not positive, it should be set to \(0 .\) If the price per item is not positive, it should be set to \(0.0 .\) Write a test app named InvoiceTest that demonstrates class Invoice's capabilities.

Short answer

Create an 'Invoice' class with fields for part number, part description, quantity, and price per item. Provide methods for setting and getting these values, ensuring quantity and price are positive. Implement a method to calculate the invoice amount. Then write an 'InvoiceTest' class to show the 'Invoice' class functionality.

Step-by-step solution

Define the Invoice Class

Create a public class named 'Invoice' with four private instance variables: 'partNumber' (String), 'partDescription' (String), 'quantity' (int), and 'pricePerItem' (double). Additionally, create a constructor that initializes these variables.

Implement Get and Set Methods

For each instance variable, create a public 'get' method to return its value and a 'set' method to modify its value. The 'set' methods should validate the input, ensuring that 'quantity' is non-negative and 'pricePerItem' is non-negative.

Implement getInvoiceAmount Method

Create a public method named 'getInvoiceAmount' that calculates the total invoice amount by multiplying 'quantity' by 'pricePerItem'. If 'quantity' is less than 0, it should be set to 0. If 'pricePerItem' is less than 0.0, it should be set to 0.0. The method should return the calculated amount as a double.

Create the InvoiceTest Class

Write a public class named 'InvoiceTest'. In the main method, create an object of the 'Invoice' class, set its fields with appropriate values using the set methods, and display the invoice amount using the getInvoiceAmount method.

Key concepts

Object-oriented programming

Object-oriented programming (OOP) is a paradigm that uses 'objects' to design applications and computer programs. It utilizes several key concepts, including encapsulation, inheritance, and polymorphism. In the case of the Invoice class, OOP allows us to bundle data, such as part numbers and prices, with the methods that operate on this data, like calculating the invoice amount. This modularizes the code, making it easier to manage and scale, while also keeping it secure through encapsulation.

Class constructor

A class constructor is a special kind of method in Java that is called when an object is instantiated. For the Invoice class, the constructor has the primary role of initializing the instance variables with the values provided at the time of creating a new Invoice object. This initialization is crucial as it sets the state of the object with valid starting values. Constructors ensure that the object is ready for use immediately after its creation.

In the exercise, when you create a new Invoice object, the constructor initializes part number, description, quantity, and price per item. Properly defining a constructor is an essential step to ensure the object is valid from the start.

Encapsulation

Encapsulation is a core OOP concept and is all about keeping the internal state of an object hidden from the outside. This is achieved in Java by declaring instance variables as 'private' and providing 'public' getter and setter methods to access and modify them. This control over access is what protects the internal state from unwanted interference and misuse.

In our Invoice class, encapsulation ensures that the part number, description, quantity, and price cannot be directly manipulated. Instead, they can only be accessed and modified using the public methods provided. This allows for data validation, as seen in the Invoice class. Users cannot set a negative quantity or price, as the setter methods contain checks to prevent this.

Method implementation

Method implementation refers to providing the body of a method that performs a specific task. In the Invoice class, beyond the getter and setter methods, the 'getInvoiceAmount' method is a crucial piece of functionality that calculates the total cost based on the quantity and price per item. It's a practical example of how a method can implement business logic to carry out operations on the data maintained within an object.

The 'getInvoiceAmount' method is particularly important for our Invoice class, as it encapsulates the business rule that quantities and prices must be non-negative and calculates the total invoice amount accordingly.

Data validation

Data validation is an indispensable aspect of robust software. Its purpose is to ensure that data entered into an application meets certain criteria before being processed. In the context of the Invoice class, data validation occurs within the setter methods. Each setter method checks whether the new value passed to it is within an acceptable range, and if not, sets it to a sensible default - zero in this case.

This precaution prevents logical errors like negative quantities or prices, which are nonsensical in the real world. Through data validation, the Invoice class safeguards the integrity of the data it represents.

Unit testing

Unit testing is a technique used to ensure that individual units of source code, such as methods within a class, are working as intended. It involves writing separate test cases that check whether the methods of the class perform correctly given various inputs. In the InvoiceTest class, the 'getInvoiceAmount' method is tested by creating an Invoice object, setting its fields, and ensuring that the calculated invoice amount is correct.

Good unit testing generally covers a wide range of input scenarios, including boundary cases. For instance, attempting to set negative quantities or prices in the Invoice class should trigger the data validation checks, and the unit tests should verify that the correct adjustments are made.