CSE 210: Programming with Classes

Looking at the menu for the program can be a good place to start.

Take the time to go through each activity and discuss the way that activity should work. What does it require the user to type in? What does it display to the user?

The main components of this program are the activities. Recognizing that they will all have some behaviors and attributes in common, it makes sense to have a base class and then derived classes for each specific kind of activity, such as:

• Activity (The base class that contains all shared functionality)
• BreathingActivity
• ReflectingActivity
• ListingActivity

Notice that these classes all pass the "is a" test, because a Breathing activity is an activity, etc.

You might also to have a class to handle the menu and interaction, or you might choose to handle this directly in your Main method in the Program class.

The biggest trick here is that if any behavior is used by all the activities then you should include it in the base class.

For example, each of the following are common behaviors that should be in the base class:

• Displaying the starting message
• Displaying the ending message
• Pausing while showing a spinner for a certain number of seconds
• Pausing while showing a countdown timer for a certain number of seconds

The following behaviors might be similar in name, but different in the way they behave, so they would need to be defined separately for each derived class: (As a side note, in the next unit you will learn an even more clever way to handle methods like this.)

• Run the activity

Finally, there are behaviors for each activity that are completely unique to that activity. For example, the ListActivity also needs to provide behaviors for:

• Get a random prompt
• Get a list of responses from the user

The Reflecting activity needs to provide the following:

• Get a random prompt to show
• Get a random question about the prompt
• Display the prompt
• Display questions about the prompt and get answers

In addition, as you start to implement these behaviors, you might find it beneficial to have other "helper" functions that are used internally to perform part of the task of these behaviors. These become private methods of the class.

Converting these ideas to concise method names gives us the following:

• Activity
  • DisplayStartingMessage() : void
  • DisplayEndingMessage() : void
  • ShowSpinner(seconds : int) : void
  • ShowCountDown(second : int) : void
• BreathingActivity
  • Run() : void
• ListingActivity
  • Run() : void
  • GetRandomPrompt() : string
  • GetListFromUser() : List<string>
• ReflectingActivity
  • Run() : void
  • GetRandomPrompt() : string
  • GetRandomQuestion() : string
  • DisplayPrompt() : void
  • DisplayQuestions() : void

Once again, you need to think about the attributes that are in common and include them in the base class. Then, each derived class may have its own unique attributes as well.

Base class attributes should include:

• The activity name
• The description
• The duration in seconds

The Breathing Activity likely does not need any attributes, but the listing activity should store a count of the number of items listed, and a list of prompts to draw from. Similarly, the Reflecting Activity should store a list of questions and a list of prompts to draw from.

The following shows all the member variables:

• Activity
  • _name : string
  • _description : string
  • _duration : int
• BreathingActivity
  • None needed
• ListingActivity
  • _count : int
  • _prompts : List<string>
• ReflectingActivity
  • _prompts : List<string>
  • _questions : List<string>

The base class will need to initialize all of its member variables. You might require them to be passed in as parameters or you might have a constructor that sets some/all to default values to be changed later.

Then, the derived class constructor may be able to set good values in the base class even if you don't pass parameters to it. For example, a constructor that has no parameters could look like this:

    public ReflectingActivity()
    {
        _name = "Reflecting";
        _description = "This activity will help you reflect on times ...";
        _duration = 50;

        // Set other values here that are unique to the Reflecting Activity
    }

The code above shows the most simple and straightforward way to do this and assumes the variables are protected (not private) in the base class. You could also use setters or pass them to the base base class constructor directly.

In addition to initializing the variables, the constructors for the ListingActivity and the ReflectingActivity need to initialize the list of prompts (and questions for the Reflecting activity) and populate them with values.

The following is a final class diagram for each of the classes that you can use as a guide as you being writing your code.