Object instantiation is the process of creating a new object from a class using the keyword new followed by a call to one of the class's constructors, which sets the initial values of the object's attributes (EK 1.13.C.1).
Object instantiation is how a class goes from being a blueprint to being an actual object in memory. You write the keyword new, then call one of the class's constructors, like Rectangle r = new Rectangle(3.0, 5.0);. The constructor has the same name as the class, and its job is to set up the object's initial attribute values using the arguments you pass in.
Two things happen in that one line, and the AP exam tests both. First, you declare a variable of a reference type (Rectangle r), which holds an object reference, or null if no object exists yet (EK 1.13.B.1). Second, new Rectangle(3.0, 5.0) actually builds the object and hands back a reference to it. The arguments you pass must match the constructor's parameter list in order, number, and type. If a class has multiple constructors with different signatures (that's called overloading), Java picks the one whose parameter list matches your arguments.
Instantiation lives in Topic 1.13 (Creating and Storing Objects) in Unit 1: Using Objects and Methods, and it directly supports three learning objectives. AP Comp Sci A 1.13.A asks you to identify which constructor is being called by matching the argument list to a constructor signature. AP Comp Sci A 1.13.B asks you to declare variables of the correct reference type. AP Comp Sci A 1.13.C asks you to actually write the code that creates an object with new. Beyond Unit 1, you can't write a single FRQ without it. Designing a class, building an ArrayList, or testing a method all start with new Something(...). If instantiation syntax isn't automatic, everything downstream breaks.
Keep studying AP® Computer Science A Unit 1
Object construction (Unit 1)
Construction and instantiation describe the same event from two angles. Instantiation is you calling new; construction is the constructor running and assigning your arguments to the object's attributes. Same line of code, two halves of the story.
Object reference (Unit 1)
Instantiation produces an object, but your variable never holds the object itself. It holds a reference that points to it. That's why two variables can refer to the same object, and why a reference variable with no object holds null.
Call by value (Unit 1)
When you pass arguments to a constructor, Java uses call by value, meaning the constructor gets copies of your argument values. For reference types, the copy is a copy of the reference, which is why methods can still modify the object it points to.
Constructor overloading (Unit 1)
Classes often have several constructors with different signatures (EK 1.13.A.3). When you instantiate, Java matches your argument list against those signatures, so reading signatures carefully is how you predict which constructor runs.
Instantiation is a multiple-choice staple. A typical stem gives you a class definition like public Book(String t, String a) and asks which line correctly creates a Book object, or which code segments will compile. The traps are predictable. Watch for arguments in the wrong order (passing an int where a String goes), the wrong number of arguments, a missing new keyword, or a declared type that doesn't match the class. Fiveable practice questions mirror this exactly, like asking which line correctly creates a Student object with name "Alice" and age 16. On the free-response section, no question asks you to define instantiation, but you'll use it constantly. Writing new expressions correctly, especially inside methods that build and return objects or add elements to an ArrayList, is baseline FRQ survival.
Declaring a variable (Rectangle r;) just creates a named slot that can hold an object reference. No object exists yet, and the reference is null. Instantiation (new Rectangle(3.0, 5.0)) actually creates the object. You usually do both in one line, which is why they blur together, but on the exam they're tested as separate skills (1.13.B vs 1.13.C). Calling a method on a declared-but-never-instantiated variable gives you a NullPointerException, not a new object.
Object instantiation means creating an object with the keyword new followed by a call to one of the class's constructors.
The constructor has the same name as the class, and the arguments you pass must match the parameter list in order, number, and type.
Declaring a reference variable does not create an object; until you instantiate, the variable holds null.
A variable of a reference type stores a reference to the object, not the object itself.
When a class has overloaded constructors, Java chooses the one whose signature matches your argument list.
Constructor arguments are passed using call by value, so the constructor receives copies of the values you pass in.
It's creating an object from a class using the new keyword and a constructor call, like Student s = new Student("Alice", 16);. The constructor uses your arguments to set the object's initial attribute values. It's covered in Topic 1.13 of Unit 1.
No. Book b; only declares a reference variable, and it holds null until you instantiate with b = new Book("Title", "Author");. The exam tests this distinction directly, and forgetting it leads to NullPointerExceptions in your code.
The constructor is the code inside the class that initializes the object's attributes. Instantiation is the act of calling that constructor with new. You instantiate; the constructor does the setup work.
Yes. Arguments must be compatible in order, number, and type with the constructor's parameter list (EK 1.13.C.3). Passing new Student(16, "Alice") to a constructor expecting (String, int) won't compile, and that exact mix-up is a favorite MCQ trap.
Yes, both ways. Multiple-choice questions ask you to pick the line that correctly instantiates an object or identify which overloaded constructor gets called, and every FRQ that builds or returns objects requires you to write new expressions correctly.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.