Huh?
Your Obj_1 and Obj_2 are referencing the same object.  There is no
copying involved whatsoever.  Furthermore, your definition of shallow
vs. deep copy is far different from mine..    There are no copy
constructors in java, you can use the Prototype design pattern.

Which is actually much more like

MyClass *Obj_1 = new MyClass(args);
MyClass *Obj_2 = Obj_1;

Which involves no copying of the actual object living somewhere in the
heap at all.

Java is a funny beast. It has no pointers, except that everything that is
not a primitive is one. A java reference is actually a "polite pointer"
which disallows a lot of the unsafe operations (such as reinterpret_cast,
or pointer arithmetics).

HTH
Stefan

No, it is not shallow copying.  It is in fact, like you said, two
references to *the same* object.  Shallow copying in C++ means getting
two references to *two different* (but identical) objects.

The Java way is more like getting a C++ reference to the same object,
which is somewhat unusual, but not "usually unacceptable".  Compare
this:

<java>
MyClass obj1 = new MyClass(args); // reference (pointer) to new object
MyClass obj2 = obj1;  // reference to same object (no copying)
</java>

<C++>
MyClass obj1(args);   // original object (not a pointer or reference!)
MyClass &obj2 = obj1; // reference to same object (no copying)
MyClass obj3 = obj1;  // new but identical object (shallow copy)
</C++>

<C++>
MyClass *obj1(args);  // pointer (reference) to new object
MyClass *obj2 = obj1; // pointer to the same object (no copying)
</C++>

As you can see, java is much more like the second C++ example, not the
first.
In C++ obj3 is created using the default copy constructor, and hence is a
shallow copy of obj1.  In Java there is no default copy constructor - if
you want to copy an object you need to define your own copy constructor,
which could be a shallow or deep copy, depending on how you code it.  The
more common way is to use clone though - but here too shallow or deep
copy depends on your own implementation.

<java>
MyClass obj3 = new MyClass(obj1); // copy constructor must be defined
MyClass obj4 = obj1.clone();  // clone must be defined
</java>

-- Beware the False Authority Syndrome

By the way, in C++ it's more like:

MyClass Obj_1(args);
MyClass Obj_2 = Obj_1;

Regards

The above is incorrect it should either be:
MyClass * Obj_1 = new MyClass(args);
MyClass * Obj_2 = Obj_1;
Here only the pointer value is copied, both pointers will then point to
the same object.
or
MyClass Obj_1 = MyClass(args);
MyClass Obj_2 = Obj_1;
Here either the default memberwise shallow copy will be performed or
maybe a deep copy if the default copy constructor has been overridden.

If MyClass has a pointer to allocated data and the class performs the
default memberwise shallow copy then Obj_1 and Obj_2 will both have
pointers pointing to the same data. This is the basic issue regarding
shallow copying of objects (where this sharing of a resource is not
desired or not intended).

In the above only the reference is copied and not the underlying
object, however, this doesn't necessarily create any issues as the
garbage collector is able to track when all references to the object
no-longer exist and know when the object's memory can be reclaimed. The
problem occurs when a copy results in more than one object sharing a
resource and both objects acting as though they are the sole owner of
that resource, i.e. they have not been designed to share the resource
or maybe the sharing was unintentional...

The issue mainly crops up with value semantics (and particularly where
objects are passed-by-value) because the default copy-semantics only
performs a shallow copy, for example...
MyClass Foo()
{
  MyClass Obj_1 = MyClass(args);
  return Obj_1;
}
Imagine MyClass has a dynamic buffer and performs a shallow copy to the
object that will be returned from function foo. Obj_1 will then be
destroyed and, assuming the destructor does what it should and
deallocates the buffer, the pointer in the returned object will have
become invalidated since it was pointing to the dynamic buffer which
has now been deallocated.

If you change foo to use reference rather than value semantics, and
therefore behave more like you would expect in Java, the issue no
longer exists as no copying of the object will take place :-

std::auto_ptr<MyClass> Foo()
{
  std::auto_ptr<MyClass> Obj_1 = new MyClass(args);
  return Obj_1;
}