新关键字在Java中的作用

Question

I am not sure how new keyword behaves in Java. Is it for sure that every time I will use new keyword, a new Object will be created on heap?

I got this doubt when I was studying following example-

class Mixer {
  Mixer() { }
  Mixer(Mixer m) { m1 = m; }
  Mixer m1;
  public static void main(String[] args) {
    Mixer m2 = new Mixer();
    Mixer m3 = new Mixer(m2); // Does it create any new mixer object?
    m3.go();
    Mixer m4 = m3.m1;          m4.go(); 
    Mixer m5 = m2.m1;          m5.go();
  }
  void go() { System.out.print("hi "); }
}

The line Mixer m3 = new Mixer(m2); invokes a constructor which does not create any new object. So, is it that no new object was created?

Also, Which variable refers to which object in the end of program, ie till we get NullPointerExcetion for variable m5 .

Answer 1

Yes - every time you use new (as a keyword) a new object will be created. In this case:

Mixer m3 = new Mixer(m2);

The line Mixer m3 = new Mixer(m2); invokes a constructor which does not create any new object.

Your reasoning is completely incorrect. A new Mixer is being created using m2 as a parameter. Usually this indicates a copy constructor - creating a new Mixer with the same properties as the old one (but it is always a new, distinct object, and doesn't technically have to copy the properties of the object passed in at all.)

Answer 2

new always creates a new instance (so always reserves heap memory, etc.).

This should illustrate it. note that == on an instance will tell you if it is the same instance (object) or a different one. (which is why you should always use equals, unless this is what you want to do)

I've added a funny thing happening with strings. "abc" does not create a new instance, but reuses an existing one. but when you call new on the String class it does.

public class Test {
    private String value;

    public String getValue() {
        return value;
    }

    public Test() {
        value = "default";
    }
    public Test(Test t) {
        this.value = t.getValue();
    }

    public Test(String value) {
        this.value = value;
    }

    public static void main(String[] argv) {
        Test t1 = new Test();
        Test t2 = new Test(t1);

        if (t1 == t2) {
            System.out.println("t1 == t2. should not happen");
        } else {
            System.out.println("t1 is a different instance from t2");
        }

        String s1 = "test";
        String s2 = "test";

        if (s1 == s2) {
            System.out.println("s1 == s2. strings initialized with quotes don't always get a new instance.");
        } else {
            System.out.println("s1 is a different instance from s2. should not happen");
        }

        String s3 = new String("test");
        String s4 = new String(s3);

        if (s3 == s4) {
            System.out.println("s3 == s4. should not happen.");
        } else {
            System.out.println("s3 is a different instance from s4, as they were newed.");
        }

    }
}

Answer 3

From the programmer's perspective, new causes the creation of a new object.

However, the compiler may perform escape analysis to determine whether the object really needs to be created on the heap at runtime.

For your last question, your code creates two objects. One is referenced by m2, m3.m1 and m4, and the other is referenced by m3.

Answer 4

First, forget about the stack/heap distinction - that is an implementation detail of the compiler or the runtime (depending on the language in question). It might make a difference if you are doing systems programming in C or assembly, but not when you are working in garbage-collected languages and environments like Java or .NET.

And to answer your question: new actually does two things in most(?) (all?) languages that has such an operator. It first allocates memory somewhere to hold an instance of the type, and then calls a constructor to initialize an instance of the type in that newly allocated memory. Constructor chaining then may cause other constructors to be called (either on the same type, base classes/superclasses of the type, or anything that type's constructor needs to do its work).

As pointed out by @berry120 , a constructor taking a parameter of the same type as the type that the constructor is for usually indicates a copy constructor. Another way of achieving the same result is to have and make an explicit call to something like a clone() method which returns a copy of the object it is called on.

Answer 5

它确实创建了一个新对象，并且它的构造函数传递了对您已经创建的另一个对象m2的引用。