Java passes by reference because if you modify the properties of the passed element then the original is modified, as can be seen if you define swap as so:

public static void swap(Point p1,Point p2){
double tempx = p1.x;
double tempy = p1.y;
p1.x = p2.x;
p1.y = p2.y;
p2.x = tempx;
p2.y = tempy;
}

If you pass by value in C++ you cannot modify the original.

Object references in Java behave like pointers in C++, so you can assign the references around as much as you like (which is what your swap does) without affecting the referenced values. The difference with C++ is that C++ references (rather than pointers) cannot be reassigned, so assignment affects the referenced object rather than changing the reference.

swap(p1,p2);

You could try this, this would not swap the pointers in the outer code, because the pointers are local copies in the swap function.

Good luck

void swap(Point &p1, Point &p2) {
    cout << "Before swap" << &p1 << endl;
    Point temp = p1;
    p1 = p2;
    p2 = temp;
    cout << "After swap" << &p1 << endl;
}

And you will notice that the references are the same, just the values are swapped.
I’m just saying that(and if you notice the comment and java example just before your last comment), even if u made new values, the passed arguments won’t change cause what is passed is the value of copied reference, not the reference itself.
I hope the idea is clear now.


public static void swap(Point p1,Point p2){
Point tmp = new Point(p1);
p1.setLocation(p2);
p2.setLocation(tmp);
}


Only magic part about C++ is that it has automatic byte-wise assignement operator. When you are doing p2=p1 in c++ you are not swapping the references, you are swapping the contents of the objects. Java just lacks operator overloading to achieve the same, nothing to do with value versus reference.
If you think it is not a difference, consider doing this with maps of million elements. According to your logic, it should be instant operation (as you are just swapping the ‘references’) – but in reality, it will copy the entire map around 3 times (not while passing to the method, but while doing = assignment).
You should compare reference to the pointer in C++ versus pointer in java – this would do pure swap.

public double getX(){return x;}
public double getY(){return y;}
 
public static void swap(Point p1,Point p2){
        double x1 = p1.getX();
        double y1 = p1.getY();
        p1 = new Point(p2.getX(),p2.getY());
        p2 = new Point(x1,y1);
 }

but even doing this won’t affect the passed arguments, which will keep having their original values.