Scribd
Upload
23 views2 pages

Java 2D Point Class Implementation

Java labprograms

Uploaded by

madhukeshs605
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
23 views2 pages

Java 2D Point Class Implementation

Java labprograms

Uploaded by

madhukeshs605
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Program 4:

A class called MyPoint, which models a 2D point with x and y coordinates, is designed as follows:

 Two instance variables x (int) and y (int).


 A default (or "no-arg") constructor that construct a point at the default location of (0,0).
 A overloaded constructor that constructs a point with the given x and y coordinates.
 A method setXY() to set both x and y.
 A method getXY() which returns the x and y in a 2-element int array.
 A toString() method that returns a string description of the instance in the format "(x,y)".
 A method called distance(int x, int y) that returns the distance from this point to another point at the
given (x, y) coordinates
 An overloaded distance(MyPoint another) that returns the distance from this point to the given MyPoint
instance (called another)
 Another overloaded distance() method that returns the distance from this point to the origin (0,0)
Develop the code for the class MyPoint. Also develop a JAVA program (called TestMyPoint) to test all the
methods defined in the class.

package [Link];

public class My_Point


{
private int x;
private int y;

// Constructor with parameters


public My_Point(int i, int j)
{
this.x = i; // Assign parameters i and j to instance variables
this.y = j;
}

// Default constructor
public My_Point() {
this(0, 0); // Call the parameterized constructor
}

// Method to set x and y


public void setXY(int x, int y)
{
this.x = x;
this.y = y;
}

// Method to get x and y as an array


public int[] getXY()
{
int[] xy = new int[2];
xy[0] = x;
xy[1] = y;
return xy;
}

// Override toString method


@Override
public String toString() {
return "(" + x + ", " + y + ")";
}
// Calculate distance to another point (x, y)
public double distance(int x, int y) {
return [Link]([Link](this.x - x, 2) + [Link](this.y - y, 2));
}

// Calculate distance to another My_Point object


public double distance(My_Point another) {
return [Link]([Link](this.x - another.x, 2) + [Link](this.y - another.y, 2));
}

// Calculate distance from the origin (0,0)


public double distance()
{
return [Link]([Link](this.x, 2) + [Link](this.y, 2));
}
}

// Main class
class My_Point_main
{
public static void main(String[] args)
{
My_Point p1 = new My_Point();
[Link](p1); // (0, 0)

My_Point p2 = new My_Point(3, 4);


[Link](p2); // (3, 4)

[Link](5, 6);
[Link](p1); // (5, 6)

int[] xy = [Link]();
[Link](xy[0]); // 5
[Link](xy[1]); // 6

[Link]([Link](2, 3)); // Distance from (5,6) to (2,3)


[Link]([Link](p2)); // Distance from (5,6) to (3,4)
[Link]([Link]()); // Distance from (5,6) to origin
}
}

Output:
(0, 0)
(3, 4)
(5, 6)
5
6
4.242640687119285
2.8284271247461903
7.810249675906654

Common questions

Powered by AI

The toString() method improves the usability of the MyPoint class by providing a human-readable format for the point's coordinates, which is especially useful in test and debug scenarios. It allows for easy logging of object states, making it simpler to verify behaviors during development without manually extracting and formatting coordinate values .

The MyPoint class is designed to model a 2D point with integer x and y coordinates. It includes the following key functionalities: two instance variables for x and y, a default constructor initializing these to (0,0), and an overloaded constructor for specific values. There are methods to set and get the coordinates, the latter returning them in a 2-element array. The class overrides toString() to output the point in "(x,y)" format and provides three distance methods: one for a specific pair of coordinates, one for another MyPoint instance, and one for the distance to the origin .

The potential limitations of the MyPoint class design might include the absence of bounds checking in the setXY() method, which could result in invalid states if used improperly. Additionally, using integer types for coordinates may not provide the precision required for certain applications, suggesting a limitation in accuracy. Moreover, the getXY() method returning an array could lead to mutable state exposure, which can be risky if not handled carefully .

The distance method that takes a MyPoint object calculates the Euclidean distance between the current point and another point represented by the parameter object. It squares the differences in x and y coordinates, sums them, and takes the square root of the result. This method is useful because it allows for calculating distances based on object references, simplifying comparisons between instances of MyPoint .

Including a method for calculating the distance from the origin in the MyPoint class provides a quick way to determine how far a point is from the coordinate system's origin (0,0). This can be advantageous in applications where positional hierarchy or proximity matters, such as spatial analysis or graphical rendering, where distances from a base point need frequent computation .

Encapsulation in the MyPoint class is maintained by declaring the instance variables x and y as private and providing public methods like setXY() and getXY() for accessing and modifying these fields. This encapsulation ensures internal data integrity by controlling how data is accessed or modified, thus preventing unintended side effects and maintaining the class's internal consistency—an essential aspect of robust object-oriented design .

The getXY() method's design choice to return coordinates as an array provides a straightforward way to access both x and y coordinates simultaneously, promoting convenience in scenarios where both are required together. However, this choice sacrifices some type safety, as arrays are mutable and could lead to unintended modifications if not properly handled. Despite this, it enhances usability by simplifying operations that need both values instead of calling separate methods for each coordinate .

The overloaded constructor in the MyPoint class enhances functionality by allowing the creation of a point at any given x and y coordinates, rather than just the default (0,0). This flexibility is essential for initializing objects with specific starting positions, making the class more versatile for various applications .

The MyPoint class utilizes object-oriented principles by abstracting the concept of a 2D point with its x and y coordinates encapsulated within the class. It exposes only necessary behaviors, such as setting coordinates and calculating distances, through public methods while keeping the internal state private. This design promotes reusability, modularity, and enhances maintainability by decoupling the class's implementation from its interface, enabling users to manipulate 2D points without delving into the underlying mechanics .

Method overloading enhances distance functionality by offering multiple ways to calculate distance based on different inputs: to a given set of coordinates, another MyPoint object, or the origin. This flexibility caters to varied computational needs without requiring additional logic outside the class, streamlining usage and maintaining encapsulation and clarity in how distance is understood and operated upon in different contexts .

You might also like