问答首页 → Java企业应用
0 0

new 一个对象？5

public class Test_4 {
public void test() {
Test_4 t1 = new Test_4();
Test_4 t2 = new Test_4();
if (t1.equals(t2)) {
System.out.println("t1.qual（t2）");
}
if (t2 == t1) {
System.out.println("t1!=t2");
}
else{
System.out.println("t1!=t2 and !t1.equals(t2)");
}
}
打印else
String s=new String ();
String ss=new String ();
if(s.equals(ss)){
System.out.println("s.equal(ss)");
}else{
System.out.println("s!=ss");
}
这是为什么啊? 
new 
2012年3月18日 22:02

7个答案 按时间排序 按投票排序

0 0

采纳的答案

简单说，由于Test_4没有重写equals方法，则调用的是Object中的equals方法，以下是jdk源码中Object的equals方法：
    public boolean equals(Object obj) {
return (this == obj);
    }
它通过"=="比较两个对象，也就是比较两个对象的应用地址。   

再说String，它已经重写了equals方法，因此调用的是自身重写后的方法，源码如下：
    public boolean equals(Object anObject) {
if (this == anObject) {
    return true;
}
if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = count;
    if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
    if (v1[i++] != v2[j++])
return false;
}
return true;
    }
}
return false;
    }
看源码知道它比较的是两个字符串的值是否一样。

另外，重写了equals方法就必须重写hashcode方法，你可以在Test_4中重写equals方法，实现自己的比较规则，就如String重写equals方法一样，只不过是String是jdk帮我们写好了。

2012年3月19日 09:41
0 0

对象类型比较用==是比较地址，即同一指向。用equals比的是对象的值。要么用==，要么重写equals方法。

2012年3月19日 11:11
0 0 

　equals方法的重要性毋须多言,只要你想比较两个对象是不是同一对象,你就应该实现equals方法,让对象用你认为相等的条件来进行比较. 

　　下面的内容只是API的规范,没有什么太高深的意义,但我之所以最先把它列在这儿,是因为这些规范在事实中并不是真正能保证得到实现. 

　　1.对于任何引用类型, o.equals(o) == true成立. 

　　2.如果 o.equals(o1) == true 成立,那么o1.equals(o)==true也一定要成立. 

　　3.如果 o.equals(o1) == true 成立且 o.equals(o2) == true 成立,那么 

　　o1.equals(o2) == true 也成立. 

　　4.如果第一次调用o.equals(o1) == true成立，在o和o1没有改变的情况下以后的任何次调用都成立. 

　　5.o.equals(null) == true 任何时间都不成立. 

　　以上几条规则并不是最完整的表述,详细的请参见API文档.对于Object类,它提供了一个最最严密的实现,那就是只有是同一对象时,equals方法才返回true,也就是人们常说的引用比较而不是值比较.这个实现严密得已经没有什么实际的意义, 所以在具体子类(相对于Object来说)中,如果我们要进行对象的值比较,就必须实现自己的equals方法.先来看一下以下这段程序:
 
　　public boolean equals(Object obj) 

　　{ 

　　if (obj == null) return false; 

　　if (!(obj instanceof FieldPosition)) 

　　return false; 

　　FieldPosition other = (FieldPosition) obj; 

　　if (attribute == null) { 

　　if (other.attribute != null) { 

　　return false; 

　　} 

　　} 

　　else if (!attribute.equals(other.attribute)) { 

　　return false; 

　　} 

　　return (beginIndex == other.beginIndex 

　　& endIndex == other.endIndex 

　　&& field == other.field); 

　　} 

　　这是JDK中java.text.FieldPosition的标准实现,似乎没有什么可说的. 我信相大多数或绝大多数程序员认为,这是正确的合法的equals实现.毕竟它是JDK的API实现啊. 还是让我们以事实来说话吧:
 
　　package debug 

　　;import java.text.*; 

　　public class Test { 

　　public static void main(String[] args) { 

　　FieldPosition fp = new FieldPosition(10); 

　　FieldPosition fp1 = new MyTest(10); 

　　System.out.println(fp.equals(fp1)); 

　　System.out.println(fp1.equals(fp)); 

　　} 

　　} 

　　class MyTest extends FieldPosition{ 

　　int x = 10; 

　　public MyTest(int x){ 

　　super(x); 

　　this.x = x; 

　　} 

　　public boolean equals(Object o){ 

　　if(o==null) return false; 

　　if(!(o instanceof MyTest )) return false; 

　　return ((MyTest)o).x == this.x; 

　　} 

　　} 

