Activity: Grade Calculations Solution

Goals:

By the end of this activity you should be able to do the following:
    • Understand the basic syntax of the Java programming language

    • Have a better understanding of classes and methods

    • Have a better understanding of how to use the viewer canvas in jGRASP

Description:

In this activity you will create two classes. First, you will create a class called Grade which will represent your grade in COMP 1210. The second class, which will be called GradeGenerator, is a driver program that will calculate your course average. Words underlined and highlighted in blue represent concepts and terminology that will be important for Exam 1 on Wednesday. Boxed-in text does not have to be read in lab, but explains the highlighted concepts in context as an exam review. See pages 3 - 5 for important information related to all future projects (highlighted in red).

Directions:

Part 1: Grade.java – skeleton code (minimal code required to compile the class and methods with the specified method signatures)

    • Create your Grade class and declare the following instance variables using the private access (or visibility) modifier:
o  exam1, exam2, and finalExam: double values to hold exam grades
o  activityAvg: double that holds the activity average
Read the boxed-in portions
o  quizAvg: double that holds the quiz average
after lab to help study for
o
projectAvg: double that holds the project average



Exam 1!
o
studentName: String representing student name



Instance variables are declared inside of the class, but not inside of a method. Instance variables are available to any instance method in the class. They should be private to avoid violating encapsulation (see class notes / textbook). When an object is created, space is set aside for the instance variables, and the variables are assigned initial values.

An access (or visibility) modifier specifies whether a member of a class can be accessed and modified from outside of the class (public) or inside of the class only (private). The protected visibility modifier will be further discussed in chapter 9 with respect to inheritance.

Which of your instance variables are reference types, which are primitive types, and what is the difference between the two?

    • You will now declare three constants representing the three possible exams. Declare the three constants with public visibility.



Constants are fields in a class that contain a value that never changes. Constant names are capitalized and are declared as static (they exist even when an object has not be created and can be accessed using the class name, similar to static methods) and final (the value cannot be changed after it has been assigned). An example of a public constant: Math.PI

Why do public instance variables violate encapsulation while public constants do not?





Page 1 of 7
Activity: Grade Calculations    Page 2 of 7


    • Now create private constants that represent the weight of each portion of your grade:




    • Add skeleton code (or stub) for a constructor to the Grade class that accepts the student name as a parameter.






A constructor is invoked when an object is created using the new operator and is used to initialize fields using parameter values or default values. Constructors have no return type and always have the same name as the class. Think about why a constructor would have public visibility rather than private visibility.

The formal parameter nameIn is a variable that has local scope and represents input being sent from the calling method. Because it is a local variable, it can only be accessed from within the constructor and will no longer exist when the end of the constructor is reached (space is no longer reserved in memory; see garbage collection).


    • Set up method skeleton code (or stubs) for the following methods:

o setLabAverages: no return value; takes two double parameters activityAvgIn and quizAvgIn. The projectAvg will be set separately below.




    o setProjectAvg: no return; takes a double called projectAvgIn as a parameter.

<Do this one on your own>

    o setExamScore: no return; takes an int parameter examType and a double examScore.





    o calculateGrade: returns a double representing your grade; no parameters.





    o toString: String return and no parameters.






Compile your program. If this were a project, this is the point where you would submit to the “Skeleton Code (Ungraded)” Web-CAT assignment to check the correctness of your method headers.


Page 2 of 7
Activity: Grade Calculations    Page 3 of 7


Part 2: Grade.java – Completing the constructor and instance methods

Completing the Constructor

    • The formal parameter String studentNameIn is considered to be a local variable that will not be accessible after the constructor ends. You need to assign the studentNameIn to the instance variable studentName using an assignment statement within the constructor.




Examples of declaration, assignment, and initialization.


Declaration:

Assignment:

Declaration and











int aNum;


aNum = 1;

initialization:








int bNum
= 10;

Completing the Method: toString

•    Complete the toString method so that it returns a String representation of a Grade object:






•    Test your constructor and toString in the interactions pane:
¼MMGrade comp1210Grade = new Grade("Pat");

M¼MMcomp1210Grade

MM«MName: Pat
Invokes the toString
MM©MCourse Grade: 0.0
method implicitly and
M¼MM
prints the return value.



Completing the Set Methods:    setLabAverages, setExamScore, setProjectAverage

    • In your setLabAverages method, add the following code to store your activity and quiz average.





    • In your setProjectAverage, set the value of the instance variable representing project average.




    • Your setExamScore method should use the public constants to decide which of the exam score instance variables to set when the method is called: exam1, exam2, or finalExam.












Page 3 of 7
Activity: Grade Calculations    Page 4 of 7














Typically, this set method would include a boolean return and would return false if examType was not 1, 2, or 3; however, for brevity in this activity the method return type is void.

