CS2 Lesson 10: Designing Classes

  1. Creating a class
    1. Error checking
    2. Magic Numbers
    3. Public vs private
    4. Instance Methods
  2. Exercise
  3. Object Oriented Design
  4. Reading and exercises

Note on the lesson: in some of today’s videos, I start creating a “Time” class that I want you to follow along. Please do follow along: that means, create an IntelliJ project, and, while you’re watching the videos, work on the code in IntelliJ alongside watching the video. Pause the video when I ask you to, work on the code for a bit, and then come back to watch me work on that same code.

Creating a class

Some basic vocabulary terms we should know for now:

Follow along the above video where I walk you through the process of creating a class in IntelliJ, declaring variables and constructors, and using the class in another main method.

This is the process we should always keep in mind when we design classes: first you think about the instance variables that the class should have, make a constructor (or multiple constructors) for that class, and implement the toString() method so that you can output objects of that type.

Error checking

In this video above, I walk through the process of error checking in our class. We want to define the parameters of how to use the class properly. For example, the following should not make sense:

Time time = new Time(13, 75, "Go away!");
System.out.println(time);

Even though we provided the Time constructor with two integers and a String, this should just not be allowed, since it does not correspond to an actual time. So we add in some error checking in our Time constructor:

public Time(int h, int m, String amOrPm) {
    if (h < 1 || h > 12) {
        throw new IllegalArgumentException("Illegal hour: " + h + ". Hour must be between 1 and 12.");
    }
}

This is a common paradigm in Java: when we define a class, we should define the way in which it should be allowed to be used. If the class requires an integer between 1 and 12 for the hour, we should throw an exception if any code tries to use it with other parameters. We will discuss exceptions in more depth later on in the semester.

Magic Numbers

The textbook talks about magic numbers earlier in the book. I hope you had read this already, but the book raises some good points about how we should use variables with meaningful names to drive logic in our code, rather than just numbers like “1” or “12” in the above code. When we revisit code later on, we might forget what we meant by those numbers, while if we have good variable names, we will be reminded of why we put those in.

To do this, we declare constant class variables. These are static variables that are marked final:

public class Time {

    public static final int MIN_HOUR = 1;
    public static final int MAX_HOUR = 12;

    // ...

    public Time(int h, int m, String amOrPm) {
       if (h < MIN_HOUR || h > MAX_HOUR) {
            throw new IllegalArgumentException("Illegal hour: " + h + ". Hour must be between 1 and 12.");
        }
    }
}

This was, we know that the 1 and 12 represent “minimum” and “maximum” hours that are allowed to be used in this class.

Public vs private

If you paid close attention, you will have seen that I declared the hour, minute, and amPm variables using the keyword private, while I declare the MIN_HOUR variable using the keyword public. Why? What do public and private mean?

Public and private are visibility modifiers. These are what tell you what classes have access to these items (variables, methods, classes, constructors, etc). There are four levels of visibility modifiers:

As a rule of thumb, we should often make everything as private as possible. We want to restrict how others use our class; that way, we can control how they will use it and predict and plan for possible bad behavior. I go through an example in the video above of what could go wrong if we just make everything public.

Instance Methods

If, as we said before, we made all our instance variables private, how would other classes use the data stored in our class? How would other classes see the current hour for a particular Time object?

The answer: create an instance method that allows other classes to access this value.

public int getHour() {
    return hour;
}

Then other classes can “see” the value of the hour, but they still can’t change it. If we want to allow them to change it, we can create a setHour method, similarly, and put in our “error-checking” code in there as well, possibly throwing an exception if we are provided an illegal hour.

Exercise

Create a class that represents a Book object. A Book is described by an author, a title, and a publication year.

Define the class, declare its instance variables, and create a toString method for it. The toString method should return a String in the form: author, “Title” (year)

For example, the book Effective Java by Joshua Bloch, released in 2017, should be outputted as Joshua Bloch, "Effective Java" (2017).

Note: to get quotation marks to display in a String, escape it using a backslash:

System.out.println("\"Effective Java\""); // display "Effective Java", with the quotes

Important: we will be using this class in our second project, so please work on this now. Submit this on CodingRooms so I can see it.

Object Oriented Design

We now revisit one of the paradigms I mentioned earlier in the semester: modular design.

  1. Break large problems up into smaller components.
  2. Solve each component on its own, test it out on its own.
  3. Integrate the components together.

Now, though, our components should be the “objects” in our program. To use an analogy from grammar, we should think about the “nouns” of the problem we’re solving. What are the “things” in the problem, and what are those “things” doing? Those “nouns” should be represented by objects, which then need a class to define them. The instance variables are the data that is needed to represent that data type, and the instance methods would be the way that objects of that data type can behave and/or interact with other objects.

Reading and exercises

This is a good time to catch yourself up on old readings. We should have read chapter 1 - 7 already, so please catch up on those if you feel lost on anything. Do all the exercises.

For the material on classes, specifically, take a look at chapters 9 - 11. Again, do as many exercises as you can. In particular, Exercises 2 and 3 from Chapter 11 are really good practice for creating basic classes.