Free Response Question (FRQ) - StepTracker Class

Section 3.15 Free Response Question (FRQ) - StepTracker Class

The AP exam’s second free response question (FRQ) is on classes, where students design and implement a described class. Students will be instructed to design and implement a class based on provided specifications and examples. A second class might also be included. Students will be provided with a scenario and specifications in the form of a table demonstrating ways to interact with the class and the results. The class must include a class header, instance variables, a constructor, a method, and implementation of the constructor and required method. (Inheritance is no longer covered in the AP exam and FRQs.)This question does not involve more complex topics such as arrays.

🔗

To succeed on the FRQ Question 2 on Classes, you must know how to:

🔗

Create a class using public class Classname { }
🔗

🔗
Write a constructor with the same name as the class and no return type. This constructor will probably have a parameter that is assigned to an instance variable and will need to assign default values to the other instance variables.
🔗

🔗
Write public methods in the class that use the instance variables as well as parameters and return values. These methods will probably use if statements but not more complex coding. One of these methods will probably be an accessor method that returns an instance variable or a calculated value that is dependent on the instance variables, and one will probably be a mutator method that changes the value of an instance variable.
🔗

🔗

🔗

Subsection 3.15.1 StepTracker Class FRQ

The 2019 FRQ 2 for the class StepTracker is a good example of what to expect. It is available as question 2 on page 7 of https://apstudents.collegeboard.org/sites/default/files/2019-05/ap19-frq-computer-science-a.pdf

https://apstudents.collegeboard.org/sites/default/files/2019-05/ap19-frq-computer-science-a.pdf

, reproduced below.

🔗

Question 2.

🔗

This question involves the implementation of a fitness tracking system that is represented by the StepTracker class. A StepTracker object is created with a parameter that defines the minimum number of steps that must be taken for a day to be considered active. The StepTracker class provides a constructor and the following methods.

🔗

addDailySteps, which accumulates information about steps, in readings taken once per day
🔗

🔗
activeDays, which returns the number of active days
🔗

🔗
averageSteps, which returns the average number of steps per day, calculated by dividing the total number of steps taken by the number of days tracked
🔗

🔗

🔗

The following table contains a sample code execution sequence and the corresponding results.

🔗

Table 3.15.1.

🔗

Statements and Expressions	Value Returned (blank if no value)	Comment
StepTracker tr = new StepTracker(10000);		Days with at least 10,000 steps are considered active. Assume that the parameter is positive.
tr.activeDays();	0	No data have been recorded yet.
tr.averageSteps();	0.0	When no step data have been recorded, the averageSteps method returns 0.0.
tr.addDailySteps(9000);		This is too few steps for the day to be considered active.
tr.addDailySteps(5000);		This is too few steps for the day to be considered active.
tr.activeDays();	0	No day had at least 10,000 steps.
tr.averageSteps();	7000.0	The average number of steps per day is (14000 / 2).
tr.addDailySteps(13000);		This represents an active day.
tr.activeDays();	1	Of the three days for which step data were entered, one day had at least 10,000 steps.
tr.averageSteps();	9000.0	The average number of steps per day is (27000 / 3).
tr.addDailySteps(23000);		This represents an active day.
tr.addDailySteps(1111);		This is too few steps for the day to be considered active.
tr.activeDays();	2	Of the five days for which step data were entered, two days had at least 10,000 steps.
tr.averageSteps();	10222.2	The average number of steps per day is (51111 / 5).

This question asks you to write the complete StepTracker class, including the constructor and any required instance variables and methods. Your implementation must meet all specifications and conform to the example.

🔗

Subsection 3.15.2 Determining the Instance Variables

Work in pairs or groups to read through the problem statement and determine the instance variables required for this class. During the exam, it helps to circle the words that are important and may describe the instance variables. Different groups may come up with different variables that will still work. Groups should report back and compare answers in class to determine the best variables before writing the class.

🔗

It may help to first identify the variables that are needed for the constructor and the accessor and mutator methods.

🔗

Activity 3.15.1.

Select the phrases below which probably mention an instance variable. Note that some of these may be referring to the same variable or to local variables.

🔗

