1. Constructors and Initialization

Introducing Constructors

• We often want to initialize the instance variables for an object when we create the object
• A constructor is a special type of method designed to perform such initialization
• Although it may not be obvious, we have been using constructors
• Constructors are called whenever we use the new operator to create an object
• For example:

  Phone iphone = new Phone();
  

• The expression new Phone() calls a constructor
• If you do not write your own constructor, then Java supplies one for you
• We have been using this automatically provided constructor up until now
• The automatically provided constructor constructs an object but does little else
• It is usually better to define your own constructor so you can correctly initialize variables

Defining a Constructor

• The general syntax for defining a constructor is:

  [accessModifier] ClassName(parameterList) {
      statements
  }
  

• Where:
  • accessModifier: determines which classes can access this method
  • ClassName: the same name as the class
  • parameterList: the types and names of the parameters
  • statements: the commands to execute when the method is called
• For now, use the public access modifier for all class constructors
  • Other objects call the constructor when creating new objects
• For example:

• Constructors must use the same name and capitalization as the class name
• Constructors can have zero or more parameters, just like other methods
• Constructors also have no return type (not even void!)
  

Example of Phone Class with Constructor

Multiple Constructors

• We can write a class with more than one constructor
• In other words, we can overload the constructor by defining multiple versions of it in a single class
  
• All constructors have the same name as the class, but have different parameter lists
• The technique of defining multiple constructors is known as constructor overloading
• Having multiple constructors allows us to create an object in different ways
• By allowing different ways of creating an object, we make our classes more flexible and easier to reuse
• A good constructor will assign values to each member variable of the class.
• Below are examples of well-written constructors:
  

Example: Constructor with no Parameters

• If you do not want to accept arguments for instance variables, write a constructor with no parameters:
• Note that constructors with no parameters are sometimes called default constructors
• A default constructor sets instance variables to default values

Example: Constructor with one Parameter

• If you want to accept only some arguments, write a constructor with at least one parameter.
• The remaining values can always be set later by calling the setter methods

  public Phone(String theBrand) {
      brand = theBrand;
      model = "Unknown model";
      price = 0.0;
  }

• Alternately, 
  

Example: Constructor with two Parameters

• If you want to accept arguments for all instance variables, write a constructor with parameters for each variable:

  public Phone(String theBrand, String theModel, double thePrice) {
      brand = theBrand;
      model = theModel;
      price = thePrice;
  }
  

Implicit Default Constructors

• If the programmer does not define a constructor, then the compiler supplies an empty one like the following:

  public Phone() {}

• However, if the programmer defines any constructor, the compiler does not provide one
• Best practice is to always define your own no-parameter constructor

Example Phone Class with Overloaded Constructors

/**
 * Phone.java example
 * @author parrishj
 *
 */

public class Phone {
    public String brand;
    public String model;
    public double price;
   
    /**Constructor(s)*/
   
    /**
     * Creates a new Phone object
     * with default values
     */
    public Phone() {
        brand = "Unknown brand";
        model = "Unknown model";
        price = 0.0;
    }
   
    /**
     * Creates a new Phone object
     * with default values, except
     * for the brand
     * @param theBrand the brand of
     * the phone
     * e.g. iPhone or Samsung
     */
    public Phone(String theBrand) {
        brand = theBrand;
        model = "Unknown model";
        price = 0.0;
    }
   
    /**
     * Creates a new Phone object
     * @param theBrand the brand of
     * the phone e.g. iPhone or Samsung
     * @param theModel the phone's
     * model. e.g. 7 or Galaxy S7
     * @param price the phone's price
     * in dollars
     */
    public Phone(String theBrand, String theModel, double thePrice) {
        brand = theBrand;
        model = theModel;
        price = thePrice;
    }
   
    /**Accessors*/

    /**
     * Returns the brand of phone
     * e.g. iPhone or Samsung
     * @return the brand
     */
    public String getBrand() {
        return brand;
    }
   
    /**
     * Returns the phone's model
     * e.g. 7 or Galaxy
     * @return the model
     */
    public String getModel() {
        return model;
    }
   
    /**
     * Returns the phone's current
     * market price
     * @return the price
     */
    public double getPrice() {
        return price;
    }
   
    /**Mutators*/

    /**
     * Assigns a brand to the phone
     * e.g. iPhone or Samsung
     * @param newBrand the brand of phone
     */
    public void setBrand(String newBrand) {
        brand = newBrand;
    }
   
    /**
     * Assigns a model to the phone
     * e.g. 7 or Galaxy
     * @param newModel the phone's model
     */
    public void setModel(String newModel) {
        model = newModel;
    }

    /**
     * Assigns the phone the current
     * market price for that brand
     * and model
     * @param newPrice the market price
     */
    public void setPrice(double newPrice) {
        price = newPrice;
    }
   
    /**Additional Methods*/

    /**
     * Displays a message alerting the user
     * that the phone is now making a call
     */
    public void makeCall() {
        System.out.println(brand + " is now making a call.");
    }
   
    /**
     * Displays a message alerting the user
     * that the phone is now making a call
     * to a specified person
     * @param name the person who is being called
     */
    public void makeCall(String name) {
        System.out.println(brand + " is now calling " + name);
    }
   
    /**
     * Returns a String of all the important
     * information about the phone, including
     * brand, model and price
     * @return the important phone information
     */
    @Override public String toString() {
        return "Brand: " + brand 
            + "\nModel: " + model
            + "\nPrice: " + price;
    }
}

Defining Objects from Overloaded Constructors

• If a class has more than one constructor, our program must decide which constructor to call
• The way that Java resolves which constructor to call is by matching the arguments to the parameter list
• Constructor matching is done based on the number and types of the parameters
• Also, the matching only works if the order is correct
• For example, assume our class has the following three constructors:

• Open up your Person.java class from the last activity.
• Now, add two constructors to your class as specified below:
• The first constructor is a default constructor
• It takes in no parameters
• It sets the the name field to have a default value of "name unknown"
• It sets the age field to have a default value of 0
• It sets the gender field to have a default value of "gender unknown"
• The second constructor overloads the first
• It takes in 3 parameters - a String for the name, an int for the age, a String for the gender
• It assigns name, age and gender the values passed in as parameters
  

• Java uses two types of memory - heap and stack memory
• Stack memory stores local variables (primitives and reference variables) and information about each method call.
• Throughout the execution of a program, the amount of stack memory currently in use grows and shrinks as methods are called and methods return (end).
  
• Heap memory stores objects.
• All of the data about the object.
  
• Reference variables in the stack memory point to objects on the heap
• Reference variables simply store the address of the object in the heap
  
• An object is shared by all reference variables to this object
  
• Once an object no longer has a reference variable referencing it in the stack memory, it is removed by the automatic garbage collection.
  

Wrap Up: 

• Answer the practice exam questions on Canvas from this lesson.

Upcoming Assignments:

• Activities 8.1 and 8.2 due Thursday at 11:59pm
• Lesson 8 Practice Exam Questions due Thursday at 11:59pm
• Quiz 4 due Friday at 11:59pm
• Peer Reviews of Lesson 7 and 8 Practice Exam Questions due Saturday at 11:59pm
  
• Lab 4 due Monday at 11:59pm