Instantiating Objects in its own Class

This is my first question here. I am a comp. Eng. student and our teacher gave us some problems to work on.

He basically asked us to create 2 classes; one of which should contain 2 overloaded constructors and some methods regarding data encapsulation, and the other should be the main class. Our job is to "control" the first class from the main class using methods from that class. He also mentioned that we should pass values of some primitive and reference type variables between classes. I wrote some piece of code, but i get a StackOverflow Error during the class that has constructors in it is initializing. To my knowledge, you get this error when you do a recursion, but I don't get where I am doing it.

Here's the constructor class I coded (sorry for my bad naming, but since its just homework I didn't think on my names):

public class ConstructorClass {
		
	//Fields
	private String str;
	private int integer;

	
	//Constructors
	public ConstructorClass(String a)	{
		str= a;
	}
	
	public ConstructorClass(int a)	{
		integer= a;
	}
	
	//Objects
	public ConstructorClass obj1= new ConstructorClass("abc");
	public ConstructorClass obj2= new ConstructorClass(1);

	
	//Methods
	public int getInteger() {
		return this.integer;
	}
	
	public String getString() {
		
		return this.str;
	}
	
	public ConstructorClass getObj1() {
		ConstructorClass obj= new ConstructorClass("");
		obj.str= obj1.str;
		return obj;
	}
	
	public ConstructorClass getObj2() {
	
		return obj2; 
	}
}

Edit: This is the error I am getting:

> Exception in thread "main" java.lang.StackOverflowError at
> ConstructorClass.<init>(ConstructorClass.java:19)

Line 19 is :

public ConstructorClass obj1= new ConstructorClass("abc");

You get this because you've basically got the following:

public class ConstructorClass {
    //Objects
    public ConstructorClass obj1= new ConstructorClass("abc");
    public ConstructorClass obj2= new ConstructorClass(1);
}

This is a hidden form of recursion.

It is roughly equivalent to writing

public class ConstructorClass {
    public ConstructorClass(int a)  {
        public ConstructorClass obj1= new ConstructorClass("abc");
        public ConstructorClass obj2= new ConstructorClass(1);
        ...
    }

    ...
}

i.e. invoking the constructor from every constructor.

Also see the official java tutorial on initializing fields - although this is not explicitly mentioned there, what it says about "instance initializer blocks" also applies to using a final method to initialize an instance field, which is what you did here:

> The Java compiler copies initializer blocks into every constructor.

The details are specified in JLS 14, Chapter 8.3.2. Field Initialization :

> If the declarator is for an instance variable (that is, a field that is not static), then the following rules apply to its initializer:
<ul>
<li> [...]
<li> At run time, the initializer is evaluated and the assignment performed each time an instance of the class is created (§12.5).

Whenever you instantiate a ConstructorClass, you also instantiate its two members, obj1 and obj2. These members are themselves ConstructorClasses, so they each have obj1 and obj2 members which also get instantiated, and so on, until you fail with a StackOverflowError.

I'm not sure why you have these two members (i.e., I can't see a requirement for them), but if you really need to have them, you should have them in some different context (e.g., as static members, as local variables in some method, etc.)

Your getting stackoverflow error because of creating below two object at class level itself:

public ConstructorClass obj1= new ConstructorClass("abc");
public ConstructorClass obj2= new ConstructorClass(1);

Following code might work for you:

public class ConstructorClass {

    //Fields
    private String str;
    private int integer;
    //Constructors
    public ConstructorClass(String a)   {
        str= a;
    }

    public ConstructorClass(int a)  {
        integer= a;
    }


    //Methods
    public int getInteger() {
        return this.integer;
    }

    public String getString() {

        return this.str;
    }

    public ConstructorClass getObj1() {
        ConstructorClass obj= new ConstructorClass("");
        obj.str= new ConstructorClass("abc").str;
        return obj;
    }

    public ConstructorClass getObj2() {
        return new ConstructorClass(1); 
    }
    
} 

class ConstructorExample{
	public static void main(String[] args) {
    	new ConstructorClass("");
    }
}

Note:

If want to achieve encapsulation in your class make sure you have getter and setter methods for variable str and integer

Stackoverflow is coming as class is getting instantiated recursively partially due to these lines

     //Objects
      public ConstructorClass obj1= new ConstructorClass("abc");
      public ConstructorClass obj2= new ConstructorClass(1);

Remove above two lines issue will gone. You will get 1 compile issue which should be easy to solve.

What's happening internally is, Suppose from ur main class you tried to create object of this class using

    ConstructorClass cc = new ConstructorClass("string");

Now 1st constructor will be used. Then instance field will be created. Instance field creation also calls constructor. Constructor will again createnter code heree instance field. And this loops keeps on going which causes issues.

U need to learn how classes get loaded and in what order it gets created. If u tried to use instance block or static block it would add more complexity/learning for you.

Here is the fixed code, with the following changes implemented:

1. Remove the cyclic calls from ConstructorClass
   (An object's method trying to instantiate itself)

2. Introduce setInteger() and setString() methods in ConstructorClass to set the values of its private data members.

3. Instantiate the ConstructorClass objects from MainClass

4. Call the setInteger() and setString() methods of ConstructorClass from MainClass

Working code:

// File name:  MainClass.java
class ConstructorClass {
//Fields
private String str;
private int integer;
//Constructors
public ConstructorClass(String a)   {
str = a;
}
public ConstructorClass(int a)  {
integer = a;
}
//Methods
public int getInteger() {
return this.integer;
}
public String getString() {
return this.str;
}
public void setInteger(int a) {
integer = a;
}
public void setString(String a) {
str = a;
}
}
public class MainClass {
//Objects
ConstructorClass obj1;
ConstructorClass obj2;
public MainClass() {
obj1 = new ConstructorClass("abc");
obj2 = new ConstructorClass(1);
}
public ConstructorClass getObj1() {
ConstructorClass obj = new ConstructorClass("");
obj.setInteger(100);
obj.setString("Hello! How are you doing?");
return obj;
}
public ConstructorClass getObj2() {
return obj2;
}
public static void main(String[] args) {
MainClass mc = new MainClass();
System.out.println("obj1 - integer = " + mc.getObj1().getInteger());
System.out.println("obj1 - string = " + mc.getObj1().getString());
System.out.println("obj2 - integer = " + mc.getObj2().getInteger());
System.out.println("obj2 - string = " + mc.getObj2().getString());
}
}

Output:

> javac MainClass.java
> java MainClass
obj1 - integer = 100
obj1 - string = Hello! How are you doing?
obj2 - integer = 1
obj2 - string = null