Objective Develop a collection of commonly used methods.

Discussion In this lab you will be building up a small library of methods that we may find useful at some later time. A little time spent now, carefully considering how these methods ought to be written, can save considerable amounts of time later when code reuse can be employed.

While we will not always know the context in which a method will be used, we can generally make a reasonable guess. Whenever possible, we should try to make the implementation of a method as general as possible. This includes:

• Careful thought about the appropriate information to be passed to each method.
• Consideration of the most general types that can be used for parameters and return values.
• Minimize, if possible, side-effects.
• Appropriate documentation of pre- and post-conditions.

1. A method that picks a random number between low and high, inclusive.

2. A method that picks a random floating point number between low and high.

3. A method to compute the distance between two Points.

4. A method to compute the midpoint of two Points.

5. A predicate to determine if two Circles overlap.

6. A predicate to determine if two Rectangles overlap.

class Point {
  double x, y;
  Point(double x, double y) {
    this.x = x; 
    this.y = y;
  }
  public String toString() {
    return "I am a Point at (" + x + ", " + y + ")"; 
  }
} 

class Circle {
  private double radius, x, y; 
  Circle(double r, double x, double y) {
    radius = r; 
    this.x = x; 
    this.y = y; 
  }
  Point center() {
    return new Point(this.x, this.y); 
  }
  double radius() {
    return radius; 
  }
} 

class Rectangle {
  double x, y, width, height; 
  Rectangle(double x, double y, double width, double height) {
    this.x = x; 
    this.y = y;
    this.width = width;
    this.height = height; 
  }
} 

If you were to run the following tests

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) 
        System.out.println(LabEight.random(-14, -8)); 
    for (int i = 0; i < 10; i++) 
        System.out.println(LabEight.random(3.2, 3.9));  
    Point p1 = new Point(1, 4); 
    Point p2 = new Point(5, 1); 
    System.out.println(LabEight.distance(p1, p2)); 
    Point p3 = LabEight.midpoint(p1, p2); 
    System.out.println(p3); 
    Circle c1 = new Circle(10, 3,  3); 
    Circle c2 = new Circle( 9, 3, 21); 
    System.out.println(
        "Circles overlap? The answer is: " + LabEight.overlaps(c1, c2));
    Rectangle r1 = new Rectangle(5, 5, 5, 5);  
    Rectangle r2 = new Rectangle(7, 1, 2, 2);
    System.out.println(
        "Rectangles overlap? The answer is: " + LabEight.overlaps(r1, r2)); 
}

frilled.cs.indiana.edu%java LabEight
-13
-9
-10
-14
-8
-13
-12
-13
-8
-14
3.8893441296921716
3.8197796997135343
3.7198162871052696
3.5426342839050067
3.723866363497135
3.8542103463665556
3.762537621124611
3.862830975636286
3.397977654009052
3.2720480907723437
5.0
I am a Point at (3.0, 2.5)
Circles overlap? The answer is: true
Rectangles overlap? The answer is: false
frilled.cs.indiana.edu%

1. We go through three stages:

• First we need to identify the inputs of this procedure.
• Then we need to describe the type of result (or output, if any).
• Then we will need to describe how (the method by which) we obtain the result.

1. an integer number low representing the lower endpoint of the interval
2. an integer number high representing the higher endpoint of the interval

1. a value that is random and in between low and high inclusive

First compute the number of possible outcomes in the interval:

int num = (high - low + 1); 

Then obtain a random number between 0 and 1.

double per = Math.random(); 

Scale this number to the interval we're working with.

int val = (int) (per * num); 

Translate the value into the desired range and return it.

return (val + low);

2. This problem is very much related to the previous one.

So the description here will be a bit more general.

Inputs:

1. an floating-point number low representing the lower endpoint of the interval
2. an floating-point number high representing the higher endpoint of the interval

1. a floating point value that is random and in between low and high

Also, the problem doesn't say if the output includes high or not, so this is up to you.

Method:

It depends how you're generating the random numbers but most likely they will be random numbers between 0 and 1, let's call it val.

This value can be looked at as a percentage.

The length of the target interval is

(high - low)

so if we want to translate val into a location on the segment from low to high we will have to multiply the length of the interval by the percentage:

val * (high - low) 

This is a number that represents a fraction of the length of the target interval between low and high. If we add low to this we will obtain the desired random number that corresponds to val and falls in between low and high and we could return it:

return val * (high - low) + low; 

As we said it depends on the source you're using. The book says there are two such sources that you could use: Math.random or a Random object which could return nextFloat(). In both cases the method described here would work.

3. Again, you are being asked to turn a solution in a procedure. How do you proceed. First solve the problem by itself, at least once. Then turn your solution into a procedure by looking at what's general in your solution. Here we need to compute the distance between two points.

How do you solve this problem? Here's a picture:

Here's an implementation:

public class Test {
    public static void main(String[] args) {
	Point p, q; 
	p = new Point(2, 4); 
        q = new Point(6, 1); 
        double distance; 
        int h, v; 
        h = Math.abs(p.x() - q.x()); 
	v = Math.abs(p.y() - q.y()); 
	distance = Math.sqrt(h * h + v * v); 
	System.out.println(distance); 
    } 
} 

public class Test {
    public static void main(String[] args) {
	Point p, q; 
	p = new Point(2, 4); 
        q = new Point(6, 1); 
        double distance; 
        distance = LabEight.computeDistanceBetween(p, q); 
	System.out.println(distance); 
    } 
} 

class LabEight {
    public static double computeDistanceBetween(Point p, Point q) {  
        int h, v;
        h = Math.abs(p.x() - q.x()); 
	v = Math.abs(p.y() - q.y()); 
	return Math.sqrt(h * h + v * v); 
    }
}

Note that the code above assumes Point has two accessors, for the coordinates. If you don't implement them (and the class I provided does not have them, but they are easy to write so you can make the change yourself) then simply remove the parens, to work directly with the variables. It's up to you. Encapsulation is not the central point here, when we look at the distance method. But the preferred method would indeed be to have accessors with private instance variables (in general).

When we create a method we follow these steps:

1. Write and test the code that implements the procedure.

   We've done this in Test.java

2. Identify what the code needs (inputs) and what it produces (outputs).

   Our procedure needs the two points. It should have as the result the distance between the two points, most likely a number with decimals.

3. The inputs are called parameters, and they have to be listed as formal parameters. They have types. Their number and order are important. They should be given names, used in the definition of the procedure.

   We call the parameters, the two points, p and q. Their type is Point.

4. Come up with a descriptive name for the procedure (or method). The name of the procedure together with the number and types of the parameters (in the order in which they are listed) is called the signature of the method. There cannot be two methods with the same signature in the same class.

   We decided to call it computeDistanceBetween. Other names are possible.

5. If the method returns a result, make sure you specify that in the definition of the method. Otherwise mark it as void (that is, as not returning a result).

   Our method returns a double.

The section above removes all mistery about it, but here's the overview anyway:

Inputs:

1. Point p
2. Point q

• a floating point value that represents the distance between p and q