I am just starting out in programming. If someone could help me with these assignments, it would be greatly appreciated.
"Write a Rectangle class.
This class represents Rectangles. Each Rectange has the X and Y coordinates of its center point (as doubles) and its width and height (as double values, too). No other values should be stored! This means no area, no perimeter!
The class should have the following constructors and methods:
1. a constructor that takes X, Y, width, and height as arguments;
2. a constructor that takes only width and height as arguments;
3. a default constructor;
4. a method setCenter that takes X and Y as arguments;
5. a method setWidth that takes a width value;
6. a method setHeight that takes a height value;
7. a method getX that returns the X coordinate;
8. a method getY that returns the Y coordinate;
9. a method getWidth that returns the width value;
10. a method getHeight that returns the height value;
11. a method getArea calculates the area of the rectangle and returns it;
12. a method getPerimeter it calculates the perimeter of the rectangle and returns it;
13. a method toString that creates a String that includes the X, Y center coordinates, width, and height, and returns the string. This method does not use System.out.println() itself. It returns a String value to the caller.
Write an application (RectangleTest.java) to test your Rectangle class.
Your Application should test all the constructors and methods."
"Write a program to read a list of exam scores (integers in the range 0 to 100) and to output the total number of grades and the number of grades in each letter-grade category (90 to 100 = A, 80 to 89 = B, 70 to 79 = C, 60 to 69 = D, and 0 to 59 = F). The end of the input is indicated by a negative score as a sentinel value. (The negative value is used only to end the loop, so do not use it in the calculations.) For example, if the input is
98
87
86
85
85
78
73
72
72
72
70
66
63
50
-1
The output would be
Total number of grades=14
Number of A’s=1
Number of B’s=4
Number of C’s=6
Number of D’s=2
Number of F’s=1"
Sure! I can help you with your programming assignments.
1. Rectangle Class:
To write the Rectangle class, you will need to create a new Java file called "Rectangle.java". In this file, you can define the class with the required constructors and methods. Here's a step-by-step guide on how to implement each of the constructors and methods:
Step 1: Define the class with the appropriate name:
```
public class Rectangle {
// class implementation goes here
}
```
Step 2: Define instance variables for the Rectangle's X and Y coordinates, width, and height:
```
private double x;
private double y;
private double width;
private double height;
```
Step 3: Implement the constructors:
a) Constructor with X, Y, width, and height:
```
public Rectangle(double x, double y, double width, double height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
```
b) Constructor with only width and height:
```
public Rectangle(double width, double height) {
this(0.0, 0.0, width, height);
}
```
c) Default constructor:
```
public Rectangle() {
this(0.0, 0.0, 0.0, 0.0);
}
```
Step 4: Implement the setCenter, setWidth, and setHeight methods:
```
public void setCenter(double x, double y) {
this.x = x;
this.y = y;
}
public void setWidth(double width) {
this.width = width;
}
public void setHeight(double height) {
this.height = height;
}
```
Step 5: Implement the getX, getY, getWidth, and getHeight methods:
```
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getWidth() {
return width;
}
public double getHeight() {
return height;
}
```
Step 6: Implement the getArea and getPerimeter methods:
```
public double getArea() {
return width * height;
}
public double getPerimeter() {
return 2 * (width + height);
}
```
Step 7: Implement the toString method:
```
public String toString() {
return "Rectangle: x = " + x + ", y = " + y + ", width = " + width + ", height = " + height;
}
```
That completes the implementation of the Rectangle class. Now you can save and compile the "Rectangle.java" file.
2. RectangleTest Application:
To test your Rectangle class, you can create another Java file called "RectangleTest.java". In this file, you can create instances of the Rectangle class and use its constructors and methods to perform the required tests. Here's a possible implementation:
```
import java.util.Scanner;
public class RectangleTest {
public static void main(String[] args) {
// Create an instance of Rectangle using the constructor with X, Y, width, and height
Rectangle rectangle1 = new Rectangle(2.5, 3.0, 5.0, 4.0);
System.out.println(rectangle1.toString()); // prints the string representation of the Rectangle
// Create an instance of Rectangle using the constructor with only width and height
Rectangle rectangle2 = new Rectangle(8.0, 6.0);
System.out.println(rectangle2.toString()); // prints the string representation of the Rectangle
// Create an instance of Rectangle using the default constructor
Rectangle rectangle3 = new Rectangle();
System.out.println(rectangle3.toString()); // prints the string representation of the Rectangle
// Use the setCenter, setWidth, and setHeight methods to modify the Rectangle
rectangle3.setCenter(1.0, 1.5);
rectangle3.setWidth(3.0);
rectangle3.setHeight(2.0);
System.out.println(rectangle3.toString()); // prints the updated string representation of the Rectangle
}
}
```
Save and compile the "RectangleTest.java" file, and run it. You should see the output generated by the test cases.
I hope this explanation helps you with your programming assignment! If you have any further questions or need additional information, please let me know.