　　运行一下看看会打印出什么: 

　　System.out.println(fp.equals(fp1));打印true 

　　System.out.println(fp1.equals(fp));打印flase 

　　两个对象,出现了不对称的equals算法.问题出在哪里(脑筋急转弯：当然出在JDK实现的BUG)?我相信有太多的程序员(除了那些根本不知道实现equals方法的程序员外)在实现equals方法时都用过instanceof运行符来进行短路优化的，实事求是地说很长一段时间我也这么用过。
 
　　太多的教程，文档都给了我们这样的误导。而有些稍有了解的程序员可能知道这样的优化可能有些不对但找不出问题的关键。另外一种极端是知道这个技术缺陷的骨灰级专家就提议不要这样应用。我们知道，"通常"要对两个对象进行比较，那么它们"应该"是同一类型。所以首先利用instanceof运算符进行短路优化，如果被比较的对象不和当前对象是同一类型则不用比较返回false。
 
　　但事实上，"子类是父类的一个实例"，所以如果子类 o instanceof 父类，始终返回true,这时肯定不会发生短路优化，下面的比较有可能出现多种情况，一种是不能造型成父类而抛出异常，另一种是父类的private 成员没有被子类继承而不能进行比较，还有就是形成上面这种不对称比较。可能会出现太多的情况。
 
　　那么，是不是就不能用 instanceof运算符来进行优化？答案是否定的，JDK中仍然有很多实现是正确的，如果一个class是final的，明知它不可能有子类，为什么不用 instanceof来优化呢？为了维护SUN的开发小组的声誉，我不说明哪个类中，但有一个小组成员在用这个方法优化时在后加加上了加上了这样的注释：
 
　　if (this == obj) // quick check 

　　return true; 

　　if (!(obj instanceof XXXXClass)) // (1) same object? 

　　return false; 

　　可能是有些疑问，但不知道如何做（不知道为什么没有打电话给我......）那么对于非final类，如何进行类型的quick check呢？ 

　　if(obj.getClass() != XXXClass.class) return false; 

　　用被比较对象的class对象和当前对象的class比较，看起来是没有问题，但是，如果这个类的子类没有重新实现equals方法，那么子类在比较的时候，obj.getClass() 肯定不等于XXXCalss.class, 也就是子类的equals将无效，所以
 
　　if(obj.getClass() != this.getClass()) return false; 

　　才是正确的比较。另外一个quick check是if(this==obj) return true; 

　　是否equals方法比较的两个对象一定是要同一类型？上面我用了"通常"，这也是绝大多数程序员的愿望，但是有些特殊的情况，我们可以进行不同类型的比较，这并不违反规范。但这种特殊情况是非常罕见的，一个不恰当的例子是，Integer类的equals可以和Sort做比较，比较它们的value是不是同一数学值。（事实上JDK的API中并没有这样做，所以我才说是不恰当的例子）在完成quick check以后，我们就要真正实现你认为的“相等”。对于如果实现对象相等，没有太高的要求，比如你自己实现的“人”类，你可以认为只要name相同即认为它们是相等的，其它的sex, ago都可以不考虑。这是不完全实现，但是如果是完全实现，即要求所有的属性都是相同的，那么如何实现equals方法？
 
　　class Human{ 

　　private String name; 

　　private int ago; 

　　private String sex; 

　　.................... 

　　public boolean equals(Object obj){ 

　　quick check....... 

　　Human other = (Human)ojb; 

　　return this.name.equals(other.name) && this.ago == ohter.ago && this.sex.equals(other.sex);
 
　　} 

　　} 

　　这是一个完全实现，但是，有时equals实现是在父类中实现，而要求被子类继承后equals能正确的工 

　　作，这时你并不事实知道子类到底扩展了哪些属性，所以用上面的方法无法使equals得到完全实现。 

　　一个好的方法是利用反射来对equals进行完全实现： 

　　public boolean equals(Object obj){ 

　　quick check....... 

　　Class c = this.getClass(); 

　　Filed[] fds = c.getDeclaredFields(); 

　　for(Filed f:fds){ 

　　if(!f.get(this).equals(f.get(obj))) 

　　return false; 

　　} 

　　return true; 

　　} 

