Objects. Creating and saving the objects of classes. Areas of data storage in memory. Using an arrays of references to objects

Objects. Creating and saving the objects of classes. Areas of data storage in memory. Using an arrays of references to objects


Contents


1. How to create a class object using the new operator? General form

Java uses a single syntax for working with objects. A class object is declared using a reference.

The general form of declaring a class object without allocating memory for it has the following form:

ClassName objName;

where

  • ClassName – class name for which an object named objName is created;
  • objName – the name of the reference to the ClassName object.

The above declaration indicates that the objName is a reference to a ClassName object. For the reference you need to allocate memory (initialize the reference) using the new operator as shown below:

objName = new ClassName();

If you do not allocate memory for the reference and refer to it as a class object, an error will occur.

There is another general form for declaring a class object. In this case, the memory is allocated when the object is declared:

ClassName objName = new ClassName();

The allocation of memory for a reference to a class object is also called “attaching” an object to a reference.

 

2. Examples of creating the objects of different classes

Example 1. Create a CLine class object that implements the line on the coordinate plane. The program code for the class declaration is:

// class that implements a line on the coordinate plane
public class CLine
{
    // internal variables
    private double x1, y1, x2, y2;

    // class constructors
    // constructor without parameters
    CLine()
    {
        x1 = y1 = 0;
        x2 = y2 = 1;
    }

    // constructor with 4 parameters
    CLine(double x1, double y1, double x2, double y2)
    {
        this.x1 = x1; this.y1 = y1;
        this.x2 = x2; this.y2 = y2;
    }

    // access methods
    // get data
    public double GetX1() { return x1; }
    public double GetY1() { return y1; }
    public double GetX2() { return x2; }
    public double GetY2() { return y2; }

    // set data
    void SetXY(double nx1, double ny1, double nx2, double ny2)
    {
        x1 = nx1; y1 = ny1;
        x2 = nx2; y2 = ny2;
    }

    // A method that calculates the length of a line
    double Length()
    {
        double len;
        len = Math.sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
        return len;
    }
}

The following code shows how to create and use CLine objects.

public class CTestLine
{
    public static void main(String[] args)
    {
        double x, y; // additional variables

        // creating a CLine class object using a constructor without parameters
        CLine line1 = new CLine();

        // creating a CLine class object using a constructor with 4 parameters
        CLine line2 = new CLine(2.0, 3.0, 4.0, 5.0);

        // using objects of line1 class
        x = line1.GetX1(); // x = 0.0
        y = line1.GetY2(); // y = 1.0

        // using objects of line2 class
        x = line2.GetX1(); // x = 2.0
        x = line2.GetX2(); // x = 4.0
        y = line2.GetY2(); // y = 5.0

        // redefining the line1 object, the previous object will be destroyed using the "garbage collector"
        line1 = new CLine(-4.0, -2.0, 33.4, -20.5);

        x = line1.GetX1(); // x = -4.0
        y = line1.GetY2(); // y = -20.5
    }
}

As you can see from the code, in the main() function two references with the names line1, line2 are declared for CLine objects. Memory is allocated for these references using the ‘new’ statement. Then, for the line2 object, the memory is redefined again. The old memory will be freed with the next of garbage collection.

Example 2. Create a CName class object that implements the name. The main() function demonstrates the creation of a CName class object in different ways using different constructors.

// class that implements the name
public class CName
{
    private String name;
    private String surname;
    private String patronymic;

    // class constructors
    // constructor without parameters
    CName()
    {
        name = surname = patronymic = "";
    }

    // constructor with three parameters
    CName(String _name, String _surname, String _patronymic)
    {
        name = _name;
        surname = _surname;
        patronymic = _patronymic;
    }

    // access methods
    String GetName() { return name; }
    String GetSurname() { return surname; }
    String GetPatronymic() { return patronymic; }

    // function that demonstrates the use of the CName class
    public static void main(String[] args)
    {
        CName nm1 = new CName(); // the constructor without parameters is called
        CName nm2; // just declaring a reference to an object of the CName class, the memory has not yet been allocated
        nm2 = new CName("Happy", "New", "Year!"); // creating an object - allocating memory

        // checking
        String str;
        str = nm1.GetName(); // str = ""
        str = nm1.GetSurname(); // str = ""

        str = nm2.GetName(); // str = "Happy"
        str = nm2.GetSurname(); // str = "New"
        str = nm2.GetPatronymic(); // str = "Year!"
    }
}

 