Completing the Method:    calculateGrade

    • Add code to calculate your grade. The weight constants are not necessarily useful to users of the Grade class, so they are private rather than public.










Note that the grade you are calculating is not an instance variable. In general you should try to keep as many variables local as possible to avoid method dependencies and logic errors. This is especially true for values that are calculated from field values. It is usually preferable to calculate a value when needed rather than attempt to update it each time any of several fields it depends on is updated.


•    Test your set methods in the interactions pane:

M¼MMcomp1210Grade.setLabAverages(90, 80);

M¼MMcomp1210Grade.setProjectAvg(95);

M¼MMcomp1210Grade.setExamScore(Grade.EXAM_1, 85);

M¼MMcomp1210Grade.setExamScore(Grade.EXAM_2, 88);

M¼MMcomp1210Grade.setExamScore(Grade.FINAL, 91);

M¼MMcomp1210Grade.calculateGrade()

MMMM89.5


Project note: Always use public constants in your driver programs rather than literal values whenever possible.





In the workbench to the top left-hand side of jGRASP, open the myGrade object and make sure that your instance variables have been set correctly.








Page 4 of 7
Activity: Grade Calculations    Page 5 of 7























You can also open a canvas window (click Open Canvas button  on the Workbench tab) and then drag comp1210grade onto the canvas. Be sure to change the viewer to “Basic” if this is not already selected. Note the Basic view does not display the static variables/constants but rather only the instance variables. In the canvas below, comp1210Grade has been dragged onto the canvas a second time. The first one is set to the Basic viewer and the second one set to the toString() viewer, which displays the toString value to the object.








Open a canvas window    and

drag comp1210Grade onto

the canvas twice. The viewer

on the left is set to the Basic

viewer (default for simple

user objects). For the viewer

on the right, click the drop-

down menu    , select

Viewers, then select

toString() as the viewer.





“Set” methods are mutator methods and modify your object's attributes. “Get” methods are accessor methods that return the specified attribute.


A get method should return the value, but should not modify an object's instance data.



Page 5 of 7
Activity: Grade Calculations    Page 6 of 7



Project note: Do not depend on the toString method to test your other methods; for example, to test calculateGrade you should invoke calculateGrade directly.


There may be instances in which you want to convert a number from one type to another, which can be done via assignment conversion, promotion, or casting. All of the numbers were doubles in the above example, but conversion may be needed in when an expression contains integers and integer division is unwanted.


Question: Suppose that aNum is an integer. Modify the following code 3 different times to using assignment conversion, promotion, and casting to produce a correct output (assume that integer division is not desired).

int aNumTimes2 = aNum * 2;

double result = aNumTimes2 / 3;


    • Important project note: to score full points on the projects, you should use constants in your code rather than just the value itself (this avoids the use of “magic numbers” and is considered good programming practice). Constant identifiers should always be capitalized. For example, if you had an integer of value 1 that is used represent the color red, you should not use the value 1 throughout your code. Instead, you should have a constant named RED set to the value of 1 and refer to the constant throughout your code.
        ◦ Constants should be public if they are useful outside of the class (for example, to allow a user to change an exam category without having to memorize that regular exam is 1 or 2 and the final = 3).

        ◦ Constants should be private if they are only useful inside of the class (for example, in a bowling class the total number of pins is 10; the user would not have to necessarily know or use this value, but the class itself would have to use it to calculate the score).


Part 3: Driver Program

    • Download GradeGenerator.java and GradeGenerator.jgrasp_canvas.xml from the Files page in Canvas (Files > Lab > Activities > Activity_04B_files.zip) and save them in the same folder as your Grade.java.

    • Complete the main method in GradeGenerator by invoking the methods required set the fields for grades in the Grade object that is created assigned to the variable comp1210Grade.

When setting the scores for exam1, exam1 and finalExam, do NOT use literal values to set the exam grades. Instead use the appropriate constants.

Bad:  comp1210Grade.setExamScore(1, exam1Score);
Good: comp1210Grade.setExamScore(Grade.EXAM_1, exam1Score);

After completing the main method GradeGenerator.java, compile and run the program to test it.

    • Run the program using the canvas file you downloaded (GradeGenerator.jgrasp_canvas.xml) by

clicking the Run in Canvas button  on the desktop toolbar.  After the canvas window opens,
click the play button  to begin stepping in the program.  Note that the variables on the canvas


Page 6 of 7
Activity: Grade Calculations    Page 7 of 7


were dragged from the Debug tab during a previous run. Below is an example of the canvas window for “Pat Smith-Jones” prior to setting any of the grades in comp1210Grade. You may need to reposition and/or resize one or more of individual viewers on the canvas depending on your screen’s pixel density. Be sure to demo this for your TA.




















































Disclaimer: This activity is not comprehensive in its presentation of Exam 1 concepts.







Page 7 of 7