int myVar;

int myVar = 6;

/*File dynamic1.cpp  Copyright 1997, R.G.Baldwin
Illustrates static and dynamic instantiation of both
primitive variables and objects.  Also illustrates
instantiation of dynamic arrays of both primitive
variables and objects.

The output from this program is as follows:

myIntVar contains 6
myIntPtr points to 7
myIntArrayPtr points to 8 9 10
myStaticObj contains 11
myObjPtr points to 12
myObjArrayPtr points to 13 14 15

********************************************************/

#include<iostream.h

class dynamic1 {
  int objData; //single instance variable of the class

public:
  dynamic1(){}//default constructor

  //parameterized constructor
  dynamic1(int inData){objData = inData;}

  int getData(){return objData;} //get method

  void putData(int inData){objData = inData;}//put method

  static void classMain(){ //class method named classMain
    //Instantiate and initialize static primitive
    // variable
    int myIntVar = 6;
    cout << "myIntVar contains " << myIntVar << endl;

    //Instantiate and initialize dynamic primitive
    // variable
    int *myIntPtr = new int(7);
    cout << "myIntPtr points to " << *myIntPtr << endl;

    //Instantiate dynamic array of primitive variables.
    // Initialization is not supported for dynamic
    // arrays.
    int *myIntArrayPtr = new int[3];

    //Put some data in the dynamic array.
    for(int i = 0; i < 3; i++) *(myIntPtr+i) = i+8;

    //Display the data in the dynamic array.
    cout << "myIntArrayPtr points to ";
    for(i = 0; i < 3; i++) cout << *(myIntPtr+i)
                                                 << " ";
    cout << endl;

///Now work with objects instead of primitive variables.

    //Instantiate and initialize static object
    dynamic1 myStaticObj(11);
    cout << "myStaticObj contains "
                       << myStaticObj.getData() << endl;

    //Instantiate and initialize dynamic object
    dynamic1 *myObjPtr = new dynamic1(12);
    cout << "myObjPtr points to "
                       << myObjPtr - getData() << endl;

    //Instantiate dynamic array of objects.
    // Initialization of dynamic arrays is not supported.
    dynamic1 *myObjArrayPtr = new dynamic1[3];

    //Put some data in the dynamic array of objects
    for(i = 0; i < 3; i++)
      (myObjArrayPtr+i)-putData(i+13);

    //Display the data in the dynamic array of objects
    cout << "myObjArrayPtr points to ";
    for(i = 0; i < 3; i++)
      cout << (myObjArrayPtr+i)-getData() << " ";

  }//end classMain
};//End dynamic1 class definition.
//=====================================================//

void main()
{
  //call the class method named classMain
  dynamic1::classMain();
}//end main

/*File Dynamic1.java Copyright 1997, R.G.Baldwin
Illustrates allocation of primitive variables to static
memory at compile time.

Also illustrates instantiation of dynamic objects and 
dynamic arrays of objects at runtime.

The output from this program is as follows:

myPrimitiveVariable contains 6
myObjRef contains Dynamic1@1cc748
Object referred to by myObjRef contains 12
myArrayOfRefs contains 
Dynamic1@1cc766 
Dynamic1@1cc767 
Dynamic1@1cc768 

Objects referred to by myArrayOfRefs contain 
13 
14 
15 
********************************************************/

class Dynamic1 {
  //single instance variable of the class of type int
  private int objData; 

  //parameterized constructor
  public Dynamic1(int inData){
    objData = inData;
  }//end constructor

  //get method
  public int getData(){
    return objData;
  }//end getData()

  public static void main(String[] args){//main method
    //Declare and initialize primitive variable of type 
    // int in static memory at compile time. Display it.
    int myPrimitiveVariable = 6;
    System.out.println("myPrimitiveVariable contains " 
                                  + myPrimitiveVariable);

    //Instantiate and initialize object in dynamic memory
    // at runtime.  Display the contents of the reference
    // variable and the contents of the object it refers
    // to.
    Dynamic1 myObjRef = new Dynamic1(12);
    System.out.println("myObjRef contains " + myObjRef);
    System.out.println(
              "Object referred to by myObjRef contains " 
                                 + myObjRef.getData() );

    //Instantiate array of references to objects in 
    // dynamic memory at runtime.
    Dynamic1[] myArrayOfRefs = new Dynamic1[3];

    //Instantiate some objects in dynamic memory and
    // store references to those objects in the array
    // of references.
    for(int i = 0; i < 3; i++)
      myArrayOfRefs[i] = new Dynamic1(i+13);

    //Display the values contained in the array of 
    // references to objects
    System.out.println("myArrayOfRefs contains ");
    for(int i = 0; i < 3; i++)
      System.out.println(myArrayOfRefs[i]);
    System.out.println();

    //Display the values in the objects referenced by
    // the array of references
    System.out.println(
        "Objects referred to by myArrayOfRefs contain ");
    for(int i = 0; i < 3; i++)
      System.out.println(myArrayOfRefs[i].getData());

  }//end Main
}//End Dynamic1 class definition.

