Create Object Instances

Class Definition

To create an instance of an object, first we need to have the full definition of the class, which includes 3 main components: Instance Variables, Constructors, and Methods.

Create Objects: Reference-Type Variable

Once we have the class definition, such as our Button class, then in order to create an instance of a class object, we do several things: 1. Create a Reference-Type variable: We need to declare that we will make an object of that specific data-type, so we must create a reference variable that we can use to access (or refer) to our object instance.

• Button myButton; //declare a reference-type variable, this can point to a Button object (it can hold the memory address of a Button-type object);

• The default value for a reference-type variable is 'null'.

• null keyword is a literal value that means an reference-type variable does not currently refer to an object instance. This allows us to test whether or not a reference-variable currently contains a valid memory address of an object.

• Button myButton; when we first declare an object reference, it is null;

• myButton = null; Allows us explicitly set an object reference to null

1. Call a valid Constructor Method (function) to create an object instance:

   • We need to use the keyword new to call a constructor

   • we need to call one of the constructors we defined in the class.

   • Executing: new Button() does several things:

     • it creates memory for our object in the 'Heap', the memory place where objects are stored for our program.

     • it executes code in the constructor method, this is a good place to initialize variables for our object

   • We will usually call a constructor using the following syntax:

     • myButton = new Button() - this sets the value of our object reference variable to be the memory address location in the heap where our object data is stored.

2. Use the Object Instance: once we have an object reference variable which is pointing to an object instance, the memory location of our object's data , now we can call methods of the object using dot notation: myButton.Click(); or we can modify instance variables myButton.x = 5;

3. Null pointer exception: If we try to do step 3 before we've done both step 1 and 2, we try to use an reference variable to call object methods,....before we have established a connection between our reference variable and an object instance....then we'll get a null pointer Exception.

4. Multiple references to a single object: It is perfectly ok to have more than 1 object reference variable pointing to an object instance. This would look like:

   Button myButton = new Button();  //create reference variable and call constructor 
   Button myButtonPointer = myButton;  // 2 Button reference variables are both `referring` to a single Button object instance.

5. Passing Objects into Functions as Parameters

   When we call a function or a method, if the function has an input parameter which is an object: then the address of the object is passed into the function. So, changes made to the function's local-parameter reference-variable are actually affecting the object, since it points to the same object adddress.

   //create function that takes an object as input parameter
   void myFunction( Button localButton ){
        localButton.x = 100;
   }
   Button myButton = new Button();
   myButton.x = 5;
   myFunction( myButton ); 
   
   println(myButton.x);  ///myButton.x is now 100, it was modified in the function

   When this function completes executing, then the local parameter, localButton, is destroyed, so it's no longer pointing at the object.