　　为了说明的方便，上明的实现省略了异常，这样的实现放在父类中，可以保证你的子类的equals可以按你的愿望正确地工作。关于equals方法的最后一点是：如果你要是自己重写（正确说应该是履盖）了equals方法，那同时就一定要重写hashCode().这是规范，否则.............
 
　　我们还是看一下这个例子： 

　　public final class PhoneNumber { 

　　private final int areaCode; 

　　private final int exchange; 

　　private final int extension; 

　　public PhoneNumber(int areaCode, int exchange, int extension) { 

　　rangeCheck(areaCode, 999, "area code"); 

　　rangeCheck(exchange, 99999999, "exchange"); 

　　rangeCheck(extension, 9999, "extension"); 

　　this.areaCode = areaCode; 

　　this.exchange = exchange; 

　　this.extension = extension; 

　　} 

　　private static void rangeCheck(int arg, int max, String name) { 

　　if(arg < 0 　　 arg > max) 

　　throw new IllegalArgumentException(name + ": " + arg); 

　　} 

　　public boolean equals(Object o) { 

　　if(o == this) 

　　return true; 

　　if(!(o instanceof PhoneNumber)) 

　　return false; 

　　PhoneNumber pn = (PhoneNumber)o; 

　　return pn.extension == extension && pn.exchange == exchange && pn.areaCode == areaCode;
 
　　} 

　　} 

　　注意这个类是final的，所以这个equals实现没有什么问题。我们来测试一下: 

　　public static void main(String[] args) { 

　　Map hm = new HashMap(); 

　　PhoneNumber pn = new PhoneNumber(123, 38942, 230); 

　　hm.put(pn, "I love you"); 

　　PhoneNumber pn1 = new PhoneNumber(123, 38942, 230); 

　　System.out.println(pn); 

　　System.out.println("pn.equals(pn1) is " + pn.equals(pn1)); 

　　System.out.println(hm.get(pn1)); 

　　System.out.println(hm.get(pn)); 

　　} 

　　既然pn.equals(pn1),那么我put(pn,"I love you")后，get(pn1)为什么是null呢？ 

　　答案是因为它们的hashCode不一样，而hashMap就是以hashCode为主键的。所以规范要求，如果两个对象进行equals比较时如果返回true,那么它们的hashcode要求返回相等的值

2012年3月18日 22:40
0 0

原因是这样的，对于创建的普通类，如您上面创建的Test_4类，如果没有重写equals方法的话，会默认使用Object类的equals方法，Object的equals的方法如下
public boolean equals(Object obj) {
return (this == obj);
    }
即比较两个对象的堆内存地址是否一致。
因此上面第一个程序创建了两个Test_4类，就会在堆中创建两块内存，即有两个不同的地址。因此会输出else。
至于String类的equals相等是由于String类重写了Object类的equals的方法。
public boolean equals(Object anObject) {
if (this == anObject) {
    return true;
}
if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = count;
    if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
    if (v1[i++] != v2[j++])
return false;
}
return true;
    }
}
return false;
    }
即会先去比较两个对象的地址是否相等，若是不相等会去比较两个字符串的每个字符是否相等，所以上面的创建了两个String对象，虽然地址不相等，但是他们内部的字符串值是相等的(实际是将字符串存放到char[]中).都是字符。

2012年3月18日 22:29
0 0

Java语言深入:深入研究Java equals方法

http://www.enet.com.cn/article/2007/1114/A20071114910902.shtml

2012年3月18日 22:13
0 0

 

引用
equals方法的重要性毋须多言,只要你想比较两个对象是不是同一对象,你就应该实现equals方法,让对象用你认为相等的条件来进行比较.

　　下面的内容只是API的规范,没有什么太高深的意义,但我之所以最先把它列在这儿,是因为这些规范在事实中并不是真正能保证得到实现.

　　1.对于任何引用类型, o.equals(o) == true成立.

　　2.如果 o.equals(o1) == true 成立,那么o1.equals(o)==true也一定要成立.

　　3.如果 o.equals(o1) == true 成立且 o.equals(o2) == true 成立,那么

　　o1.equals(o2) == true 也成立.

　　4.如果第一次调用o.equals(o1) == true成立，在o和o1没有改变的情况下以后的任何次调用都成立.

　　5.o.equals(null) == true 任何时间都不成立.

