Question

The first programming project involves writing a program that computes the minimum, the maximum and the average weight of a collection of weights represented in pounds and ounces that are read from an input file. This program consists of two classes. The first class is the Weight class, which is specified in integer pounds and ounces stored as a double precision floating point number. It should have five public methods and two private methods:

1. A public constructor that allows the pounds and ounces to be initialized to the values supplied as parameters.

2. A public instance method named lessThan that accepts one weight as a parameter and returns whether the weight object on which it is invoked is less than the weight supplied as a parameter.

3. A public instance method named addTo that accepts one weight as a parameter and adds the weight supplied as a parameter to the weight object on which it is invoked. It should normalize the result.

4. A public instance method named divide that accepts an integer divisor as a parameter. It should divide the weight object on which the method is invoked by the supplied divisor and normalize the result.

5. A public instance toString method that returns a string that looks as follows: x lbs y oz, where x is the number of pounds and y the number of ounces. The number of ounces should be displayed with three places to the right of the decimal.

6. A private instance method toOunces that returns the total number of ounces in the weight object on which is was invoked.

7. A private instance method normalize that normalizes the weight on which it was invoked by ensuring that the number of ounces is less than the number of ounces in a pound.

Both instance variable must be private. In addition the class should contain a private named constant that defines the number of ounces in a pound, which is 16. The must not contain any other public methods.

The second class should be named Project1. It should consist of the following four class (static) methods.

1. The main method that reads in the file of weights and stores them in an array of type Weight. It should then display the smallest, largest and average weight by calling the remaining three methods. The user should be able to select the input file from the default directory by using the JFileChooser class. The input file should contain one weight per line. If the number of weights in the file exceeds 25, an error message should be displayed and the program should terminate.

2. A private class method named findMinimum that accepts the array of weights as a parameter together with the number of valid weights it contains. It should return the smallest weight in that array.

3. A private class method named findMaximum that accepts the array of weights as a parameter together with the number of valid weights it contains. It should return the largest weight in that array.

4. A private class method named findAverage that accepts the array of weights as a parameter together with the number of valid weights it contains. It should return the average of all the weights in that array.

Be sure to follow good programming style, which means making all instance variables private, naming all constants and avoiding the duplication of code. Furthermore you must select enough different input files to completely test the program.

Answer 1

CODE:

//weight class
public class Weight
{
   //defining private variables pound, ounces and number of ounces in pound which is 16
   private int pounds;
   private double ounces;
   private int numberOfOuncesInPound=16;
   //constructor which initializes the weight variable with the coming input
   public Weight(int p, double o)
   {
       this.pounds=p;
       this.ounces=o;
   }
   //checks if the incoming weight object is less than the current object weight
   public boolean lessThan(Weight w)
   {
       //first comparison between pounds of the objects, if current object is less, then return true
       if(this.pounds<w.pounds)
           return true;
       //else if it is less then return false
       else if(this.pounds>w.pounds)
           return false;
       //else if both are equal then we compare the ounces
       else
       {
           //if current object ounces is less than we return true else false
           if(this.ounces<w.ounces)
               return true;
           else
               return false;
       }
   }
   //adds incoming weight to the current weight object and then normalize it
   public void addTo(Weight w)
   {
       this.pounds+=w.pounds;
       this.ounces+=w.ounces;
       normalize();
   }
   //divide the current weight with factor x which is a parameter of the function
   public void divide(int x)
   {
       this.ounces=toOunces();
       this.ounces/=x;
       this.pounds=0;
       normalize();
   }
   //returns a string which contains the data in a Particular Format
   public String toString()
   {
       return this.pounds+" lbs "+this.ounces+" oz";
   }
   //returns weight converted into ounces
   private double toOunces()
   {
       return this.pounds*this.numberOfOuncesInPound+this.ounces;
   }
   //this function checks if number of ounces is greater than 16 then it normalizes it by converting into pounds
   private void normalize()
   {
       while(this.ounces>this.numberOfOuncesInPound)
       {
           this.ounces-=this.numberOfOuncesInPound;
           this.pounds++;
       }
   }
}

