Introduction to Mutator Methods

Now that we are done with accessor methods, we will move on to mutator methods (also called setter methods). Mutator methods change the values of instance variables of an object by setting them to another value as a parameter. The headers for these methods are basically the opposite of accessor methods. 

While accessor methods have a return type and no parameters, mutator methods usually have no return type (they are usually void methods) and have a parameter (the value which to change the object to). Like accessor methods, sometimes we don't want other clients to change the data of an object, thus there will not be a mutator method for that instance variable. 

If a class has no mutator methods, then that class is said to be immutable. In our example, we will have the Assignment class be immutable with no mutator methods.

Writing Mutator Methods for the Student Class

Now, we will write mutator methods for the Student classes for the variables that we want the client to be able to change: name and gradeLevel.

/** Represents an assignment that a student will complete
*/
public class Assignment {
  private boolean correctAnswer; // represents the answer to an assignment, either T/F

  /** Makes a new assignment with one True/False question and sets the correct answer
  */
  public Assignment(boolean answer) {
    correctAnswer = answer;
  }
  
  /** Prints details about the assignment
  */
  @Override
  public String toString() {
    return "This is an assignment with correct answer " + answer;
  }

}

/** Represents a high school student
*/
public class Student {
  private int gradeLevel; // a grade between 9-12
  private String name; // the students name in the form "FirstName LastName"
  private int age; // the student's age, must be positive
  private Assignment assignment; // the current assignment the student is working on

  /** Makes a new student with grade gradeLev, name fullName, and age ageNum
  */
  public Student(int gradeLev, String fullName, int ageNum) {
    gradeLevel = gradeLev;
    name = fullName;
    age = ageNum;
    assignment = null; // There is no active assignment at the moment
  }

  /** Returns the student's grade level
  */
  public int getGradeLevel() {
    return gradeLevel;
  }
  
  /** Returns the student's name
  */
  public String getName() {
    return name;
  }

  
  /** Returns the current assignment the student is working on
  */
  public Assignment returnCurrentAssignment() {
    return assignment;
  }

  /** Prints details about the student
  */
  @Override
  public String toString() {
    return name + ", a " + gradeLevel + "th grade high school student";
  }

  **/** Changes the student's name
  */
  public void setName(String fullName) {
    name = fullName;
  }

  /** Changes the student's grade level
  */
  public void setGradeLevel(int gradeLev) {
    gradeLevel = gradeLev;
  }**

}

Note that if a method does not return anything, the keyword void appears before the method name. If a method does return something, we put the return type (String, boolean, int, double, float, char, etc.) in this location instead of void. 

In some cases, a class might have mutator methods that are not void. There can be mutator methods that return the original value of the variables they change. However, mutator methods are typically void methods. 

Using Mutator Methods

Let's see how mutator methods work in practice. 

Assume that this is in the main method of some other class:

Student bob = new Student(10, "Bob Smith", 16);

If we check the state of bob, gradeLevel is 10, name is "Bob Smith," age is 16, and assignment is null. 

Now let's say that we realized we forgot Bob's middle name and input the wrong grade level. We can change these features through the following lines:

bob.setName("Bob John Smith");

bob.setGradeLevel(11);

Now if we check the state of bob, gradeLevel is 11, name is "Bob John Smith," age is 16, and assignment is null. 

Note that once we construct bob, we have no way of changing the values of age or assignment because there are no mutator methods for these two variables.