创建新的Java Object实例时，在匿名代码块中初始化变量是否兼容？

Question

Just like this :

class Car {
    int carId;
    String brand;
    public Car(int carId, String brand) {
        this.carId = carId;
        this.brand = brand;
    }
    // getter and setter
    public String toString() {
        return " car :" + "id - " + carId + ", brand - " + brand;
    }
}
public class User {
    String name;
    Car car;
    // getter and setter
    public String toString() {
        return name + " has a " + car.toString();
    }
    public static void main(String[] args) {
        // 1st
        User u = new User() {
            { // my problem is here : is this block OK?
                setName("Tom");
                setCar(new Car(1, "Volvo"));
            }
        };
        // 2nd or this
        // Car car = new Car(1, "Volvo");
        // User u = new User();
        // u.setName("Tom");
        // u.setCar(car);

        System.out.println(u);
    }
}

I know this works fine in C#, and it seems that it also works in Java. However, it's really not clear that if that's right or a good code style... Really thanks for your help!

Answer 1

In Java, you are creating an anonymous inner class here.

So that object is not a User , but a subclass of User .

It is pretty uncommon, and most people consider it bad style. Some people use it "by accident" (not knowing what they are doing), a few suggest to follow this pattern. But in general, it will surprise most of your readers, and a base rule in programming is to avoid doing that. You follow conventions, even when they are informal and not written down.

And for the record: depending on how you implemented your own equals() method, this approach of creating sub class instances on the fly might even lead to bizarre bugs.

Therefore: simply don't do it.

Answer 2

In c# there is a construct called Object Initializer and it looks syntactically similar to what you tried to do here.

However, this does not exist in Java .

What you proposed is a combination of an Anonymous Class Declaration and an Instance Initializer that is sometimes refererred to as "Double Brace Initialization" and comes with several serious caveats - see this question for even more reasons to avoid this in addition to the valid points GhostCat mentioned in his answer .