3.3 Anatomy of a Class

1. The parts of a class

In this course, a class is always designated public and is declared with the keyword class 3.3.A.2. Inside, a typical class has three kinds of parts:

Part	What it does	Access in AP® code
Instance variables	Store the attributes of each object	private 3.3.A.5
Constructors	Set the initial values when an object is created	always public 3.3.A.3
Methods	Define the behaviors of the object	public, or private for helpers 3.3.A.6

Here is a complete class in the AP® free-response “class design” style. Read the comments: they label each part.

public class LibraryBook
{
    // ----- instance variables: private -----
    private String title;
    private int pages;
    private boolean checkedOut;

    // ----- constructor: public, no return type -----
    public LibraryBook(String bookTitle, int numPages)
    {
        title = bookTitle;
        pages = numPages;
        checkedOut = false;
    }

    // ----- accessor methods: public -----
    public String getTitle()
    {
        return title;
    }

    public boolean isCheckedOut()
    {
        return checkedOut;
    }

    // ----- mutator methods: public -----
    public void checkOut()
    {
        checkedOut = true;
    }

    public void returnBook()
    {
        checkedOut = false;
    }

    public void setPages(int numPages)
    {
        if (numPages > 0)
        {
            pages = numPages;
        }
    }

    /** Returns the number of days needed to read the book
     *  at pagesPerDay pages a day. Precondition: pagesPerDay > 0 */
    public int daysToRead(int pagesPerDay)
    {
        return divideRoundUp(pages, pagesPerDay);
    }

    // ----- helper method: private, used only inside the class -----
    private int divideRoundUp(int a, int b)
    {
        return (a + b - 1) / b;
    }

    // ----- toString: returns a String that describes the object -----
    public String toString()
    {
        return title + " (" + pages + " pages)";
    }
}

Client code in another class:

LibraryBook book = new LibraryBook("Ocean Tides", 250);
book.checkOut();
System.out.println(book.getTitle() + " out: " + book.isCheckedOut());
System.out.println(book.daysToRead(30));
System.out.println(book);

Output:

Ocean Tides out: true
9
Ocean Tides (250 pages)

Background: the last line works because println calls the object’s toString method. You will see toString in class code, but writing your own toString (overriding it) is outside the AP® exam, so the exam will not ask you to write one.

2. Encapsulation: public and private

Data encapsulation is a technique in which the implementation details of a class are kept hidden from external classes 3.3.A.1. Two keywords control access to classes, data, constructors and methods 3.3.A.1:

• private restricts access to the declaring class (the class where it is written) 3.3.A.1.
• public allows access from classes outside the declaring class 3.3.A.1.

The class above hides how it stores its data. A client cannot see that checkedOut is a boolean; it only sees the behaviors checkOut, returnBook and isCheckedOut. The class could later store the status another way without breaking any client.

3. Each object has its own instance variables

Instance variables belong to the object, and each object has its own copy of each variable 3.3.A.4.

LibraryBook a = new LibraryBook("Ocean Tides", 250);
LibraryBook b = new LibraryBook("Desert Stars", 120);
a.checkOut();
System.out.println(a.isCheckedOut() + " " + b.isCheckedOut());
System.out.println(a + " / " + b);

Output:

true false
Ocean Tides (250 pages) / Desert Stars (120 pages)

Memory after the code runs:

Variable	Object it refers to: title	pages	checkedOut
a	“Ocean Tides”	250	true
b	“Desert Stars”	120	false

Calling a.checkOut() changed only the checkedOut that belongs to a.

4. Keep instance variables private

Access to attributes should be kept inside the class to accomplish encapsulation, so it is good practice to make instance variables private unless the class specification says otherwise 3.3.A.5. Then the only way to change pages is through setPages, which refuses bad values.

A client that tries to reach a private instance variable directly does not compile:

LibraryBook book = new LibraryBook("Ocean Tides", 250);
book.pages = -5;

Compiler says:

error: pages has private access in LibraryBook

The public mutator is the correct way in, and it protects the data:

LibraryBook book = new LibraryBook("Ocean Tides", 250);
book.setPages(-5);
System.out.println(book);
book.setPages(300);
System.out.println(book);

Output:

Ocean Tides (250 pages)
Ocean Tides (300 pages)

5. Public and private methods

Access to behaviors can be internal or external to the class 3.3.A.6. A public method can be called from inside the class or from other classes. A private method can only be called inside the class 3.3.A.6.

In LibraryBook, the public method daysToRead calls the private helper divideRoundUp. That is allowed because the call is inside the class. A client calling the helper does not compile:

LibraryBook book = new LibraryBook("Ocean Tides", 250);
System.out.println(book.divideRoundUp(250, 30));

Compiler says:

error: divideRoundUp(int,int) has private access in LibraryBook

Watch out: choose private for a method when it is a small step that only the class itself needs, and public when it is a behavior that the class specification promises to other classes.