Object Creation and Storage (Instantiation)

Overview

Two periods on three learning objectives. Day 1 is about building and storing an object: an object is created with the keyword new followed by a call to one of the class’s constructors, which have the same name as the class (1.13.C.1, 1.13.A.1); the reference that comes back is stored in a variable whose type is the class, and a reference variable holds null when there is no object (1.13.B.1); a constructor’s signature is its name plus the ordered list of parameter types, read from the header’s parameter list (1.13.A.2); and the values passed in set the new object’s starting values (1.13.C.2). Day 2 is about choosing and running a constructor: overloaded constructors have different signatures (1.13.A.3); arguments must be compatible with the parameter list in number, order, and type, and they are passed by value (1.13.C.3); and a constructor call jumps into the constructor and back (1.13.C.4).

The CED’s suggested skill is 2.B (write program code involving data abstractions). The guided practice and puzzle worksheet ask students to build and correct complete constructor calls, not just recognize them.

• String and Scanner are the running examples. Students already use Scanner console = new Scanner(System.in); (Topic 1.4) and nextInt, nextDouble, and nextLine to read input. Calls such as reader.nextInt() appear as in Topic 1.4; say once that the rules for calling a method on an object are taught fully in Topic 1.14.
• Constructor code inside a class is read, never written. Ticket, Locker, Pizza, Backpack, Lamp, Parcel, Sprout, Kite, and Camera are invented for this lesson so students can see inside a constructor; writing classes and constructors is Unit 3.
• A string literal such as "Ada" still gives a String object without new. That shortcut belongs to String alone and is covered in Topic 1.15. Joining text with + is also Topic 1.15, so a label and a value still take a print followed by a println.
• Method headers for main start with public static. Students can read past them; they are explained in a later topic.

Show slide 2, or write Scanner console = new Scanner(System.in); on the board. Pairs answer three questions in two minutes: “Which word is the name of a class?”, “After this line runs, does an object exist? What kind?”, and “What does console hold: the object, or something else?”

Expected: Scanner is the class (it appears twice); yes, one Scanner object exists; and from Topic 1.12, console holds a reference to the object, which you can picture as its address. Then ask the question nobody can answer yet: “What does the word new do?” Leave it on the board; it is today’s first idea.

1. The construction crew (slides 3–5). Read the five goals on slide 3; the first three are today’s. A blueprint is not a house; someone has to build the house. Every class comes with special code whose only job is to build objects of that class: a constructor (1.13.A.1). A constructor has the same name as its class, capital letter and all.
2. new (1.13.C.1). An object is created by writing the keyword new followed by a call to one of the class’s constructors. new means “build a brand-new object”; the constructor call after it says which class and with what information. Creating an object is called instantiation: the result is a new instance (Topic 1.12).
3. Take one statement apart (slide 5). String greeting = new String("Good morning"); Piece by piece: String greeting declares a variable that can refer to a String; = stores the right side’s result (Topic 1.4); new asks for a new object; String(...) is the constructor call; "Good morning" is the information passed in. Java runs the right side first, and the result of new is a reference to the new object, which = stores in greeting. (NewGreeting prints Good morning.)
4. Same shape, another class (slide 6). Run KeyboardScanner. Line 7 has exactly the same shape: new Scanner(System.in) calls the Scanner constructor with System.in (the keyboard), and the reference is stored in keyboard. It prints A Scanner object is ready. and nothing needs to be typed: building a Scanner only sets it up to read. Slide 6 lines up three statements to show the pattern Type name = new Type(...);.
5. Predict: MissingNew (slide 7 afterward). Without new, does it compile? No: Java reports cannot find symbol and names method String(String). Without new, Java thinks this is an ordinary method call (Topic 1.9) to a method named String, and there is none.
6. The literal shortcut. Students will ask why String name = "Ada"; works without new. A string literal is a shortcut only String gets; Topic 1.15 covers it. Every other class’s objects come from new.

This is the CED’s “Marking the Text” strategy. Write the four statements on the board. Each student copies the four statements and marks them with colors: circle the assignment operator and the keyword new; underline the variable’s type and the constructor being called; draw a box around the list of arguments passed to the constructor.

• Scanner keyboard = new Scanner(System.in);
• String city = new String("Denver");
• Ticket mine = new Ticket("Dune", 14, 12.5);
• String empty = new String();

Debrief by asking: “In every statement, what do the two underlined words have in common?” They match: the variable’s type is the class being built. “What is in the box in the last statement?” Nothing: that constructor takes no arguments. “How many objects exist after all four run?” Four, one per new.

