Thread: What language would describe this code so that I can research it?

I'm wondering what is happening to the creation of the class named "obj2" when another object named "obj1" inside the parenthesis. What is the technical term or the language used to describe what's happening here?

Class obj2 = new Class(obj1);

Thanks Norm.

So, if I said that obj1 is an argument that's being sent to a constructor of obj2, would that be correct?

That's hard to wrap the head around. Can you point me in the direction of any material to explain passing an obj of a class as an argument to another class?

Originally Posted by FightingIrishman

I'm wondering what is happening to the creation of the class named "obj2" when another object named "obj1" inside the parenthesis. What is the technical term or the language used to describe what's happening here?

Class obj2 = new Class(obj1);

Your wording makes me think you have not quite assimilated the difference between a class and a class object (instance). Better read up on the basics.
And anyway that code is wrong - the class "Class" does not have a public constructor.

The example you have shown is a class instance being declared and an instance of another class as an argument to the constructor.
Every class has a constructor. If the coder doesn't provide one the compiler will use a default constructor with no arguments.
A class can have more than one constructor as long each is unique in its argument declaration (the parameters).
If you provide a constructor/s all instances of that class must be declared using one of the constructors you provided.

Here is an example of passing the instance of a class to the constructor of another class.
(You can copy paste this code to this online compiler and run it.)

public class HelloWorld{
 
     public static void main(String []args){
        MyPoint topLeft = new MyPoint(10,12);                               // create a MyPoint instance
        System.out.printf("Top left: %s \n", topLeft.toString());       
        MyPoint bottomRight = new MyPoint(20, 24);                          // create another MyPoint instance
        System.out.printf("Bottom Right: %s \n", bottomRight.toString());
 
        MyRect rect = new MyRect(topLeft, bottomRight);                     // create a MyRect instance
        System.out.printf("Rectangle: %s \n", rect.toString());
     }
}
class MyPoint{
    private int _x; 
    private int _y; 
 
    public MyPoint(int x, int y){   // this is the constructor for MyPoint - it takes two int arguments 
        this._x = x;
        this._y = y;
    }
    public int getX(){
        return this._x;
    }
    public int getY(){
        return this._y;
    }
    public void setXY(int x, int y){
        this._x = x;
        this._y = y; 
    }
    public String toString(){
        return "[" + this._x + ", " + this._y + "]";
    }
 
}
class MyRect{
    private int _x1; 
    private int _x2; 
    private int _y1; 
    private int _y2; 
    public MyRect(MyPoint p1, MyPoint p2){      // this is the constructor for MyRect - it takes two MyPoint arguments
        this._x1 = p1.getX();   // the values from MyPoint arguments p1 and p2 are copied to local private vars. 
        this._y1 = p1.getY(); 
        this._x2 = p2.getX(); 
        this._y2 = p2.getY(); 
    }
    public int getX1(){
        return this._x1; 
    }
    public int getY1(){
        return this._y1; 
    }
    public int getX2(){
        return this._x2; 
    }
    public int getY2(){
        return this._y2; 
    }
    public MyPoint getTopLeft(){
        return new MyPoint(this._x1, this._y1);
    }
    public MyPoint getBottomRight(){
        return new MyPoint(this._x2, this._y2);
    }
    public String toString(){
        return "[" + this._x1 + ", " + this._y1 + "] [" + this._x2 + ", " + this._y2 + "]"; 
    }
}

This is the output:

Top left: [10, 12] 
Bottom Right: [20, 24] 
Rectangle: [10, 12] [20, 24]

In the case above the class MyPoint has one constructor that takes two int arguments.
The compiler will give you an error if you try to initialize a MyPoint variable without providing exactly 2 int arguments.

You can even declare a constructor to accept an instance of its own class as the argument. This is done to create a "Copy Constructor".

MyClass a = new MyClass() 
...do something with a...
MyClass b = new MyClass(a)

More info about it here although it gets a little overwhelming, take in what you can and come back to it when you have a better understanding of how class instances and object references work.

Originally Posted by Norm

The class name HelloWorld is not related to the code. A better name would be: TestConstructors

Yes, that is the default class name from the online compiler.