Think about phrases that indicate a value that is being stored or changed or returned.

This question involves the implementation of a fitness tracking system
that is represented by the **StepTracker** class.

A StepTracker object is created with a parameter that defines
the minimum number of steps that must be taken for a day to be active.

The StepTracker class provides a constructor and the following methods.

     - addDailySteps, which accumulates information about steps in readings
       taken once per day.

     - activeDays, which returns the number of active days.

     - averageSteps, which returns the average number of steps per day
       calculated by dividing the total number of steps taken
       by the number of days tracked.

🔗

These multiple choice questions will help you to determine the instance variables through the constructor parameters and accessor and mutator methods.

🔗

Activity 3.15.2.

Given the StepTracker class description above, which of these statements describes an instance variable that the StepTracker constructor should set using a parameter?

🔗

the minimum number of steps that must be taken for a day to be considered active
🔗
Yes, the problem definition describes this as a parameter to create a StepTracker object.
the number of active days
🔗
This is not described as a parameter to create an StepTracker object.
the average number of steps per day
🔗
This is not described as a parameter to create an StepTracker object.
the total number of steps taken
🔗
This is not described as a parameter to create an StepTracker object.
number of days tracked
🔗
This is not described as a parameter to create an StepTracker object.

🔗

Activity 3.15.3.

Which of the following methods is an accessor method that returns the value of an instance variable?

🔗

StepTracker tr = new StepTracker(1000)
🔗
This is a call to the constructor.
tr.addDailysteps(1000);
🔗
No, addDailySteps(1000) probably adds the given steps to an instance variable as a mutator method.
tr.activeDays();
🔗
Yes, activeDays() is an accessor method that returns the number of active days (a great instance variable!).

🔗

Activity 3.15.4.

Which of the following methods is a mutator method that changes the value of an instance variable?

🔗

StepTracker tr = new StepTracker(1000)
🔗
No, this is a call to the constructor.
tr.addDailysteps(1000);
🔗
Yes, addDailySteps(1000) is a mutator method that adds the steps given as a parameter to an instance variable that keeps track of the steps taken so far.
tr.activeDays();
🔗
No, activeDays() is an accessor method that returns the number of active days.
tr.averageSteps();
🔗
No, averageSteps() is a complex accessor method that calculates and returns the average number of steps from the instance variable.

🔗

Activity 3.15.5.

What are the instance variables (at least 4!) that you need for the StepTracker class? What are the data types for each instance variable?

🔗

Subsection 3.15.3 Writing the Class Header and Constructor

You will receive at least 1 point if you write the class header and a constructor that has the same name as the class and no return type. You will receive another point for creating private instance variables inside the class. Complete the class definition below with the class name, the instance variables you determined above, and the constructor. Remember that for this problem, a StepTracker object is created (with a constructor) with a parameter that defines the minimum number of steps that must be taken for a day to be considered active. The constructor will often have a parameter which it should assign to an instance variable. It should also assign default values to the other instance variables.

🔗

Activity 3.15.6.

Write the first draft of the class StepTracker below with the class name, the instance variables, and the constructor with a parameter for the minimum number of steps threshold for active days. Make sure it compiles.

🔗

// Write public class your classname here and delete comment
{
   // write instance variable declarations here

// write the constructor with a parameter here

public static void main(String[] args)
   {
      StepTracker tr = new StepTracker(10000);
   }
}
====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

// Tests for ActiveCode StepTrackerCode1
public class RunestoneTests extends CodeTestHelper
{
    @Test
    public void test1()
    {
        // check class name
        boolean passed = checkCodeContains("correct class heading", "public class StepTracker");
        assertTrue(passed);
    }

@Test
    public void test2()
    {
        // constructor with 1 parameter for threshold minSteps
        String args = "int";
        String results = checkConstructor(args);

boolean passed = getResults("pass", results, "Checking constructor with one int argument");
        assertTrue(passed);
    }

@Test
    public void test3()
    {
        // check int - declaration of instance variables and parameter in constructor
        String actual = testPrivateInstanceVariables();
        String expected = "4 Private";

boolean passed = getResults(expected, actual, "Checking declaration of instance variables");
        assertTrue(passed);
    }
}