1. Where does the reference go? (slide 8). If the reference new hands back is not stored, the program can never find the object again. It goes in a variable whose type is the class: Scanner keyboard;, String city;. It looks like a Topic 1.2 declaration with a class name where a primitive type would go.
2. Predict: SharedReference (slide 9 afterward). How many objects? Line 2 has no new, so it builds nothing; = copies the reference already in city (Topic 1.12). Both lines print Denver, and there is one object. Rule of thumb: count the news to count the objects.
3. null (1.13.B.1). A variable of a reference type holds an object reference or, if there is no object, the literal null (Topic 1.4). Run NullThenObject: it prints null, then Sky. Line 3 creates an object and its reference replaces null, like any assignment.
4. Empty is not null (slide 10). Run EmptyVersusNull. new String() builds a real object with no characters, so the brackets print with nothing between them: []. The null variable prints [null], because there is no object at all.
5. Predict: which declarations compile? (slide 11). Pairs decide for the four declarations. Expected: A (String title = null;) and C (Scanner in = new Scanner(System.in);) compile; B (double price = null;) and D (String reader = new Scanner(System.in);) do not. Then compile the two demo files for the messages: WrongVariableType: incompatible types: Scanner cannot be converted to String. NullPrimitive: incompatible types: <null> cannot be converted to int. A String variable holds only references to String objects; an int always holds a number, never a reference, so it cannot hold null.

1. Reading a header (slides 12–13). How do you know what goes in the parentheses for a class you have never used? Read the constructor’s header in the documentation, as in Topic 1.9. Two real ones: String(String original) and Scanner(InputStream source). A constructor header has the class name and no return type, not even void.
2. Parameter list and signature (1.13.A.2). The parameter list gives the type and a variable name for each value the constructor needs. The signature is the constructor’s name plus the ordered list of parameter types; the names are left out. String(String original) has the signature String(String); String() has the signature String().
3. A made-up header (slide 13). Ticket(String movie, int seat, double price) has the signature Ticket(String, int, double). A call needs three values in that order: a String, an int, then a double. Order is part of the signature: Ticket(int, String, double) would be a different one.
4. Parameters set starting values (1.13.C.2). A new object has to start out holding something, and the constructor cannot guess. The values passed in set the starting values of the new object’s attributes. Run ScannerFromText: new Scanner("85 92") builds a Scanner whose starting text is 85 92 (the reader line on slide 6), so the program prints 85 and 92 with no typing. Change the argument and the same lines read different numbers.

Hand out the puzzle worksheet. Students work questions 1, 2, 6, and 8: counting the objects each statement creates, a be-the-compiler table of declarations and constructor calls, a face-off between an empty String and null, and a one-name fix for a variable that copied null before the object existed. Whatever is not finished is homework. Circulate and check question 1: students who count an object for String b = a; or String c = null; are not yet counting the news.

Point at the four marked statements from guided practice. Ask: “How many objects do these four statements create?” (Four.) Then add String sameCity = city; and ask again. (Still four: no new, no new object.) One student finishes the sentence: “A constructor runs only when …” (new calls it).

Show new String() and new String("Lake"). Ask: “Both call a constructor named String. How many arguments does each pass? What does each new object hold?” Expected: zero arguments, and the object holds no characters; one String argument, and the object holds Lake. Then: “So how many String constructors are there?” At least two, which is today’s first idea.

1. Why more than one? People want objects that start in different ways: a String with given characters or an empty one; a Scanner that reads the keyboard or one that reads text you already have.
2. Overloaded constructors (1.13.A.3, slide 14). A class’s constructors all share the class name, so they are told apart by their parameter lists. Constructors are overloaded when a class has more than one constructor with different signatures: a different number of parameters, different types, or the same types in a different order. The same idea as overloaded methods in Topic 1.9.
3. How Java chooses (1.13.A, slide 14). It matches the call’s arguments against each signature and runs the one that fits: slide 14’s Lamp calls each pick a different constructor by their arguments. That is also why two constructors may never share a signature: Java could not choose.
4. Predict: TwoScanners. Both calls pass one argument, so the type decides: System.in is an InputStream, so line 7 runs Scanner(InputStream); "70 88" is a String, so line 8 runs Scanner(String). It prints 70.
5. Predict: StringFromNumber. new String(5) does not compile: no suitable constructor found for String(int). Overloading gives a class only the constructors that were written, and no String constructor takes an int.