1 //weight class 2 public class Weight // defining private variables pound, ounces and number of ounces in pound which is 16 private int pounds; private double ounces; private int numberOfOunces In Pound=16; //constructor which initializes the weight variable with the coming input public Weight (int P, double o) this.pounds=p; this.ounces=0; //checks if the incoming weight object is less than the current object weight public boolean less Than (Weight w) TWO CO Jan WN ση - ο ο ο Ε ω ω ω ω ω Ν Ν Ν Ν Ν Ν Ν Ν Ν Ν ΕΕΕΕΕΕΕΕΕΕ ω η ση - ο ο ο Μ ω Β //first comparison between pounds of the objects, if current object is less, then return true if(this.pounds<w.pounds) return true; //else if it is less then return false else if(this.pounds>w.pounds) return false; //else if both are equal then we compare the ounces else //if current object ounces is less than we return true else false if(this.ounces<w.ounces) return true; else return false; //adds incoming weight to the current weight object and then normalize it public void addTo (Weight w)

لا ع rr ا ا ا ا ا ادامه ای که به ما د ا د ا ما لا ا د به او بیا د ا با ما ه داده اه اه ا ع 1 ? public void addTo (Weight w) 0 0 0 0 this.pounds+=w.pounds; this.ounces+=w.ounces; normalize(); 0 0 0 0 | 1/divide the current weight with factor x which is a parameter of the function public void divide (int x) | | | | this.ounces=toOunces(); this.ounces/=x; this.pounds=0; normalize(); | | | | 0 //returns a string which contains the data in a particular Format public String toString() 0 | | 0 | return this.pounds+" lbs "+this.ouncest" OZ"; | | //returns weight converted into ounces private double toOunces() | return this.pounds this.numberOfOunces In Pound+this.ounces; 0 0 0 0 //this function checks if number of ounces is greater than 16 then it normalizes it by converting into pounds private void normalize() 0 0 0 0 while(this.ounces>this.numberOfOunces In Pound) 0 0 0 this.ounces-=this.numberOfOunces In Pound; this.pounds++; 0 0 } 66 67 } Activate

//Project1 class

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

import javax.swing.JFileChooser;
import javax.swing.JPanel;

public class Project1
{
   //findMinimum function takes weight array input and size of array and returns weight which is minimum in array
   private static Weight findMinimum(Weight[] w,int sizeOfArray)
   {
       //initializing minimumWeight to first element of the array
       Weight minimumWeight = w[0];
       //traverse through all the array and then compares using "lessThan" function
       //if "minimumWeight" is greater than array "i-th" element, then we change the minimumWeight to "i-th" element
       for(int i=1;i<sizeOfArray;i++)
       {
           if(!(minimumWeight.lessThan(w[i])))
           {
               minimumWeight=w[i];
           }
       }
       //returns the minimumWeight
       return minimumWeight;
   }
   //findMaximum function takes weight array input and size of array and returns weight which is maximum in array
   private static Weight findMaximum(Weight[] w,int sizeOfArray)
   {
       //initializing maximumWeight to first element of the array
       Weight maximumWeight = w[0];
       //traverse through all the array and then compares using "lessThan" function
       //if "maximumWeight" is less than array "i-th" element, then we change the maximumWeight to "i-th" element
       for(int i=1;i<sizeOfArray;i++)
       {
           if(maximumWeight.lessThan(w[i]))
           {
               maximumWeight=w[i];
           }
       }
       //returns the maximumElement
       return maximumWeight;
   }
   //findAverage function takes weight array input and size of array and returns weight which is average
   public static Weight findAverage(Weight[] w, int sizeOfArray)
   {
       //initializing a variable "averageWeight" to 0 pound 0 ounces
       Weight averageWeight = new Weight(0,0);
       //adding all the array elements to "averageWeight" variable and then normalizing it
       for(int i=0;i<sizeOfArray;i++)
       {
           averageWeight.addTo(w[i]);
       }
       //dividing the "averageWeight" variable by sizeOfArray to get the average
       averageWeight.divide(sizeOfArray);
       //returns the averageWeight
       return averageWeight;
   }
   //main function
   public static void main(String[] args) throws IOException
   {
       //defining an array of weight with size of 25
       Weight w[]= new Weight[25];
       //variable to count number of weights in the file, initializing it to 0
       int countNoOfWeights = 0;
       //creating a jFilechoose object to get the file
       JFileChooser fileChooser = new JFileChooser();
       //setting the default directory, change according to your need
       fileChooser.setCurrentDirectory(new File(new File("E:\\Project\\").getCanonicalPath()));
       //then we show dialog box in which user select a file
       int result = fileChooser.showOpenDialog(new JPanel());
       //defining a file variable to store the file which user choose
       File selectedFile;
       //if user chooses a file
       if(result == JFileChooser.APPROVE_OPTION)
       {
           //then we get that file in "selectedFile" variable
           selectedFile = fileChooser.getSelectedFile();
           //defining a scanner variable to take input from file
           //giving parameter to the scanner variable is the file that user chooses
           Scanner scan = new Scanner(selectedFile.getAbsoluteFile());
           //defining variables to take input from file
           int pound;
           double ounce;
           //runs till end of file
           while(scan.hasNext() )
           {
               //takes pound input which is int
               pound=scan.nextInt();
               //takes ounce input which is double
               ounce=scan.nextDouble();
               //assigns the incoming variable to the weight array index
               w[countNoOfWeights] = new Weight(pound,ounce);
               //increasing the countNoOfObjects which acts as index also
               countNoOfWeights++;
               //if no of objects is more tham 25 then we exit the program as instructed using "Return;"
               if(countNoOfWeights>=25)
               {
                   System.out.print("Number of weights in the file exceeds 25");
                   return;
               }
           }
           //printing minimum, maximum, average of the array
           System.out.println("Minimum Weight in the array is " + findMinimum(w,countNoOfWeights).toString());
           System.out.println("Maximum Weight in the array is " + findMaximum(w,countNoOfWeights).toString());
           System.out.println("Average Weight in the array is " + findAverage(w,countNoOfWeights).toString());
       }
   }
}