🔗

Here is the rubric for the instance variables and the constructor for this problem. Did you receive all 3 points? In class, your teacher may have you grade each others’ code.

🔗

Figure 3.15.2. Rubric for instance variables and constructor
🔗

🔗

Subsection 3.15.4 Writing the Accessor Method activeDays

Each method in the FRQ is worth 1 - 3 points. The method header is usually worth 1 point and the code in the method body is usually worth another point or two depending on how complex it is.

🔗

This problem asks you to write a simple accessor method called activeDays which returns the number of active days (which should be an instance variable) for 1 point.

🔗

Remember that accessor methods usually look like the following:

🔗

class ExampleClass
{
    // Instance variable declaration
    private typeOfVar varName;

    // Accessor method template
    public typeOfVar getVarName()
    {
        return varName;
    }
}

This multiple choice problem can help you determine the accessor method header.

🔗

Activity 3.15.7.

Which of the following is a good method header for the accessor method activeDays()?

🔗

public void activeDays()
🔗
Accessor methods need a return type since they return the value of an instance variable or a value calculated from instance variables.
private void activeDays()
🔗
Accessor methods should not be private.
public int activeDays(int numSteps)
🔗
Accessor methods do not usually take parameters.
public void activeDays(int numSteps)
🔗
Accessor methods need a return type since they return the value of an instance variable or a value calculated from instance variables, and they do not usually have a parameter.
public int activeDays()
🔗
Correct, accessor methods are public, have a return type, and no parameter.

🔗

Activity 3.15.8.

Copy the code from your first draft of the class StepTracker above with the instance variables and constructor. Write the accessor methods activeDays which returns the number of active days.

🔗

public class StepTracker
{
    // copy the instance variable declarations here

// copy the constructor with a parameter here

// Write the accessor method activeDays() here
    // @return activeDays

public static void main(String[] args)
    {
        StepTracker tr = new StepTracker(10000);
        System.out.println(
                tr.activeDays()); // returns 0. No data have been recorded yet.
    }
}
====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    @Test
    public void testMain() throws IOException
    {
        String output = getMethodOutput("main");
        String expect = "0\n";
        boolean passed = getResults(expect, output, "Expected output from main");
        assertTrue(passed);
    }

@Test
    public void checkCodeContains1()
    {
        // check accessor method activeDays()
        boolean passed = checkCodeContains("activeDays() method", "public int activeDays()");
        assertTrue(passed);
    }

@Test
    public void checkCodeContains2()
    {
        // check that activeDays() returns a value
        boolean passed = checkCodeContains("return");
        assertTrue(passed);
    }
}

🔗

Here is the rubric for the accessor method activeDays for this problem. The second column is small mistakes that will still earn the point but the third column is larger mistakes that will not earn the point. Did you receive the point for this method? In class, your teacher may have you grade each others’ code.

🔗

Figure 3.15.3. Rubric for accessor method activeDays()
🔗

🔗

Subsection 3.15.5 Writing the Mutator Method addDailySteps

This problem asks you to write a more complex mutator method called addDailySteps worth 3 points.

🔗

Remember that mutator methods often look like the following:

🔗

class Example
{
    // Instance variable declaration
    private typeOfVar varName;

    // Mutator method template
    public void changeVarName(typeOfVar newValue)
    {
        // an instance variable is changed through = or an operator like +=, -=,
        // ++, etc.
        varName = newValue;
    }
}

This multiple choice problem can help you determine the mutator method header.

🔗

Activity 3.15.9.

Which of the following is a good method header for the mutator method addDailySteps?

🔗

public void addDailySteps()
🔗
Mutator methods take a parameter to change the value of an instance variable.
private void addDailySteps()
🔗
Mutator methods should not be private.
public int addDailySteps(int numSteps)
🔗
Mutator methods do not usually return a value.
public void addDailySteps(int numSteps)
🔗
Correct, mutator methods are public with a void return type and take a parameter to change the value of an instance variable.
private int addDailySteps()
🔗
Mutator methods should not be private and should take a parameter to change the value of an instance variable.

🔗

