Question

\((\text {Rational Numbers})\) Create a class called Rational for performing arithmetic with fractions. Write a program to test your class. Use integer variables to represent the private instance variables of the class - the numerator and the denominator. Provide a constructor that enables an object of this class to be initialized when it is declared. The constructor should store the fraction in reduced form. The fraction \\[ 2 / 4 \\] is equivalent to \(1 / 2\) and would be stored in the object as 1 in the numerator and 2 in the denominator. Provide a no-argument constructor with default values in case no initializers are provided. Provide public methods that perform each of the following operations: a) Add two Rational numbers: The result of the addition should be stored in reduced form. b) Subtract two Rational numbers: The result of the subtraction should be stored in reduced form. c) Multiply two Rational numbers: The result of the multiplication should be stored in reduced form. d) Divide two Rational numbers: The result of the division should be stored in reduced form. e) Print Rational numbers in the form a/b, where a is the numerator and b is the denom- inator. f) Print Rational numbers in floating-point format. (Consider providing formatting capabilities that enable the user of the class to specify the number of digits of precision to the right of the decimal point.)

Short answer

Define a `Rational` class with methods for arithmetic operations and printing in fractional and decimal form. Include constructors and simplify fractions upon each operation.

Step-by-step solution

Define the Rational Class

Create a class named `Rational` with private instance variables `numerator` and `denominator`. These will be used to store the numerator and denominator of the rational number.

Implement Constructors

Create a constructor that accepts two integers, `num` and `denom`, and reduces them to their simplest form. Also, implement a no-argument constructor that sets the rational number to a default value like \(0/1\).

Simplify the Fraction

Implement a private method named `reduce()` that calculates and applies the greatest common divisor (GCD) to simplify the fraction. Use the Euclidean algorithm to find the GCD.

Addition Method

Define a method `add(Rational r)` that calculates the sum of the current Rational object with another. Use \( \frac{a}{b} + \frac{c}{d} = \frac{ad + bc}{bd} \) to compute the new numerator and denominator, then simplify using `reduce()`.

Subtraction Method

Create a method `subtract(Rational r)` following a similar logic as addition: \( \frac{a}{b} - \frac{c}{d} = \frac{ad - bc}{bd} \). Simplify the result with `reduce()`.

Multiplication Method

Design a method `multiply(Rational r)` that multiplies the current Rational object with another: \( \frac{a}{b} \times \frac{c}{d} = \frac{ac}{bd} \). Simplify the product using `reduce()`.

Division Method

Create a method `divide(Rational r)` by multiplying with the reciprocal of another Rational object: \( \frac{a}{b} \div \frac{c}{d} = \frac{a \cdot d}{b \cdot c} \). Call `reduce()` to simplify the result.

Print Method for Fraction

Implement a method `printFraction()` that returns a string of the form `"a/b"`, representing the fraction (handle special cases such as denominators of 1 to return just the numerator).

Print Method for Decimal

Develop a method `printDecimal(int precision)` that converts the fraction to decimal form with the specified precision, using string formatting for the correct number of decimal places.

Test the Class

Create a separate test class with a `main` method that creates various `Rational` instances. Call the methods to test addition, subtraction, multiplication, division, and both print methods to ensure correct functionality.

Key concepts

Java classes

In Java, classes are foundational building blocks of object-oriented programming. A class serves as a blueprint for creating objects, allowing developers to define the properties and behaviors that the objects, often referred to as instances, will have. For example, in our `Rational` class, this concept is applied to handle operations on rational numbers (fractions).

The class contains instance variables for the numerator and denominator, which hold the essential state of a fraction. By encapsulating the data within the class, we ensure that these properties can only be accessed and modified through defined methods.

By organizing code into classes, we create reusable components that can interact with each other within a program. This makes Java classes vital for building scalable and maintainable software applications.

Fraction arithmetic

Fraction arithmetic involves operations such as addition, subtraction, multiplication, and division performed on fractions. This is an essential part of math that can also be implemented programmatically. In our `Rational` class example, we have methods for each type of fraction operation.

• **Addition** is performed using the formula \( \frac{a}{b} + \frac{c}{d} = \frac{ad + bc}{bd} \).
• **Subtraction** is managed similarly: \( \frac{a}{b} - \frac{c}{d} = \frac{ad - bc}{bd} \).
• **Multiplication** is straightforward: \( \frac{a}{b} \times \frac{c}{d} = \frac{ac}{bd} \).
• **Division** involves reciprocation: \( \frac{a}{b} \div \frac{c}{d} = \frac{a \cdot d}{b \cdot c} \).

After each operation, it is crucial to reduce the result to its simplest form to ensure the fraction is appropriately represented.

Instance variables

Instance variables are non-static variables defined within a class, and each instance of the class has its own copy of them. In the context of our `Rational` class, the numerator and denominator are private instance variables.

These variables are critical because they store the specific state of a fraction for each object, meaning that each `Rational` object can represent different fractions. This encapsulation is a key principle of object-oriented programming as it helps maintain data integrity by controlling how data is accessed and modified.

By declaring them private, we ensure that these variables cannot be directly accessed from outside the class. Instead, they require methods such as constructors and other member functions to be used, preserving the internal consistency of the object's state.

Constructors in Java

Constructors in Java play a crucial role in object creation by initializing new instances of a class with specific attributes. In the `Rational` class, there are two constructors: one with parameters and a no-argument default constructor.

The parameterized constructor allows for initial values for the numerator and denominator to be set and also calls a method to reduce the fraction to its simplest form. This ensures that the object is always in a valid state with its attributes set correctly after creation.

The default constructor provides a way to create a `Rational` object without initial values, usually setting the fraction to a default like 0/1. Constructors ensure that the creation of an object is streamlined and efficient, maintaining control over how objects are initialized in Java.