2.2: CREATING AND STORING OBJECTS (INSTANTIATION)

OBJECTIVES

I can:

• create and use constructors

• create objects by calling constructors with parameters

• explain the purpose of method overloading

• create classes that overload methods

• explain how null objects do not point to any particular object data

• create programs that use other classes as a client to solve a specific problem

A Java class defines what objects of the class know (attributes) and what they can do (behaviors).

Each class has constructors like World() and Turtle(habitat) which are used to initialize the attributes in a newly created object.

A new object is created with the new keyword followed by the class name. For example:

Person firstName = new Person("John");

When this code executes, it creates a new object of the specified class and calls a constructor, which has the same name as the class.

For example, new Person() creates and initializes a new object of the Person class. 

For in the Java Swing Turtle program, new World() creates and initializes a new object of the World class, and new Turtle(habitat) creates and initializes a new Turtle object in the World habitat:

World habitat = new World(); // create a new World object

Turtle t = new Turtle(habitat); // create a new Turtle object

OVERLOADING CONSTRUCTORS

There can be more than one constructor defined in a class.

This is called overloading the constructor.

Usually there is a constructor that has no parameters (nothing in the parenthesis following the name of the constructor) like the World() constructor above.

This is also called the no-argument constructor. 

The no-argument constructor usually sets the attributes of the object to default values.

There can also be other constructors that take parameters like the Turtle(habitat) constructor above.

A parameter (also called an actual parameter or argument) is a value that is passed to a constructor. 

It can be used to initialize the attribute of an object.

The World class actually has two constructors.

One doesn't take any parameters and one takes the width and height:

World world1 = new World();

World world2 = new World(int width, int height);

THE WORLD CLASS CONSTRUCTORS

The constructor that doesn't take any parameters, World(), creates a graphical window with 640x480 pixels.

The World(int width, int height) constructor takes two integer parameters, and initializes the World object's width and height for them, for example new World(300, 400) creates a 300x400 pixel world:

World world1 = new World(); // creates a 640x480 world

World world2 = new World(300, 400); // creates a 300x400 world

Note: The turtle world does not use the cartesian coordinate system. The top left corner is (0, 0). x increases to the right, and y increases towards the bottom of the screen.

THE TURTLE CLASS CONSTRUCTORS

The Turtle class also has multiple constructors, although it always requires a world as a parameter in order to have a place to draw the turtle.

There is another Turtle constructor that places the turtle at a certain (x, y) location in the world, for example at the coordinate (50, 100) below:

Turtle t1 = new Turtle(world1);

Turtle t2 = new Turtle(50, 100, world1);

Note: Notice that the order of the parameters matters. The Turtle constructor takes (x, y, world) as parameters in that order. If you mix up the order of the parameters it will cause an error, because the parameters will not be the data types that it expects. 

OBJECT VARIABLES AND REFERENCES

You can also declare an object variable  and initialize it to null (Turtle t1 = null;).

An object variable holds a reference to an object.

A reference is a way to find the object in memory.

It is like a tracking number that you can use to track the location of a package.

Dog fido = new Dog();

Dog fido declares a new variable named fido which can hold a reference to a Dog object. 

new Dog() calls the Dog() constructor to create a new Dog object. 

The assignment operator (=) assigns a reference to fido for the new Dog object.

Dog spot = null;

Dog oreo;

Dog spot and Dog oreo declare new variables named spot and oreo that can hold references to Dog objects.

When there is no value or a variable is assigned null there is no reference to a Dog object... yet. So, spot and oreo are both null.

Turtle t1 = null;

So, the code above creates a variable t1 that refers to a Turtle object, but the null means that it doesn't refer to an object yet.

You could later create the object and set the object variable to refer to that new object:

t1 = new Turtle(world1);

It is most common to declare an object variable and initialize it in the same line of code:

Turtle t2 = new Turtle(world1);

CONSTRUCTOR SIGNATURES

When you use a class that someone has already written for you in a library that you can import like the Turtle class above, you can look up how to use the constructors and methods in the documentation for that class.

Turtle Documentation 

The documentation will list the signatures (or headers) of the constructors or methods which tell you their name and parameter list.

The parameter list, in the header of a constructor, lists the formal parameters, declaring the variables that will be passed in as values and their data types.

Constructors are overloaded when there are multiple constructors in the same class, but the constructors have different signatures (differ in number, type, and/or order of parameters).

For example, the image above shows two constructors for the Turtle class that take different parameters.

In unit 5, we will learn how to write our own classes from scratch.

However, if you see a class definition on the AP exam, like the one below for a class called Date, you should be able to pick out the attributes (instance variables) and the constructors and know how to use them.

For example, I could use the information above to create new Date objects!

Date birthday = new Date(1988, 4, 13);

Date default = new Date();

FORMAL AND ACTUAL PARAMETERS

When a constructor like Date(2005, 9, 1) is called, the formal parameters, (int year, int month, int day), are set to copies of the actual parameters (or arguments), which are 2005, 9, and 1.

This is call by value which means that copies of the actual parameter values are passed to the constructor.

These values are used to initialize the object's attributes.

The type of the values being passed in as arguments have to match the type of the formal parameter variables.

We cannot give a constructor a String object when it is expecting an int.

The order of the arguments also matters.

If you mix up the month and day in the Date constructor, you will get a completely different date, for example January 9th (1/9) instead of September 1st (9/1).

Yes, this lesson does introduce A LOT of vocabulary, but don't worry if you don't understand everything about classes and constructors yet.

We will learn more about how this all works in Unit 5 when we actually write our own classes and constructors.

SUMMARY

• Constructors initialize the attributes in newly created objects. They have the same name as the class.

• A constructor signature is the constructor name followed by the parameter list which is a list of the types of the parameters and the variable names used to refer to them in the constructor.

• Overloading is when there is more than one constructor. They must differ in the number, type, or order of parameters.

• New is a keyword that is used to create a new object of a class. The syntax is new ClassName( ). It creates a new object (instance) of the specified class and calls a constructor.

• A no-argument constructor is a constructor that doesn't take any passed in values (arguments) and usually sets default values for the attributes (instance variables).

• Parameters allow values to be passed to the constructor to initialize the newly created object's attributes.

• The parameter list, in the header of a constructor, is a list of the type of the value being passed and a variable name. These variables are called the formal parameters.

• Actual parameters are the values being passed to a constructor. The formal parameters are set to a copy of the value of the actual parameters.

• Formal parameters are the specification of the parameters in the constructor header. In Java this is a list of the type and name for each parameter. For example, World(int width, int height).

• Call by value means that when you pass a value to a constructor or method it passes a copy of the value.

EVIDENCE

1) Complete the following Google Form. This form must be 100% correct and includes released AP practice questions. To stop working and return later, hit submit! You can "edit your response" and continue where you left off.

UO.2 Evidence 

2) MC Exam Practice: This lesson has additional practice problems which can be found on the MC Exam Practice page with an answer key! Use ctrl + f to search for different objectives throughout the year. You could look at these questions now, or, save these practice questions for later and use them to review! The choice is yours.