　　以上几条规则并不是最完整的表述,详细的请参见API文档.对于Object类,它提供了一个最最严密的实现,那就是只有是同一对象时,equals方法才返回true,也就是人们常说的引用比较而不是值比较.这个实现严密得已经没有什么实际的意义, 所以在具体子类(相对于Object来说)中,如果我们要进行对象的值比较,就必须实现自己的equals方法.先来看一下以下这段程序:

　　public boolean equals(Object obj)

　　{

　　if (obj == null) return false;

　　if (!(obj instanceof FieldPosition))

　　return false;

　　FieldPosition other = (FieldPosition) obj;

　　if (attribute == null) {

　　if (other.attribute != null) {

　　return false;

　　}

　　}

　　else if (!attribute.equals(other.attribute)) {

　　return false;

　　}

　　return (beginIndex == other.beginIndex

　　& endIndex == other.endIndex

　　&& field == other.field);

　　}

　　这是JDK中java.text.FieldPosition的标准实现,似乎没有什么可说的. 我信相大多数或绝大多数程序员认为,这是正确的合法的equals实现.毕竟它是JDK的API实现啊. 还是让我们以事实来说话吧:

　　package debug

　　;import java.text.*;

　　public class Test {

　　public static void main(String[] args) {

　　FieldPosition fp = new FieldPosition(10);

　　FieldPosition fp1 = new MyTest(10);

　　System.out.println(fp.equals(fp1));

　　System.out.println(fp1.equals(fp));

　　}

　　}

　　class MyTest extends FieldPosition{

　　int x = 10;

　　public MyTest(int x){

　　super(x);

　　this.x = x;

　　}

　　public boolean equals(Object o){

　　if(o==null) return false;

　　if(!(o instanceof MyTest )) return false;

　　return ((MyTest)o).x == this.x;

　　}

　　}

　　运行一下看看会打印出什么:

　　System.out.println(fp.equals(fp1));打印true

　　System.out.println(fp1.equals(fp));打印flase

　　两个对象,出现了不对称的equals算法.问题出在哪里(脑筋急转弯：当然出在JDK实现的BUG)?我相信有太多的程序员(除了那些根本不知道实现equals方法的程序员外)在实现equals方法时都用过instanceof运行符来进行短路优化的，实事求是地说很长一段时间我也这么用过。

　　太多的教程，文档都给了我们这样的误导。而有些稍有了解的程序员可能知道这样的优化可能有些不对但找不出问题的关键。另外一种极端是知道这个技术缺陷的骨灰级专家就提议不要这样应用。我们知道，"通常"要对两个对象进行比较，那么它们"应该"是同一类型。所以首先利用instanceof运算符进行短路优化，如果被比较的对象不和当前对象是同一类型则不用比较返回false。

　　但事实上，"子类是父类的一个实例"，所以如果子类 o instanceof 父类，始终返回true,这时肯定不会发生短路优化，下面的比较有可能出现多种情况，一种是不能造型成父类而抛出异常，另一种是父类的private 成员没有被子类继承而不能进行比较，还有就是形成上面这种不对称比较。可能会出现太多的情况。

　　那么，是不是就不能用 instanceof运算符来进行优化？答案是否定的，JDK中仍然有很多实现是正确的，如果一个class是final的，明知它不可能有子类，为什么不用 instanceof来优化呢？为了维护SUN的开发小组的声誉，我不说明哪个类中，但有一个小组成员在用这个方法优化时在后加加上了加上了这样的注释：

　　if (this == obj) // quick check

　　return true;

　　if (!(obj instanceof XXXXClass)) // (1) same object?

　　return false;

　　可能是有些疑问，但不知道如何做（不知道为什么没有打电话给我......）那么对于非final类，如何进行类型的quick check呢？

　　if(obj.getClass() != XXXClass.class) return false;

　　用被比较对象的class对象和当前对象的class比较，看起来是没有问题，但是，如果这个类的子类没有重新实现equals方法，那么子类在比较的时候，obj.getClass() 肯定不等于XXXCalss.class, 也就是子类的equals将无效，所以

　　if(obj.getClass() != this.getClass()) return false;

　　才是正确的比较。另外一个quick check是if(this==obj) return true;

　　是否equals方法比较的两个对象一定是要同一类型？上面我用了"通常"，这也是绝大多数程序员的愿望，但是有些特殊的情况，我们可以进行不同类型的比较，这并不违反规范。但这种特殊情况是非常罕见的，一个不恰当的例子是，Integer类的equals可以和Sort做比较，比较它们的value是不是同一数学值。（事实上JDK的API中并没有这样做，所以我才说是不恰当的例子）在完成quick check以后，我们就要真正实现你认为的“相等”。对于如果实现对象相等，没有太高的要求，比如你自己实现的“人”类，你可以认为只要name相同即认为它们是相等的，其它的sex, ago都可以不考虑。这是不完全实现，但是如果是完全实现，即要求所有的属性都是相同的，那么如何实现equals方法？