1. Arguments and parameters (1.13.C.3, slide 17). An argument is a value passed in when the constructor is called. Java pairs arguments with parameters by position, so three things must line up: the number of arguments, their order, and their types. Each argument must be compatible with its parameter: that type, or one Java converts to automatically. From Topic 1.5, an int converts to a double automatically; a double never converts to an int on its own.
2. Run Ticket. new Ticket("Dune", 14, 12) prints Dune, 14, and 12.0. The third argument is the int 12 going to double price; it is compatible, and the output shows the conversion.
3. Change one thing. Three calls, each one small change from a call that works, and none compiles (slide 17 shows them beside the call that works):

In the last call, 14 going to double price would be fine; the problem is 12.5 going to int seat.

Go back to slide 15 (Pick the constructor). Pairs decide which Pizza constructor each call runs, or “none.” Expected: A runs Pizza(String, int); B does not compile, because 2 would go to String size; C does not compile, because this class has no constructor with no parameters; D runs Pizza(String). Call out C: a class has only the constructors that were written.

Then the harder round on the board. An invented class Backpack has four constructors: Backpack(), Backpack(String color), Backpack(String color, int pockets), and Backpack(int pockets, double weight). Pairs decide, for each of six calls, which constructor runs, or that no constructor matches and the call does not compile.

Debrief by running BackpackCalls, whose constructors print which one ran: Backpack(), Backpack(String, int), Backpack(int, double) with weight 2.0, and Backpack(String). Then compile BackpackNoMatch to see no suitable constructor found for Backpack(int,String) and no suitable constructor found for Backpack(double,int). Notice that the compiler describes each failed call by its argument types, the same form as a signature.

1. The question. “If a constructor changes its parameter, does your variable change too?” If it could, you could never trust a variable after a call.
2. The rule (1.13.C.3, slide 18). Arguments are passed using call by value: each parameter starts as a copy of its argument’s value. Like photocopying a form before handing it over: whatever is written on the copy, your original stays as it was.
3. Predict: Locker. The constructor adds 100 to its parameter. Students predict both lines. Output: 112, then 12. Trace with two columns: myNumber in main stays 12 the whole time; number starts as a copy of 12, becomes 112, and is gone when the constructor finishes. Slide 18 shows the same copy with mySeat staying 14.
4. Arguments can be expressions. Java evaluates an argument first and passes a copy of the result. The study guide’s SeatExpression passes row * 10, so seat starts at 30 and row is still 3.

1. The rule (1.13.C.4, slide 18). A constructor call interrupts the normal top-to-bottom order. Java runs every statement in the constructor first; once the last one finishes, control returns to the point right after the call, finishes that statement (storing the reference), and moves on. The order statements actually run in is the flow of control.
2. The analogy. Pausing a video to answer the door: you deal with the visitor completely, then resume exactly where you stopped.
3. Predict: Pizza. Students write the four lines of output. Open; line 6 jumps into the constructor, which prints cheese; back to line 7, Next customer; line 8 jumps in again and prints veggie. Each new makes its own jump and returns to just after its own call.
4. Check: slide 19 (Line up at the movies). Pairs write the output: Line up, Ticket 5, Buy popcorn, Ticket 6, Find seats.

Puzzle worksheet questions 3–5, 7, 9, and 10 are homework, about 20 minutes: a snippet pool that picks among overloaded Parcel constructors, a be-the-JVM trace of two constructor calls and call by value, code tiles that read a city and a box count with Scanner and build a Parcel, two truths and a lie about Kite signatures, a who-am-I vocabulary review, and a one-sentence reflection on how Java chooses a constructor. Question 4 settles the Think First prediction printed just before it.

Leave slide 20 (Words to know) up. Write Ticket mine = new Ticket("Up", seat, 9); on the board, with int seat = 5; above it. Ask the class to name, in order: the variable’s type, the keyword that creates the object, the signature that must exist, the conversion that happens (the int 9 becomes 9.0), what seat holds after the call (still 5: call by value), and when the next line runs (after every statement in the constructor). If time allows, slide 21’s sentence starter takes the warm-up line apart one last time as a pair-share.

Give the exit ticket (about five minutes). Question 1 checks choosing a constructor by its signature and matching arguments in number, order, and type (1.13.A, 1.13.C); question 2 checks reference variables, null, and counting the objects new creates (1.13.B, 1.13.C). Re-teach the weaker one at the start of Topic 1.14.