In elementary mathematics of 2-dimensions, each point on the plane (or paper or screen, if you like) can be represented by a pair of numbers, (x, y), where xtells you the horizontal location of the point and y tells you the vertical location. The values are relative to some "origin" (0,0). So (3.1, 0) is the point 3.1units to the right of the origin, and (-3.6, 5) is the point 3.6 units to the left of the origin and 5 units above it. This allows us to label every point in the plane with a unique (x,y) coordinate pair. The two numbers, x and y, are called the coordinates of the point.
Create a class called Point that has the following private members:
Point should also contain private static MIN_VAL and MAX_VAL - which are initialized to -10.0 and +10.0, respectively. These will represent the legal range of both the x andy coordinates for all Points in the class. It is important that these be static values since all objects will share the same range limits.
If you wish, you can let x and y (and the two statics) be doubles. If you do, adjust the data types of corresponding members below to be compatible with your choice.
Supply the following instance members:
Also create a public static method:
Create another class called Polygon that has the following members:
You should supply all of the following (at a minimum):
For example, the x-y coordinates of the first (really 0th) Point in the Polygon would come from x_array and y_array, the x-y coordinates of the second (really 1st) Point in the Polygon would come from x_array and y_array, the x-y coordinates of the third (really 2nd) Point in thePolygon would come from x_array and y_array, and so on. (The two arrays are called parallel arrays because they work together (in parallel) to specify the Points: if you want to get the coordinates of the kth Point in the Polygon, you would use the x_array[k] for the x-coordinate andy_array[k] for the y-coordinate.)
The actual arrays passed might be larger than the int num_points passed, and that's okay! We only use the first num_points elements of the two arrays. For example, the arrays might each be 100 elements, but if num_points is 3, we are only using the first three elements of each array. Only supply these two constructors and no other.
boolean SetPoints(int num_points, float x_values, float y_values) - a mutator that takes an int, num_points, and two float arrays. The two float arrays provide the x-y coordinates of the Points in the requested Polygon in the same manner described in detail for the constructor, above. This method overwrites any values in the existing object, and creates a fresh Polygon from scratch - it does not append points to the existing Polygon.Return false (error) if the internal points array is smaller than num_points or if num_points is < 0. There is another possible reason for failure (falsereturn) that you must consider - this is part of your assignment. Do not ask what it is, but figure it out based on the information above.
void ShowPolygon() - displays the points in the Polygon as a text string such as "(3.5, 1.2), (-9.1, 5.5), (0.120, -0.30)", ...."
boolean AddPoint( float x, float y) - adds (appends) a new Point to the list, but only if there is room!
boolean AddPoint (Point p) - adds (appends) a new Point to the list, but only if there is room!
As always, make sure that mutators, constructors and any methods that affect private data filter out bad parameters from the client.
This example gives lots of opportunity to use/invoke some methods to make other methods' lives easier. Make sure you are not duplicating code, but exploiting this opportunity.
We don't care if a Polygon's points cause it to be drawn with sides crossing (if we were to draw it, which most of you will not). Any list of (x,y) pairs will be considered a valid Polygon, assuming that they are valid Points.
Polygon and Point should be classes distinct from (and not contained within) your main class (which we call Foothill).
Generate a sample main() that tests your classes.
Establish one set of min/max values for the statics in the Point class using the static mutator.
Set and display a few Point objects manually. Check that your range limitation works by attempting to set values of one Point outside the range and proving that your Point rejects this attempt.
Next, instantiate three Polygons manually from literal values in your program, i.e., do not involve the user with run-time input.
Two Polygons should be constructed with float arrays arguments for the x and y values, instantly populating the Polygon. The third should be instantiated using the default constructor, then filled with points using the mutator methods. Use different coordinate values for the Points for all threePolygons (i.e., don't create two identical Polygons).
Display the Polygons.
Make changes to the Polygons using the mutators of that class and display them again. In at least one Polygon mutator call, attempt to set values illegally (in any sense of the word based on the above criteria) and prove that your class protects against this attempt.