　　class Human{

　　private String name;

　　private int ago;

　　private String sex;

　　....................

　　public boolean equals(Object obj){

　　quick check.......

　　Human other = (Human)ojb;

　　return this.name.equals(other.name) && this.ago == ohter.ago && this.sex.equals(other.sex);

　　}

　　}

　　这是一个完全实现，但是，有时equals实现是在父类中实现，而要求被子类继承后equals能正确的工

　　作，这时你并不事实知道子类到底扩展了哪些属性，所以用上面的方法无法使equals得到完全实现。

　　一个好的方法是利用反射来对equals进行完全实现：

　　public boolean equals(Object obj){

　　quick check.......

　　Class c = this.getClass();

　　Filed[] fds = c.getDeclaredFields();

　　for(Filed f:fds){

　　if(!f.get(this).equals(f.get(obj)))

　　return false;

　　}

　　return true;

　　}

　　为了说明的方便，上明的实现省略了异常，这样的实现放在父类中，可以保证你的子类的equals可以按你的愿望正确地工作。关于equals方法的最后一点是：如果你要是自己重写（正确说应该是履盖）了equals方法，那同时就一定要重写hashCode().这是规范，否则.............

　　我们还是看一下这个例子：

　　public final class PhoneNumber {

　　private final int areaCode;

　　private final int exchange;

　　private final int extension;

　　public PhoneNumber(int areaCode, int exchange, int extension) {

　　rangeCheck(areaCode, 999, "area code");

　　rangeCheck(exchange, 99999999, "exchange");

　　rangeCheck(extension, 9999, "extension");

　　this.areaCode = areaCode;

　　this.exchange = exchange;

　　this.extension = extension;

　　}

　　private static void rangeCheck(int arg, int max, String name) {

　　if(arg < 0 　　 arg > max)

　　throw new IllegalArgumentException(name + ": " + arg);

　　}

　　public boolean equals(Object o) {

　　if(o == this)

　　return true;

　　if(!(o instanceof PhoneNumber))

　　return false;

　　PhoneNumber pn = (PhoneNumber)o;

　　return pn.extension == extension && pn.exchange == exchange && pn.areaCode == areaCode;

　　}

　　}

　　注意这个类是final的，所以这个equals实现没有什么问题。我们来测试一下:

　　public static void main(String[] args) {

　　Map hm = new HashMap();

　　PhoneNumber pn = new PhoneNumber(123, 38942, 230);

　　hm.put(pn, "I love you");

　　PhoneNumber pn1 = new PhoneNumber(123, 38942, 230);

　　System.out.println(pn);

　　System.out.println("pn.equals(pn1) is " + pn.equals(pn1));

　　System.out.println(hm.get(pn1));

　　System.out.println(hm.get(pn));

　　}

　　既然pn.equals(pn1),那么我put(pn,"I love you")后，get(pn1)为什么是null呢？

　　答案是因为它们的hashCode不一样，而hashMap就是以hashCode为主键的。所以规范要求，如果两个对象进行equals比较时如果返回true,那么它们的hashcode要求返回相等的值。

2012年3月18日 22:12
0 0

你要自己覆盖equals方法，String类就要自己的equals方法

2012年3月18日 22:07

