Question

(Rectangle Class) Create a class Rectangle. The class has attributes length and width, each of which defaults to \(1 .\) It has methods that calculate the perimeter and the area of the rectangle. It has set and get methods for both Tength and width. The set methods should verify that 7 ength and width are each floating-point numbers larger than 0.0 and less than \(20.0 .\) Write a program to test class Rectangle.

Short answer

Create a `Rectangle` class with length and width; include validation in setters, and methods for area and perimeter.

Step-by-step solution

Define the Rectangle Class

Begin by creating a class named `Rectangle`. Inside this class, initialize two default attributes: `length` and `width`, and assign them a default value of 1 each.

Initialize the Constructor

Create an `__init__` method for the `Rectangle` class that sets the `length` and `width` of the rectangle. Use the default values of 1, and also allow these values to be passed as arguments when a new object is created.

Define Get Methods

Implement getter methods `get_length` and `get_width` that return the `length` and `width` of the rectangle respectively. These methods enable access to the private attributes.

Define Set Methods with Validation

Create setter methods `set_length` and `set_width` that take a value as a parameter and set this value to `length` and `width`. Ensure the value is a floating-point number greater than 0.0 and less than 20.0. If not, raise a ValueError.

Implement Area Method

Create a method `area` inside the class that calculates the area using the formula: \[ \text{Area} = \text{length} \times \text{width} \] Return the computed area.

Implement Perimeter Method

Create a method `perimeter` inside the class that calculates the perimeter using the formula: \[ \text{Perimeter} = 2 \times (\text{length} + \text{width}) \] Return the calculated perimeter.

Test the Rectangle Class

Develop a small program that creates instances of the `Rectangle` class. Try out different lengths and widths through the set methods and ensure the area and perimeter methods work correctly by printing their outputs.

Key concepts

Rectangle Class

A Rectangle class is a fundamental concept in Object-Oriented Programming, often used to demonstrate how real-world objects can be represented in code. Imagine a rectangle shape; it has two main characteristics: length and width. In our `Rectangle` class, we represent these characteristics as attributes or properties. When we create a `Rectangle` in programming, we are basically defining a blueprint with these attributes. By default, we set both the length and the width to 1. This ensures that when a new rectangle is created without specified dimensions, it still has valid measurements. The primary purpose of the class is to encapsulate these properties and the behavior that a rectangle would have, such as calculating its area or perimeter.

Set and Get Methods

Get and set methods, also known as accessors and mutators, are crucial for interacting with object attributes from outside the class.
These methods are essential as they control how attribute values are retrieved and modified. In our `Rectangle` class, `get_length` and `get_width` methods let us access the current dimensions. Instead of accessing the attributes directly, which would be bad practice, these methods provide a controlled interface.
On the other hand, `set_length` and `set_width` methods are used to change these values. They can perform additional tasks like validation, ensuring that the given data is appropriate before assigning it to the variable. This design sticks to the principle of encapsulation, securing the object state and integrity.

Validation in Setters

Validation is an important aspect of set methods, ensuring that the state of the object remains consistent. In our `Rectangle` class, length and width must be floating-point numbers greater than 0.0 and less than 20.0.
If an invalid value is attempted to be set, such as a negative number or a number greater than 20, a `ValueError` is triggered, alerting the user to the error.
This condition prevents irrational or impossible states for the rectangle, such as a negative length or an excessively large dimension, which wouldn't make sense logically. It also exemplifies defensive programming, a practice meant to minimize bugs by addressing unforeseen inputs or actions.

Area and Perimeter Calculation

One of the key functionalities of the `Rectangle` class is the ability to compute the area and the perimeter, reflecting the real-world behavior of a geometric rectangle.
To calculate the area, we use the formula: \[ \text{Area} = \text{length} \times \text{width} \]This mathematical operation multiplies the length by the width, giving the total space enclosed by the rectangle.
For the perimeter, the formula used is: \[ \text{Perimeter} = 2 \times (\text{length} + \text{width}) \]This sum gives the total distance around the rectangle. These calculations are methods within the class, ensuring that any instance of a `Rectangle` can directly compute these measurements when needed. Such features highlight the benefit of object-oriented programming: the encapsulation of behavior within an object.