1 import java.io.File; 2 import java.io.IOException; 3 import java.util.Scanner; 5 import javax.swing.JFileChooser; 6 import javax.swing.JPanel; 8 public class Projectl lle //findMinimum function takes weight array input and size of array and returns weight which is minimum in array private static Weight findMinimum (Weight[] w, int sizeofArray) //initializing minimumWeight to first element of the array Weight minimumweight = w[0]; //traverse through all the array and then compares using "lessThan" function //if "minimumWeight" is greater than array "i-th" element, then we change the minimumWeight to "i-th" element for(int i=1;i<sizeofArray;i++) if(!(minimumweight.lessthan (w[i]))) minimumWeight=w[i]; //returns the minimumWeight return minimumweight; //findMaximum function takes weight array input and size of array and returns weight which is maximum in array private static Weight findMaximum (Weight [] w, int sizeofArray) //initializing maximumWeight to first element of the array Weight maximumWeight = w[0]; //traverse through all the array and then compares using "lessThan" function

286 private static Weight findMaximum (Weight[] w, int sizeofArray) //initializing maximumweight to first element of the array Weight maximumWeight = w[0]; //traverse through all the array and then compares using "lessThan" function //if "maximumWeight" is less than array "i-th" element, then we change the maximumWeight to "i-th" element for (int i=1;i<sizeofArray;i++) if (maximumweight.lessthan (w[i])) maximumWeight=w[i]; //returns the maximumElement return maximumWeight; WWWWWWWWWW NN 10 coin NOCO) in NO COO) in WN POCO i in in un unin in un unin n //findAverage function takes weight array input and size of array and returns weight which is average public static Weight findAverage (Weight[] w, int sizeofArray) //initializing a variable "averageWeight" to 0 pound 0 ounces Weight averageWeight = new Weight (0,0); //adding all the array elements to "averageWeight" variable and then normalizing it for (int i=0;i<sizeofArray;i++) averageWeight.addTo (w[i]); // dividing the "averageWeight" variable by sizeofArray to get the average averageWeight.divide (sizeofArray); //returns the averageWeight return averageWeight; //main function

