CMUQ 15-121 Classes, Objects, and OOP

• 1. Introduction
• 2. Visibility Modifiers
  • 2.1. Summary Table
  • 2.2. Conventions
• 3. Constructors
• 4. Getters and Setters
• 5. Aside: Static
  • 5.1. Static Methods
  • 5.2. Static Instance Variables
  • 5.3. Main Method

1. Introduction

While Python includes support for objects, you don’t actually need to use them in order to write a program. Java, however, is fundamentally object oriented. In Java, everything is an object.

Objects allow us to collect data and the actions that operate on that data into one entity.

• The data is called fields or instance variables. These are things the object needs to store.
• The actions are called methods. These are things an object needs to do.

A class provides the blueprint of what an object should look like. When you want to actually create one, then you create an instance of the class called an object.

Consider the following sample code for the hero in an adventure game. Our hero has two instance variables: hitPoints (the amount of damage the hero can take until death) and an array of items representing the inventory. There are also two methods: getHit that deducts damage from the hit points, and isDead that tells you if the hero is dead.

public class Hero {
    /*
     * This class has two instance variables
     */
    private int hitPoints;
    private Item[] items;
       
    
    /*
     * This class had two methods
     */
    public void getHit(int damage) {
        this.hitPoints -= damage;        
    }
    
    public boolean isDead() {
        if (hitPoints <= 0) {
            return true;
        }
        else {
            return false;
        }
    }
    
}

It is important to note that defining the Hero class does not create an object. This is just the class, the blueprint for a hero. In order to instantiate a hero we need a line like Hero bob = new Hero(). After that line runs, bob is hero object. We create one from blueprint represented by the class.

2. Visibility Modifiers

You may have noticed that in most of the examples so far both methods and instance variables have keywords in front of them like public and private. These keywords impact which code, outside of the object, is allowed to access that item.

• public means that the item is accessible to anyone. So, for example, the two methods in our Hero class above are public. If bob is our object, then anywhere in the program that has a copy of bob can call bob.getHit(5), because the getHit method is public.
• protected means that item is accessible to code in the same package, the same class, and even subclasses. (We’ll talk about subclasses later.)
• If you don’t specify visibility, then it receives package-private. This means the item is accessible inside the package and inside the class.
• private means that data is only accessible inside the class.

2.1. Summary Table

2.2. Conventions

3. Constructors

Every class needs at least one constructor. A constructor is a special method that is used by the class to instantiate an object. Typically, the constructor allocates and initializes the instance variables. You can have more than one constructor, as long as the different constructors have different parameters. If you don’t include a constructor, then Java will automatically include a default constructor that does almost nothing.

Remember our hero class from above? Here it is again, this time with some constructors. Either constructor can be used to instantiate an object from the Hero class.

public class Hero {
    /*
     * This class has two instance variables
     */
    private int hitPoints;
    private Item[] items;
       
    /*
     * This class has two constructors
     */
    
    public Hero() {
        this.hitPoints = 10;
        this.items = new Item[10];
    }
    
    public Hero(int hitPoints) {
        this.hitPoints = hitPoints;
        this.items = new Item[10];
    }
    
    /*
     * This class had two additional methods
     */
    public void getHit(int damage) {
        this.hitPoints -= damage;        
    }
    
    public boolean isDead() {
        if (hitPoints <= 0) {
            return true;
        }
        else {
            return false;
        }
    }
    
}

4. Getters and Setters

Given that instance variables should always be set private, what do you do if you need to modify them from outside the object? You create getters and setters. Getters and setters are methods you add to a class specifically to allow for access to instance variables. Consider the following example to allow the direct modification of a Hero’s hit points:

public class Hero {
    /*
     * This class has two instance variables
     */
    private int hitPoints;
    private Item[] items;

    /*
     * This class has two constructors
     */

    public Hero() {
        this.hitPoints = 10;
        this.items = new Item[10];
    }

    public Hero(int hitPoints) {
        this.hitPoints = hitPoints;
        this.items = new Item[10];
    }

    /*
     * A getter and setter for hitPoints
     */
    public int getHitPoints() {
        return hitPoints;
    }

    public void setHitPoints(int hitPoints) {
        this.hitPoints = hitPoints;
    }

    /*
     * This class had two additional methods
     */
    public void getHit(int damage) {
        this.hitPoints -= damage;
    }

    public boolean isDead() {
        if (hitPoints <= 0) {
            return true;
        } else {
            return false;
        }
    }

}

These allow code that is working with a hero object to modify the hitPoints of the Hero. Without providing getters and setters outside code cannot manipulate hitPoints, because it is a private instance variable.

5. Aside: Static

Let’s take a moment to talk about something else you’ve seen so far: static. When a method or instance variable is declared static that means that it is accessible as part of the class itself, not just as part of instantiated objects.

5.1. Static Methods

5.2. Static Instance Variables

5.3. Main Method