The code for this mutator method is a little more complex than the template above, because it needs to change more than 1 instance variable. Notice the comments in the sample code execution:

🔗

Table 3.15.4.

🔗

Statements and Expressions	Value Returned (blank if no value)	Comment
tr.addDailySteps(5000);		This is too few steps for the day to be considered active.
tr.activeDays();	0	No day had at least 10,000 steps.
tr.addDailySteps(13000);		This represents an active day.
tr.activeDays();	1	Of the three days for which step data were entered, one day had at least 10,000 steps.

Consider each of your instance variables and whether this method should change them. The problem below may help you.

🔗

Activity 3.15.10.

Which of the following values does the mutator method addDailySteps need to change? (check all that apply)

🔗

the minimum number of steps that must be taken for a day to be considered active
🔗
The minimum is set by the constructor.
the number of active days
🔗
Yes, addDailySteps should determine whether the number of steps given in its parameter is an active day and if so, change this variable.
the average number of steps per day
🔗
This method does not have to calculate the average.
the total number of steps taken
🔗
Yes, addDailySteps should add the number of steps taken that day in its parameter to the total.
number of days tracked
🔗
Yes, addDailySteps is called each day and can change the variable for the number of days being tracked.

🔗

Activity 3.15.11.

Copy the code from your draft of the class StepTracker above with the class name, the instance variables, constructor, and accessory method. Write the mutator method addDailySteps which takes a parameter and adds it to the appropriate instance variable and changes other instance variables appropriately.

🔗

public class StepTracker
{
    // copy the instance variable declarations here

// copy the constructor with a parameter here

// copy the accessor method activeDays() here.

// Write the mutator method addDailySteps here.
    // @param number of steps taken that day

public static void main(String[] args)
    {
        StepTracker tr = new StepTracker(10000);

// returns 0. No data have been recorded yet.
        System.out.println(tr.activeDays());

// This is too few steps for the day to be considered active.
        tr.addDailySteps(9000);

// This is too few steps for the day to be considered active.
        tr.addDailySteps(5000);

// returns 0.  No day had at least 10,000 steps.
        System.out.println(tr.activeDays());

// This represents an active day.
        tr.addDailySteps(13000);

// returns 1. Of the three days for which step data were entered, one day
        // had at least 10,000 steps.
        System.out.println(tr.activeDays());
    }
}
====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    @Test
    public void testMain() throws IOException
    {
        String output = getMethodOutput("main");
        String expect = "0\n0\n1\n";
        boolean passed = getResults(expect, output, "Expected output from main");
        assertTrue(passed);
    }

@Test
    public void checkCodeContains1()
    {
        // check mutator method addDailySteps()
        boolean passed =
                checkCodeContains(
                        "addDailySteps method with parameter", "public void addDailySteps(int");
        assertTrue(passed);
    }

@Test
    public void checkCodeContains2()
    {
        // check mutator method addDailySteps() contains "if"
        boolean passed = checkCodeContains("if statement", "if (");
        assertTrue(passed);
    }
}

🔗

Here is the rubric for the mutator method for this problem. The second column is small mistakes that will still earn the point but the third column is larger mistakes that will not earn the point. Did you receive all the points? In class, your teacher may have you grade each others’ code.

🔗

Figure 3.15.5. Rubric for mutator method
🔗

🔗

Subsection 3.15.6 Writing the Accessor Method averageSteps

This problem asks you to write a more complex accessor method which uses the instance variables to calculate and return the averageSteps for 2 points. This method returns the average number of steps per day, calculated by dividing the total number of steps taken by the number of days tracked.

🔗

This multiple choice problem can help you determine the accessor method header.

🔗

Activity 3.15.12.

Which of the following is a good method header for the accessor method averageSteps() which returns the average number of steps per day?

🔗

public void averageSteps()
🔗
Accessor methods need a return type since they return the value of an instance variable or a value calculated from instance variables.
public int averageSteps()
🔗
When you compute an average using division, you usually end up with a double value, not int.
public double averageSteps()
🔗
Correct, accessor methods are public, have a return type, and no parameter. In this case, returning an average requires a double return type.
public void averageSteps(int numSteps)
🔗
Accessor methods need a return type since they return the value of an instance variable or a value calculated from instance variables, and they do not usually have a parameter.
public int averageSteps(int numSteps)
🔗
Accessor methods do not usually take parameters.