相关推荐

    js中new一个对象的过程

    在JavaScript中，使用new关键字创建一个新对象的过程是一个涉及多个步骤的机制，其目的是构造一个新的实例对象。这个过程涉及几个关键的内部操作，理解它们有助于更好地掌握JavaScript的原型继承和面向对象编程。 1...

    用new创建对象和直接定义的区别

    `new`关键字在Java、C++、C#等面向对象语言中广泛使用，它用于在堆内存中动态分配空间并初始化一个新对象。当我们使用`new`关键字时，通常会伴随着一个类的构造函数调用，以便对新对象进行初始化。 ```java // Java...

    String s = new String(” a “) 到底产生几个对象？

    上图红色的这3个箭头，对于通过new产生一个字符串（”宜春”）时，会先去常量池中查找是否已经有了”宜春”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”宜春”对象的拷贝对象。...

    new一个对象小程序

    一个小程序，，属于程序员的小程序，请让你心仪的女生点开，，会发生意想不到的效果，程序员独特的表达方式

    javascript new一个对象的实质

    当我们使用JavaScript的new关键字来创建一个对象的时候，实际上是在进行一个特殊的函数调用，这个过程的实质包括以下几个关键步骤： 1. 创建新对象：当我们使用new操作符和构造函数时，JavaScript首先会创建一个新...

    C语言也能面向对象（二）——new和delete

    例如，如果你有一个类`Person`，你可以使用`new`创建一个`Person`对象： ```cpp Person* p = new Person(); ``` 这段代码会调用`Person`的默认构造函数来初始化新分配的对象。同时，`new`还会自动处理对齐问题，...

    java new一个对象的过程实例解析

    "Java new一个对象的过程实例解析" Java新建对象的过程是一个复杂的过程，涉及到类加载、链接、初始化和对象创建等多个阶段。在这篇文章中，我们将详细介绍Java新建对象的过程，并通过示例代码对每个阶段进行了详细...

    C++程序的生与死,C++中的四种对象（全局对象、局部对象、静态（static）对象、以new方式产生出来的局部对象），以及在C++中有四种方法可以产生一个对象

    对象根据其存储位置的不同，可以分为四类：全局对象、局部对象、静态（static）对象、以`new`方式产生的局部对象。每类对象都有特定的生命周期，即它们的创建时机与销毁时机有所不同。 #### 全局对象 全局对象是指...

    new关键字和newInstance() 的区分

    首先，new 关键字是 Java 的一个保留字，用于创建一个新的对象。例如，`A a = new A();` 就是使用 new 关键字创建了一个 A 类的对象。new 关键字的作用是创建一个新的对象，并且将其初始化。 而 newInstance() 方法...

    java中对象和对象引用的区别!

    在这段代码中，`A`表示一个类名，`a1`是一个引用变量，`new A()`则创建了一个新的`A`类的对象。这里的关键在于`a1`并不是对象本身，而是指向这个新创建的对象的一个引用。因此，`a1`保存的是该对象在内存中的地址，...

    java中用数组为一个类定义多个对象

    例如，如果有一个名为`Person`的类，我们可能需要创建多个`Person`对象来代表不同的个体。在这种情况下，可以使用数组来存储这些对象。下面我们将详细探讨如何在Java中用数组为一个类定义多个对象，并进行实例化。 ...

    C++用new创建对象和不用new创建对象的区别解析

    另一方面，堆内存是动态分配的，程序员通过`new`操作符来申请，`delete`操作符来释放。堆的大小通常远大于栈，但分配和释放的开销较大，且容易引发内存泄漏。 1. **内存分配的大小和控制**： - **栈分配**：在栈上...

    Malloc和new区别

    - **New** 建立的是一个对象，可以直接通过对象的方式来访问其成员变量和方法，而不仅仅是通过指针访问内存。 - **Malloc** 分配的只是一块内存区域，通常需要通过指针来访问这块内存，并且可以在内存中移动指针。 ...

    new操作符（new operator）和operator new的区别

    总的来说，`new`操作符是一个完整的对象创建过程，而`operator new`仅负责内存分配。放置`new`则提供了一种灵活的方式，允许在已有内存上构造对象，而无需额外分配内存。理解这些概念对于编写高效且内存管理得当的...

    new类的三种不同的用法

    `new`关键字最基本的作用就是实例化一个类的对象。当你声明一个类后，你可以通过`new`来创建该类的一个实例。例如： ```java class Person { String name; int age; } Person person = new Person(); ``` ...

    new一个Object对象占用多少内存？-附件资源

    new一个Object对象占用多少内存？-附件资源

    java 对象克隆

    在Java编程语言中，对象克隆是一种创建一个与原对象具有相同数据的新对象的过程。对象克隆主要用于复制或备份对象，以便在不干扰原始对象的情况下对其进行修改或操作。本篇文章将详细探讨Java中的对象克隆及其实现...

    Cpp 对象模型探索new 实现原理代码和图.rar

    总结来说，`new`操作符是C++中动态内存管理的核心，涉及内存分配、对象构造和异常处理等多个环节。通过分析提供的资源，我们可以更深入地理解这个过程，包括其在底层如何工作，以及如何通过自定义实现来扩展其功能。...

Magicbox
Global site tag (gtag.js) - Google Analytics