/*File Dynamic2.java Copyright 1997, R.G.Baldwin
Illustrates instantiation of array of references of type
Object and the use of that array to refer to objects
of an inherited class.

The output from this program is as follows:

myArrayOfRefs contains 
Dynamic2@1cc738 
Dynamic2@1cc739 
Dynamic2@1cc73a 

Objects referred to by myArrayOfRefs contain 
13
14
15
********************************************************/

class Dynamic2 {
  //single instance variable of the class of type int
  private int objData; 

  //parameterized constructor
  public Dynamic2(int inData){
    objData = inData;
  }//end constructor

  //get method
  public int getData(){
    return objData;
  }//end getData()

  public static void main(String[] args){//main method
    //Instantiate array of references to objects of type
    // Object in dynamic memory at runtime.
    Object[] myArrayOfRefs = new Object[3];

    //Instantiate some objects of type Dynamic2 in 
    // dynamic memory and store references to those 
    // objects in the array of references of type Object.
    for(int i = 0; i < 3; i++)
      myArrayOfRefs[i] = new Dynamic2(i+13);

    //Display the values contained in the array of 
    // references to objects. Note that the values
    // identify the actual type of object referred to.
    System.out.println("myArrayOfRefs contains ");
    for(int i = 0; i < 3; i++)
      System.out.println(myArrayOfRefs[i]);
    System.out.println();

    //Display the values in the objects referenced by
    // the array of references.  Note the requirement
    // to downcast the references to the actual type
    // of object referred to by the references in
    // order to access the instance variables of the
    // objects.
    System.out.println(
        "Objects referred to by myArrayOfRefs contain ");
    for(int i = 0; i < 3; i++)
      System.out.println(
        ((Dynamic2)(myArrayOfRefs[i])).getData());
  }//end Main
}//End Dynamic2 class definition.

/*File date1.java Copyright 1997, R.G.Baldwin
Illustrates instantiation of an object without the 
declaration of a name.  A Date object is instantiated 
and passed to the I/O system for display.  The Date 
class is contained in java.util, thus the requirement 
for the import statement.

The output for one particular run was:

Thu Oct 24 16:44:35  1996

********************************************************/
import java.util.*;
class date1 { //define the controlling class
  public static void main(String[] args){ //main method
    System.out.println( new Date() );
  }//end main
}//End date1 class.  

/*File Anonymous1.java Copyright 1997, R.G.Baldwin
Illustrates instantiation and use of an anonymous
object in a local expression.

The output from this program is as follows:
13

********************************************************/

class Anonymous1 {
  private int objData; //instance variable

  public Anonymous1(int inData){//constructor
    objData = inData;
  }//end constructor

  public int getData(){//get method
    return objData;
  }//end getData()

public static void main(String[] args){//main method
    System.out.println("" 
                    + (new Anonymous1(10).getData()+3));
  }//end Main
}//End Anonymous1 class definition.

/*File Anonymous2.java Copyright 1997, R.G.Baldwin
Illustrates instantiation and use of an anonymous
object to display the integer value 128 in hex.

The output from this program is as follows:
80
80

********************************************************/

class Anonymous2 {

public static void main(String[] args){//main method
    //Note that the value of zero being passed to the
    // Integer class constructor is a dummy value 
    // provided to make it possible to instantiate
    // the object of type Integer.  The object of 
    // type Integer is needed so that its instance
    // method named toHexString() can be invoked.
    System.out.println("" 
                    + new Integer(0).toHexString(128));

    //Access the toHexString() method as a class method
    // without the requirement for an object of the 
    // Integer type.
    System.out.println(Integer.toHexString(128));      
  }//end Main
}//End Anonymous2 class definition.

/*File date1.cpp  Copyright 1997 R.G.Baldwin
Illustrates instantiating an object without an "obvious"
declaration of the object.  An object is instantiated and
passed to a function where it is used to initialize one
of the parameters in the function.

The output from the program is:

The date is 10/24/96

*****************************************************/

#include<iostream.h
#include<string.h

class dateContainer{ //class to instantiate a date object
public:
  char dataArray[20];
  dateContainer(char* inString){
    strcpy(dataArray,inString);
  }
};//end class

class date1 { //simulates Java controlling class
public:
  //Function to receive an object containing a date
  // and display it.
  void displayDate(dateContainer objIn){
    cout << "The date is "<< objIn.dataArray << endl;
  }//end displayDate()

  static void classMain(){
    //object is required to call displayDate()
    date1 thisObject;

    //Put a call to the constructor as a parameter in
    // the function call.
    thisObject.displayDate(dateContainer("10/24/96") );
  }//end classMain
};//End date1 class definition.
//=====================================================//

void main()
{
  //call the class method named classMain
  date1::classMain();
}//end main