好的，那么当你这样做时会发生什么。
A a1=new A();
A a2=new A();
A a3=new A();
我上传了两张我想象中的照片。你能告诉我哪张照片是真的吗？
第一张图：
第二张图：
一直以为第一张是真的，现在不知道了，怀疑第二张是真的。
另外，你能向我解释一下每一方的作用吗？比如，“A a1”做什么，“new A()”做什么？
谢谢。
问问题
8036 次
10 回答
12
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
这里只创建了一个对象（只使用了一次新对象），但所有三个引用都指向它。
于 2013-10-06T16:40:18.803 回答
2
浏览图片，希望对您有所帮助。
于 2013-10-06T16:52:33.080 回答
2
不，第二张图是真的。因为每次创建一个带有单独引用的新对象时，它都会成为指向内存中单独实例的单独指针。
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内存中的同一个对象实例。
于 2013-10-06T16:42:22.090 回答
2
这是一个变量声明；
A a1;
您声明了一个名为a1type的新变量A。
a1 = new A();
您分配给a1由 产生的值new A()，这是一个新的类型对象A。
作为初始化，你可以同时做这两件事：
A a1 = new A();
每次调用类构造函数时，都会得到一个不同且分离的类实例。没有实例知道其他实例，它们位于不同的内存区域。
顺便说一句，这些都是非常非常基础的编程，所以请好好阅读并愉快地学习。
于 2013-10-06T16:43:43.193 回答
1
第一张图片是正确的Strings（由于字符串池，对已知在编译时相同的字符串进行了优化）：
String a1="s";
String a2="s";
String a3="s";
第二个适用于：
A a1=new A();
A a2=new A();
A a3=new A();
如果你想要像Stringhas 这样的行为 - 你应该实现Flyweightpattern。
于 2013-10-06T16:42:46.090 回答
1
第二张图是真的。每次您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.
于 2013-10-06T16:43:35.147 回答
1
每当你看到一个
ABC a1 = new ABC();
这意味着创建了一个新对象并使用a1您可以访问它。
这与去自行车店要求他们买一辆*新自行车*完全相似。每次你说new他们会给你买一辆新自行车。
双方的意思：
右侧意味着您在右侧有一个新类型的对象。
左边说你想在左边保留一个类型的变量。
因此，您可以拥有不同类型的双方，但您必须注意合同或条件。条件是左侧的类型应该是右侧类型的超类，或者左侧是an interface，右侧类型实现它。
例子：
A a1 = new AB();
A a2 = new BC();
并且两者都是子类，AB或者是将要实现的接口。BCAA
现在，当您将对象分配到左侧时创建对象后，与拥有一个气球（新创建的对象）并在其上附加一个字符串（a1）完全相似。这样，您可以将多个字符串附加到一个气球上，即，
A a1 = new A();
A a2 = a1;
咬住a1并a2指向同一个对象。
于 2013-10-06T16:46:22.937 回答
1
第二张图是对的。
写新总是在堆中创建一个新对象。
在现实世界中比较
一个=新的A（）；
上面的代码可以类似于
new A() ------------------ 一个孩子的诞生
A a ------------------ 那个孩子的名字（即 Ram，John）
于 2013-10-06T20:14:10.257 回答
0
第二张图是对的。这三个语句中的每一个都在创建一个引用 ( A a1 =) 和一个内存中的实际对象 ( new A())。扔掉第一张照片:)
于 2013-10-06T16:42:41.713 回答
0
第二个是正确的，因为每当创建一个对象时，它的构造函数只被调用一次。
这里三个不同的对象是由构造函数调用创建的。所以构造函数被调用了 3 次。
而普通对象方法可以为给定对象调用任意次数，而不是构造函数。
于 2015-08-15T14:47:27.247 回答