Question

/**
 * File: GradeCalculator . java
 * Description: Instances of this class are used to calculate
 *  a course average and a letter grade. In order to calculate
 *  the average and the letter grade, a GradeCalculator must store
 *  two essential pieces of data: the number of grades and the sum
 *  of the grades.  Therefore these are declared as object properties
 *  (instance variables).
 *  Each time calcAverage (grade) is called, a new grade is added to
 *  the running total, and the number of grades is incremented.
 */
/**
 *  1) Change the program so that it outputs +/- letter grades (you can decide
 *     the thresholds)
 *  2) Output, in addition to the average and letter grade, the number of grades
 *     entered so far. This requires a new method in the GradeCalculator class:
 *     public int getCount()
 *  3) Modify the addGrade() method in the GradeCalculator class so that it will
 *     reject grades that are out of range... and do not update the grade count if
 *     there is a problem with the grade range.
 *     a) notify the user that the grade has been rejected, but keep the program
 *        running
 *  4) Check user input for errors. The program should handle the entry of characters,
 *     and other non-numeric symbols without causing a crash and display error/informational 
 *     messages in a "new" text box in the panel.  
 */
/**
 *
 *
 */
public class GradeCalculator {
  private int gradeCount = 0; // GradeCalculator 's internal state
  private double gradeTotal = 0.0;
  /**
   *
   * calcAdd() is given a grade, which is added to
   * the running total. It then increments the grade count.
   * @param double grade
   * @return boolean
   */
  // Hint: change code to reject grades out of the range 0 to 100 by returning false, do
  // not update gradeCount if there is an error
  public boolean addGrade (double grade) {
    gradeTotal += grade;
    ++ gradeCount ;
    return true;
  } // calcAdd 
  /**
   * calcAverage() is given a grade, which is added to
   * the running total. It then increments the grade count
   * and returns the running average.
   * @return double average
   */
  public double calcAvg () {
    return gradeTotal / gradeCount ;
  } // calcAvg 
  //  HINT: Add a new public method that returns the gradeCount 
  //  public int getCount() -- fill in rest of code
  /**
   * calcLetterGrade() returns the letter grade for this object.
   * Algorithm: The course average is first computed from the stored
   * gradeTotal and gradeCount and then converted into a
   * letter grade.
   * @return a String representing "A" through "F"
   */
  public String calcLetterGrade () {
    // HINT: Change if/else logic for +/- letter grades
    double avg = gradeTotal / gradeCount ; // Get the average
    if (avg >= 90.0) {
      return "A";
    } else if (avg >= 80.0) {
      return "B";
    } else if (avg >= 70.0) {
      return "C";
    } else if (avg >= 60.0) {
      return "D";
    } else if (avg >= 0) {
      return "F";
    }
    return "Error";
   } // calcLetterGrade ()
} // GradeCalculator 

  /**
   * File: GradeCalcMain . java 
   * Description: This program creates a GradeCalcPanel and
   * adds it to the Frame's content pane and sets its size.
   */
  /**
   * 
   *
   */
  // See GradeCalculator . java for instructions

import javax .swing.*;

public class GradeCalcMain extends JFrame { 
  public GradeCalcMain () {
    getContentPane ().add(new GradeCalcPanel ());
    // register 'Exit upon closing' as a default close operation
    setDefaultCloseOperation ( EXIT_ON_CLOSE );
  } // end GradeCalcFrame () constructor
  public static void main(String args []){
    // change GUI so that it looks like Windows GUI, don't worry about this now
    try {
      UIManager . setLookAndFeel ("com.sun. java .swing. plaf .windows. WindowsLookAndFeel ");
    } catch (Exception e) {}
    GradeCalcMain   aframe = new GradeCalcMain ();
    aframe . setSize (450,75);
    aframe . setVisible (true);
  } // main()
} // GradeCalcMain class 

/**
 * File: GradeCalcPanel . java -
 * This class provides a user interface to
 * the GradeCalc class, which calculates a student's average
 * and letter grade for grades input into a JTextField .
 * The interface consists of input and output JTextFields and
 * and button to calculate the course average and letter grades. 
 * Also, add a text box to display user error/informational messages,
 * similar to resultField. 
 */
/**
 *
 * 
 * 
 */
// See GradeCalculator . java for instructions

import javax .swing.*;
import java . awt .*;
import java . awt .event.*;
import java .text.*;

public class GradeCalcPanel extends JPanel implements ActionListener {
  private JLabel prompt; // GUI components
  private JTextField   inputField ;
  private JLabel   resultLabel ;
  private JTextField   resultField ;
  private JButton button;
  private GradeCalculator calculator;  // The Calculator object