🔗

The complex accessor method averageSteps() must calculate the average number of steps from your instance variables. Notice that the first time it is called in the sample code execution, it returns 0.0 since there are no steps recorded. This avoids a divide by 0 error.

🔗

Table 3.15.6.

🔗

Statements and Expressions	Value Returned (blank if no value)	Comment
tr.averageSteps();	0.0	When no step data have been recorded, the averageSteps method returns 0.0.

Activity 3.15.13.

Copy the code from your draft of the class StepTracker above with the instance variables, constructor, accessor and mutator methods. Write the accessor method averageSteps which returns the average number of steps per day, calculated by dividing the total number of steps taken by the number of days tracked.

🔗

public class StepTracker
{
    // copy the instance variable declarations here

// copy the constructor with a parameter here

// copy the accessor method activeDays() here.

// copy the mutator method addDailySteps here.
   
   
    // TODO: write the accessor method getAverageSteps() here
    // @return average number of steps per day

public static void main(String[] args)
    {
        StepTracker tr = new StepTracker(10000);
        // returns 0. No data has been recorded yet.
        System.out.println(tr.activeDays());
        // returns 0.0. When no step data have been recorded,
        //  the averageSteps method returns 0.0
        System.out.println(tr.averageSteps());

// This is too few steps for the day to be considered active.
        tr.addDailySteps(9000);

// This is too few steps for the day to be considered active.
        tr.addDailySteps(5000);

// returns 0.  No day had at least 10,000 steps.
        System.out.println(tr.activeDays());
        // returns 7000.0 The average number of steps per day is (14000/2).
        System.out.println(tr.averageSteps());

// This represents an active day.
        tr.addDailySteps(13000);
        // returns 1. Of the three days for which step data were entered,
        // one day had at least 10,000 steps.
        System.out.println(tr.activeDays());
        // returns 9000.0. The average number of steps per day is (27000/3).
        System.out.println(tr.averageSteps());

tr.addDailySteps(23000); // This represents an active day.
        tr.addDailySteps(1111); // This is too few steps for the day to be active.
        // returns 2. Of the five days for which step data were entered,
        //    two days had at least 10,000 steps.
        System.out.println(tr.activeDays());
        // returns 10222.2. The average number of steps per day is (51111/5).
        System.out.println(tr.averageSteps());
    }
}
====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    @Test
    public void testMain() throws IOException
    {
        String output = getMethodOutput("main");
        String expect = "0\n0.0\n0\n7000.0\n1\n9000.0\n2\n10222.2\n";
        boolean passed =
                getResults(
                        expect,
                        output,
                        "Expected output from main. Make sure you used casting to double for the"
                                + " last result!");
        assertTrue(passed);
    }

@Test
    public void checkCodeContains1()
    {
        // check mutator method averageSteps()
        boolean passed = checkCodeContains("averageSteps() method", "public double averageSteps()");
        assertTrue(passed);
    }

@Test
    public void checkCodeZero()
    {
        StepTracker tr = new StepTracker(10000);
        double average = tr.averageSteps();

boolean passed =
                getResults(0.0, average, "averageSteps() returns 0.0 when no days recorded");
        assertTrue(passed);
    }

@Test
    public void checkCodeDoubleResult()
    {
        StepTracker tr = new StepTracker(10000);
        tr.addDailySteps(9000); // This is too few steps for the day to be considered active.
        tr.addDailySteps(5000);
        tr.addDailySteps(13000);
        tr.addDailySteps(23000);
        tr.addDailySteps(1111);
        double average = tr.averageSteps();

boolean passed =
                getResults(
                        10222.2, average, "averageSteps() returns 10222.2 (no integer division)");
        assertTrue(passed);
    }
}

🔗

Here is the rubric for the averageSteps method for this problem. Did you receive all the points? In class, your teacher may have you grade each others’ code.

🔗

Figure 3.15.7. Rubric for averageSteps method
🔗

🔗

You have attempted of activities on this page.

🔗

Prev Top Next