好的，那么当你这样做时会发生什么。
A a1=new A();
A a2=new A();
A a3=new A();
我上传了两张关于我想象中的样子的图片。你能告诉我哪张照片是真的吗？
第一张图片：
第二张图：
我一直以为第一张是真的，但现在我真的不知道，我怀疑第二张是真的。
另外，你能向我解释一下每一方的作用吗？ 比如，“A a1”是做什么的，“new A()”是做什么的？
谢谢。
【问题讨论】：
new，它都是一个新对象，一个新引用。
new A(); 在堆的某处创建一个内存实例。您声明了多个变量并分别初始化它们。这些变量中的每一个都持有对每个内存实例的引用。
new 时，您都会创建该类的新实例，因此即使它与其他实例共享公共属性，它仍然是唯一的。
new A() 将调用类 A 的无参数构造函数并创建一个新的内存对象。
A a1=new A(); // new memory object created
A a2=new A(); // new memory object created
A a3=new A(); // new memory object created
创建了三个不同的对象，所以第二张图片是真实的。
要使第一张图片为真，引用的声明应该是这样的：
A a1=new A(); // new memory object created
A a2=a1; // a2 points to the same memory object as a1 does
A a3=a1; // a3 points to the same memory object as a1 does
这里只创建了一个对象（新的只使用了一次），但所有三个引用都指向它。
【讨论】：
不，第二张照片是真的。因为每次创建一个带有单独引用的新对象时，它都会成为一个单独的指针，指向内存中的一个单独实例。
A a1 = new A(); // a new instance of A is created in memory and can be referenced by a1.
A a2 = new A();
尽管 a1 和 a2 属于同一类型，但这并不意味着它们指向或引用内存中的同一个对象实例。
但是，如果曾经执行过a1 = a2;，那么现在，a1 和a2 都会引用或指向内存中的同一个A 对象实例。
【讨论】：
第二张图是对的。这三个语句中的每一个都在创建一个引用 (A a1 =) 和一个内存中的实际对象 (new A())。扔掉第一张照片:)
【讨论】：
第一张图片对于Strings 是正确的（由于string pooling，对已知在编译时相同的字符串进行了优化）：
String a1="s";
String a2="s";
String a3="s";
第二个是正确的：
A a1=new A();
A a2=new A();
A a3=new A();
如果你想要像String 这样的行为 - 你应该实现Flyweight pattern。
【讨论】：
第二张图是真的。每次您在构造函数之后编写 new 关键字时，都会创建类的 new 实例。每次您编写 someVariable = ... 时，右侧表达式的结果都会分配到变量，即创建新的引用。
所以，
A a1 = new A(); // creates one object and assigns reference to a1
A a2 = new A(); // creates another object and assigns reference to a2
A a3 = a2; // just create yet another reference to previously created object
a1 = new A(); // creates new object and assigns its reference to the same variable that was previously used, so the previous object is "lost" now and can be garbage collected.
【讨论】：
这是一个变量声明；
A a1;
您声明了一个名为a1 的新变量，类型为A。
a1 = new A();
您将new A() 产生的值分配给a1，这是A 类型的新对象。
作为初始化，您可以同时执行这两项操作：
A a1 = new A();
每次调用类构造函数时，您都会得到一个不同且分开的类的实例。没有实例知道其他实例，它们位于不同的内存区域。
顺便说一句，这些都是非常非常基础的编程，所以好好读书，快乐学习。
【讨论】：
每当你看到一个
ABC a1 = new ABC();
这意味着创建了一个新对象并使用a1 可以访问它。
这完全类似于去自行车店并要求他们买一辆*新自行车*。每次你说new，他们都会给你买一辆新自行车。
双方的意思：
右侧意味着您在右侧有一个新类型的对象。
左边说你想在左边保留一个类型的变量。
因此您可以拥有不同类型的双方，但您必须注意合同或条件。
条件是左侧的类型应该是右侧类型的超类，或者左侧是interface，右侧类型实现了它。
例子：
A a1 = new AB();
A a2 = new BC();
AB 和 BC 要么是 A 的子类，要么A 是一个将被实现的接口。
现在创建一个对象后，将其分配到左侧与拥有一个 baloon（新创建的对象）并附加一个字符串 (a1) 非常相似。 这样，您可以将多个字符串附加到一个气球，即，
A a1 = new A();
A a2 = a1;
a1 和 a2 指向同一个对象。
【讨论】：
浏览图片，希望对您有所帮助。
【讨论】：
第二张图是正确的。
写新的总是在堆中创建一个新的对象。
现实世界的比较
A a=new A();
上面的代码可以类似
new A() ------------------ 一个孩子的诞生
一个------那个孩子的名字（即Ram，John）
【讨论】：
第二个是正确的，因为每当创建一个对象时，它的构造函数只会被调用一次。
这里三个不同的对象是由构造函数调用创建的。所以构造函数被调用了 3 次。
而对于给定的对象，普通对象方法可以被调用任意次数，而不是构造函数。
【讨论】：