  public GradeCalcPanel () {
    calculator = new GradeCalculator (); // Create a calculator instance
    // setLayout ( new GridLayout (1,5,10,10));
    prompt = new JLabel ("Grade:");
    resultLabel = new JLabel ("Average:");
    inputField = new JTextField (10);
    resultField = new JTextField (20);
    resultField . setEditable (false);
    button = new JButton ("Enter");
    button. addActionListener (this);
    add(prompt);
    add( inputField );
    add(button);
    add( resultLabel );
    add( resultField );
    inputField . setText ("");
  } // end GradeCalcPanel ()

  /**
   * actionPerformed () handles clicks on the button. 
   * It takes the data from the input JTextFields , and sends them to
   * the GradeCalculater class to calculate a running average and
   * computes the letter grade, which are displayed in TextFields .
   * @param e -- the ActionEvent the generated this system call
   */
  public void actionPerformed ( ActionEvent e) {
    double grade, ave;
    DecimalFormat   df = new DecimalFormat ("0.00");
    String inputString = inputField . getText ();
    // HINT: use try/catch blocks to catch bad input to parseDouble ()
    grade = Double. parseDouble ( inputString );
    inputField . setText ("");
    // HINT: reject a bad grade in some way (the modified addGrade will return false
    // there is a problem with the grade
    calculator. addGrade (grade);
    // HINT: output grade count along with average and letter grade
    ave = calculator. calcAvg ();
    String average = "" + df .format(ave);
    String letterGrade = calculator. calcLetterGrade ();
    resultField . setText (average + " " + letterGrade );
  } // end actionPeformed ()
} // end GradeCalcPanel class

Answer 1

#################### GradeCalcMain.class ##############
/**
* File: GradeCalcMain . java
* Description: This program creates a GradeCalcPanel and
* adds it to the Frame's content pane and sets its size.
*/
/**
*
*
*/
// See GradeCalculator . java for instructions

import javax.swing.*;

public class GradeCalcMain extends JFrame {
   public GradeCalcMain() {
       getContentPane().add(new GradeCalcPanel());
       // register 'Exit upon closing' as a default close operation
       setDefaultCloseOperation(EXIT_ON_CLOSE);
   } // end GradeCalcFrame () constructor

   public static void main(String args[]) {
       // change GUI so that it looks like Windows GUI, don't worry about this
       // now
       try {
           UIManager.setLookAndFeel("com.sun. java .swing. plaf .windows. WindowsLookAndFeel ");
       }
       catch (Exception e) {
       }
       GradeCalcMain aframe = new GradeCalcMain();
       aframe.setSize(450, 75);
       aframe.setVisible(true);
   } // main()
} // GradeCalcMain class

###################### GradeCalcPanel.java #################
/**
* File: GradeCalcPanel . java -
* This class provides a user interface to
* the GradeCalc class, which calculates a student's average
* and letter grade for grades input into a JTextField .
* The interface consists of input and output JTextFields and
* and button to calculate the course average and letter grades.
* Also, add a text box to display user error/informational messages,
* similar to resultField.
*/
/**
*
*
*
*/
// See GradeCalculator . java for instructions

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.text.*;

public class GradeCalcPanel extends JPanel implements ActionListener {
   private JLabel prompt; // GUI components
   private JTextField inputField;
   private JLabel resultLabel;
   private JTextField resultField;
   private JButton button;
   private GradeCalculator calculator; // The Calculator object

   public GradeCalcPanel() {
       calculator = new GradeCalculator(); // Create a calculator instance
       // setLayout ( new GridLayout (1,5,10,10));
       prompt = new JLabel("Grade:");
       resultLabel = new JLabel("Average:");
       inputField = new JTextField(10);
       resultField = new JTextField(20);
       resultField.setEditable(false);
       button = new JButton("Enter");
       button.addActionListener(this);
       add(prompt);
       add(inputField);
       add(button);
       add(resultLabel);
       add(resultField);
       inputField.setText("");
   } // end GradeCalcPanel ()

