Exam 1: Java Fundamentals

/**
 * Fractions with integer numerators and denominators.  Once
 * the value of a fraction has been set, that value should
 * not be changed.
 *
 * @author Samuel A. Rebelsky
 * @author Fillip Fictitious
 * @author Fiona Fictitious
 * @version 1.0 of February 2000
 */
public class Fraction
{
  // +--------+--------------------------------------------------
  // | Fields |
  // +--------+

  /** The numerator of the fraction.  Can be positive or negative. */
  protected int num;

  /** The denominator of the fraction.  Should be positive. */
  protected int denom;

  // +--------------+--------------------------------------------
  // | Constructors |
  // +--------------+

  /**
   * Build a new fraction with value A/B.
   */
  public Fraction(int A, int B)
  {
    this.num = A;
    this.denom = B;
    this.cleanup();
  } // Fraction(int,int)

  // +------------+----------------------------------------------
  // | Extractors |
  // +------------+

  /** Get the numerator of the fraction. */
  public int getNumerator() {
    return this.num;
  } // getNumerator()

  /** Get the denominator of the fraction. */
  public int getDenominator() {
    return this.denom;
  } // getDenominator()

  /** Return the fraction as a string. */
  public String toString() {
    return this.num + "/" + this.denom;
  } // toString()

  // +-------------------------+---------------------------------
  // | Mathematical Operations |
  // +-------------------------+

  /** 
   * Add this fraction to another fraction, creating a third
   * fraction for the result.
   */
  public Fraction add(Fraction other) {
    // A/B + C/D = (AD + BC)/BD
    int num = this.num*other.denom + other.num*this.denom;
    int denom = other.denom*this.denom;
    return new Fraction(num,denom);
  } // add(Fraction)

  /**
   * Multiply this fraction by another fraction, creating
   * a new fraction.
   */
  public Fraction multiply(Fraction other) {
    // A/B * C/D = (A*C)/(B*D)
    return new Fraction(this.num*other.num,
                        this.denom*other.denom);
  } // multiply(Fraction)

  /**
   * Divide this fraction by another fraction, creating
   * a new fraction.
   */
  public Fraction divide(Fraction other) {
    // A/B / C/D = A/B * 1/(C/D) = A/B * D/C = (AD)/(BC)
    return new Fraction(this.num*other.denom,
                        this.denom*other.num);
  } // divide(Fraction);

  /**
   * Negate this fraction, creating a new fraction.
   */
  public Fraction negate()
  {
    // -(A/B) = (-A)/B
    return new Fraction(-this.num, this.denom);
  } // negate()

  /**
   * Subtract another fraction from this fraction, creating
   * a new fraction for the result.
   */
  public Fraction subtract(Fraction other)
  {
    return add(other.negate());
  } // subtract(Fraction)


  // +-----------+-----------------------------------------------
  // | Modifiers |
  // +-----------+

  // This class has no modifiers.

  // +---------+-------------------------------------------------
  // | Helpers |
  // +---------+

  /** 
   * "Clean up" the fraction to ensure that the numerator and
   * denominator meet the appropriate standards.
   */
  protected void cleanup()
  {
    // If the denominator is negative, multiply both parts
    // by -1 to make it positive without changing the value
    // of the fraction.
    if (this.denom < 0) {
      this.denom = -this.denom;
      this.num = -this.num;
    }
  } // cleanup()

} // class Fraction

  /** Compute 1/3 + 2/7. */
  public static void main(String[] args) {
    SimpleOutput out = new SimpleOutput();
    Fraction frac = new Fraction(1,3);
    frac.add(new Fraction(2,7));
    out.println(frac.toString());
  } // main(String[])

  /**
   * Convert this fraction to a floating-point value.
   */
  public float toFloat()
  {
    // STUB.  What should go here?
    return 0;
  } // toFloat()

  public Fraction(int num, int denom)
  {
    this.numerator = num;
    this.denominator = denom;
    this.cleanup();
    this.simplify();
  } // Fraction(int, int)

  public void simplify()
  {
    int common;	// The greatest common divisor
    // Compute the greatest common divisor.
    // If the numerator is negative, make it positive for the
    // purposes of GCD, since Euclid said "two positive numbers"
    if (this.num < 0)
      common = gcd(-this.num, this.denom);
    else
      common = gcd(this.num, this.denom);
    // Divide numerator and denominator by the gcd.
    this.num = this.num / common;
    this.denom = this.denom / common;
  } // simplify()

  protected static int gcd(int x, int y)
  {
    // STUB
    return 1;
  } // gcd(int,int)

/** Create the fraction whose value is val. */
public Fraction(int val) {
  // STUB
} // Fraction(int)

/**
 * Return true about one-thrid of the time.
 */
protected boolean whatever()
{
  return Math.random() < .333;
} // whatever()

public class Point{
  public double distanceFromOrigin() {
    return Math.sqrt(this.x
      *this.x + this.y *
this.y);
}

    public Point(double x, double y) {
      this.x = x; this.y = y; 
    }

protected double x;

  public void set(double newX, double newY) {
    this.x = newX;
    this.y = newY;
  }

  public String toString()
  { return "(" + this.x + "," + this.y + ")"; } public double getX() {
    return this.x;
  }

  public double getY
  () {
    return this.y;
  }

    public Point() { this.x = 0; this.y = 0; } protected double y;

  public int getQuadrant()
  { if (
      (this.x > 0) && (this.y > 0)
         ) { return 1; } else
    if ((
      this.x < 0
    ) && (
      this.y > 0
       )) { return 2;
}else
    if((this.x < 0)&&(this.y<    0)
    ) { return 3;

}
    else
      if ((this.x > 0) && (this.y < 0)) { return 4; }
                   else {
return 0; }}}
    

import Point;
import SimpleOutput;

/**
 * Some simple tests of the Point class.   Distributed to help
 * students develop and test their classes.
 *
 * @author Samuel A. Rebelsky
 * @version 1.0 of February 2000
 */
public class PointTester {
  /**
   * A helper function that can print out some information
   * about a point.  Note that this is static because it
   * does not need to use any fields or non-static methods
   * from this class.
   */
  public static void report(SimpleOutput pen, Point pt)
  {
    pen.println(pt.toString());
    pen.println("  x: " + pt.getX());
    pen.println("  y: " + pt.getY());
    pen.println("  distance: " + pt.distanceFromOrigin());
    pen.println("  quadrant: " + pt.getQuadrant());
    pen.println();
  } // report(SimpleOutput, Point)

  public static void main(String[] args)
  {
    // Prepare for output.
    SimpleOutput output = new SimpleOutput();
    // Do the tests.  The tests should be self documenting.
    output.println("Testing zero-parameter constructor");
    report(output, new Point());
    output.println("Testing point (1,3)");
    Point pt = new Point(1,3);
    report(output, pt);
    output.println("Setting value to (-3,4)");
    pt.set(-3,4);
    report(output, pt);
    output.println("Setting  value to (0,-10)");
    pt.set(0,10);
    report(output, pt);
  } // main(String[])
} // class PointTester