3. What are the areas of data storage in Java programs?

In Java for storing data (objects) there are 5 different repositories:

  • registers. In this case, the data is stored inside the processor. In the registers, the data are processed most quickly. However, the number of registers is strictly limited. The compiler uses registers as needed. In Java, there are no immediate commands to store all data in registers only. Even in powerful C/C ++ languages, instructions for placing data in registers are only recommended;
  • stack. For the program, the stack is placed in the common RAM. The stack is organized using stack pointers. The stack operates on the principle of LIFO (Last-In-First-Out). Such an organization is convenient when you need to allocate memory for local functions (methods) of different levels of attachments. The stack contains only pointers to objects. The objects themselves are placed in the “heap”. The stack pointer moves downward if you want to allocate memory, and upward if the memory is freed. Thus, in terms for speed, the stack is second after registers. However, the stack does not possess such flexibility as the “heap”, since the compiler needs to know the life cycle of the data placed on the stack;
  • heap. This is a general-purpose storage that resides in RAM. All objects (instances of objects) of Java are stored here. “Heap” is more flexible compared to the stack. This is because the compiler does not spend extra effort on determining the duration of existence of objects in the “heap”. In the program, an object is created using the new operator. As a result, memory is allocated in the “heap”. However, allocating memory from the “heap” takes longer than the stack. It should be noted that powerful C/C ++ languages support the explicit creation of objects on the stack as well as in the “heap”;
  • permanent repository. Programs often use data that is unchanged. These data include constants (for example, string constants). It is advisable to embed these data directly into the code of the program. Sometimes constants are placed in static memory (ROM);
  • external repository. External storage can be permanent storage devices, for example, a computer hard drive or storage data of remote computers on the network. This type of data saving allows you to save objects on storage media, and then restore them to save in RAM.

 

4. In which area of memory are objects and object references stored?

Objects are stored in the “heap”. References to objects are stored in the stack.

 

5. How in Java are created and stored arrays of objects?

Unlike C/C ++, an array in Java is necessarily initialized. Access outside the array is not possible. To create an array of objects, you need to use a record like this:

ClassName arrayObj[];

or

ClassName[] arrayObj;

where

  • ClassName – The name of a class that serves as the type for array of objects arrayObj;
  • arrayObj – the name of the array of objects.

In the above code, the array of references arrayObj to objects of class ClassName is declared. To allocate memory for an arrayObOj from an array of 10 elements of type ClassName, you would write:

arrayObj = new ClassName[10];

This can be done in another way, immediately when declaring an array:

ClassName arrayObj = new ClassName[10];

Memory is allocated only for the array of references. For objects, memory is not yet allocated. To allocate memory for any object, you need to use approximately the following code:

for (int i=0; i<arrayObj.length; i++)
{
    arrayObj[i] = new ClassName();
}

In the above example, memory is allocated for any object in the array of objects arrayObj. To determine the length of an array, use the length property, which is public for all kinds of arrays in Java.

 

6. Example of declaring and initializing an array of objects

Let the class CLine be given, the implementation of which is described in p. 2. The example demonstrates the use of an array of n objects of the CLine type. The value of n is specified programmatically (n = 10).

public class CTestLine
{
    public static void main(String[] args)
    {
        int n = 10;
        CLine[] arrayLines = new CLine[n]; // allocating memory for an array of references

        // allocating memory for each element of the array
        for (int i=0; i<arrayLines.length; i++)
        {
            // allocating memory and initializing each individual element of the array
            arrayLines[i] = new CLine(i*2, i*1.5, i+2.2, i-1);
        }

        // the use of an array, the calculation of the total length of all segments
        double sumLength = 0;
        for (int i=0; i<arrayLines.length; i++)
            sumLength+=arrayLines[i].Length();

        System.out.println("Sum = " + sumLength); // Sum = 45.45345204172149
    }
}


Related topics