con i // dividing the "averageWeight" variable by sizeofArray to get the average averageWeight divide (sizeofArray); //returns the averageWeight return averageWeight; 600 //main function public static void main(String[] args) throws IOException o in WN co //defining an array of weight with size of 25 Weight w[]= new Weight [25]; //variable to count number of weights in the file, initializing it to o int countNoOfWeights = 0; //creating a jFilechoose object to get the file JFileChooser fileChooser = new JFileChooser(); // setting the default directory, change according to your need fileChooser.setCurrent Directory (new File(new File("E:\\Project\\").getCanonicalPath())); //then we show dialog box in which user select a file int result = fileChooser.showOpenDialog (new JPanel()); //defining a file variable to store the file which user choose File selectedFile; //if user chooses a file if (result == JFileChooser. APPROVE_OPTION) O on W NO coon W N 0 0 //then we get that file in "selectedFile" variable selectedFile = fileChooser.getSelectedFile(); //defining a scanner variable to take input from file 1/giving parameter to the scanner variable is the file that user chooses Scanner scan = new Scanner (selectedFile.getAbsoluteFile()); //defining variables to take input from file int pound; double ounce; //runs till end of file while (scan.hasNext()) 0 0 0 0 0

- 0 090) ON 0 0 0 //then we get that file in "selectedFile" variable selectedFile = fileChooser.getSelectedFile(); //defining a scanner variable to take input from file //giving parameter to the scanner variable is the file that user chooses Scanner scan = new Scanner (selectedFile.getAbsoluteFile()); //defining variables to take input from file int pound; double ounce; //runs till end of file while (scan.hasNext()) 0 0 0 0 0 0 0 0 ON 0 0 //takes pound input which is int pound=scan.nextInt(); //takes ounce input which is double ounce=scan.nextDouble(); //assigns the incoming variable to the weight array index w [CountNoofWeights] = new Weight (pound, ounce); //increasing the countNoOfObjects which acts as index also countNoOfWeights++; //if no of objects is more tham 25 then we exit the program as instructed using "Return;" if (countNoOfWeights>=25) 0 0 0 0 0 0 System.out.print("Number of weights in the file exceeds 25"); return; 0 101 102 103 104 105 106 //printing minimum, maximum, average of the array System.out.println("Minimum Weight in the array is " + findMinimum (w, countNoOfWeights).toString()); System.out.println("Maximum Weight in the array is " + findMaximum (w, countNoOfWeights).toString()); System.out.println("Average Weight in the array is " + findAverage (w, countNoOfWeights).toString()); 107 108 109) - Act

INPUT: In file "data.txt"

12 12.23
12 4.5
11 11
10 2
2 5.2
14 3
57 4.2

12 12.23 12 4.5 11 11 10 2 25.2 143 57 4.2

OUTPUT:

-File Choosing:

- . 0 0 0 0 0 0 00 00 00 00 00 00 00 00 00 0 0 0 0 0 0 0 0 0 0 0 OOOOOOOOO 0 0 0 0 //defining a scanner variable to take input from file //giving parameter to the scanner variable is the file that user chooses Scanner scan = new Scannerleelectedile net Ahenlusterile . //defining varia 4 Open int pound; float ounce; Look In: Project - A 88 8 //runs till end while (scan.hasne data.txt //takes pour pound=scan.n //takes ound ounce=scan.nl //assigns til w [countNoOfW //increasing countNoOfWei //if no of a File Name: if (countNoot Files of Type: All Files System.o return; Open Cancel using "Return;" //printing minimu, maximum, average of the array System.out.println("Minimum Weight in the array is " + findMinimum (w, countNoOfWeights).toString()) System.out.println("Maximum Weight in the array is " + findMaximum (w, countNoOfWeights).toString()) System.out.println("Average Weight in the array is " + findAverage (w, countNoOfWeights).toString() )

-RESULT:

Minimum Weight in the array is 2 lbs 5.2 oz
Maximum Weight in the array is 57 lbs 4.2 oz
Average Weight in the array is 17 lbs 3.732857142857142 oz

Minimum Weight in the array is 2 lbs 5.2 oz Maximum Weight in the array is 57 lbs 4.2 oz Average Weight in the array is 17 lbs 3.732857142857142 oz

Ask any questions if you have in comment section below.

Please rate the answer.