   /**
   * actionPerformed () handles clicks on the button. It takes the data from
   * the input JTextFields , and sends them to the GradeCalculater class to
   * calculate a running average and computes the letter grade, which are
   * displayed in TextFields .
   * @param e -- the ActionEvent the generated this system call
   */
   public void actionPerformed(ActionEvent e) {
       double grade, ave;
       DecimalFormat df = new DecimalFormat("0.00");
       String inputString = inputField.getText();
       // HINT: use try/catch blocks to catch bad input to parseDouble ()
       try {
           grade = Double.parseDouble(inputString);
           inputField.setText("");
           // HINT: reject a bad grade in some way (the modified addGrade will
           // return false
           // there is a problem with the grade
           if (calculator.addGrade(grade)) {
               // HINT: output grade count along with average and letter grade
               ave = calculator.calcAvg();
               String average = "" + df.format(ave);
               String letterGrade = calculator.calcLetterGrade();
               int count = calculator.getCount();
               resultField.setText(average + " " + letterGrade + " count: " + count);
           }
           else {
               JOptionPane.showMessageDialog(null, "Grade is out of range", "InfoBox: error", JOptionPane.ERROR_MESSAGE);
           }
       }
       catch (Exception ex) {
           JOptionPane.showMessageDialog(null, "Invalid grade", "InfoBox: error", JOptionPane.ERROR_MESSAGE);
       }

   } // end actionPeformed ()
} // end GradeCalcPanel class

################### GradeCalculator.java ##################

/**
* File: GradeCalculator . java
* Description: Instances of this class are used to calculate
* a course average and a letter grade. In order to calculate
* the average and the letter grade, a GradeCalculator must store
* two essential pieces of data: the number of grades and the sum
* of the grades. Therefore these are declared as object properties
* (instance variables).
* Each time calcAverage (grade) is called, a new grade is added to
* the running total, and the number of grades is incremented.
*/
/**
* 1) Change the program so that it outputs +/- letter grades (you can decide
* the thresholds)
* 2) Output, in addition to the average and letter grade, the number of grades
* entered so far. This requires a new method in the GradeCalculator class:
* public int getCount()
* 3) Modify the addGrade() method in the GradeCalculator class so that it will
* reject grades that are out of range... and do not update the grade count if
* there is a problem with the grade range.
* a) notify the user that the grade has been rejected, but keep the program
* running
* 4) Check user input for errors. The program should handle the entry of characters,
* and other non-numeric symbols without causing a crash and display error/informational
* messages in a "new" text box in the panel.
*/
/**
*
*
*/
public class GradeCalculator {
   private int gradeCount = 0; // GradeCalculator 's internal state
   private double gradeTotal = 0.0;

   /**
   *
   * calcAdd() is given a grade, which is added to the running total. It then
   * increments the grade count.
   * @param double grade
   * @return boolean
   */
   // Hint: change code to reject grades out of the range 0 to 100 by returning
   // false, do
   // not update gradeCount if there is an error
   public boolean addGrade(double grade) {
       if (grade >= 0 && grade <= 100) {
           gradeTotal += grade;
           ++gradeCount;
           return true;
       }
       return false;
   } // calcAdd

   /**
   * calcAverage() is given a grade, which is added to the running total. It
   * then increments the grade count and returns the running average.
   * @return double average
   */
   public double calcAvg() {
       return gradeTotal / gradeCount;
   } // calcAvg
       // HINT: Add a new public method that returns the gradeCount
       // public int getCount() -- fill in rest of code

   /**
   * calcLetterGrade() returns the letter grade for this object. Algorithm:
   * The course average is first computed from the stored gradeTotal and
   * gradeCount and then converted into a letter grade.
   * @return a String representing "A" through "F"
   */
   public String calcLetterGrade() {
       // HINT: Change if/else logic for +/- letter grades
       double avg = gradeTotal / gradeCount; // Get the average
       if (avg >= 97.0) {
           return "A+";
       }
       else if (avg >= 93.0 && avg < 97.0) {
           return "A";
       }
       else if (avg >= 90.0 && avg < 93.0) {
           return "A-";
       }
       else if (avg >= 87.0 && avg < 90.0) {
           return "B+";
       }
       else if (avg >= 83.0 && avg < 87.0) {
           return "B";
       }
       else if (avg >= 80.0 && avg < 83.0) {
           return "B-";
       }
       else if (avg >= 77.0 && avg < 80.0) {
           return "C+";
       }
       else if (avg >= 73.0 && avg < 77.0) {
           return "C";
       }
       else if (avg >= 70.0 && avg < 73.0) {
           return "C-";
       }
       else if (avg >= 67.0 && avg < 70.0) {
           return "D+";
       }
       else if (avg >= 63.0 && avg < 67.0) {
           return "D";
       }
       else if (avg >= 50.0 && avg < 63.0) {
           return "D-";
       }
       else if (avg < 50) {
           return "F";
       }
       return "Error";
   } // calcLetterGrade ()

   public int getCount() {
       return gradeCount;
   }
} // GradeCalculator