Nested Subclass Instantiation Declaration Java

Question

Coming from a JavaScript background, I find the following code a bit too robust, containing multiple statements; and am wondering how I can simply the code, and do everything in a single statement.

Student is the superclass and Friend and Schedule are the subclasses aggregated into a superclass ArrayList public member (these are not nested classes). Here is my current code:

public static void main(String[] args) {

  // Subclass1 instantiation and declaration
  Friend friend_of_andy_1 = new Friend(1002, "Bob");
  ArrayList<Friend> andys_friends = new ArrayList<>();
  andys_friends.add(friend_of_andy_1);    // superclass member

  // Subclass1 instantiation and declaration
  Schedule schedule_of_andy_1 = new Schedule(1, "Yoga practice");
  ArrayList<Schedule> andys_schedule = new ArrayList<>();
  andys_schedule.add(schedule_of_andy_1); // superclass member

  // Superclass instantiation declaration with subclass objects in constructor argument
  Student student_andy = new Student(1001, "Andy", andys_friends, andys_schedule);

}

I'm wondering if I can do something like this instead, where I declare/instantiate the superclass and subclasses in a single statement; is this possible?

public static void main(String[] args) {

  Student student_andy = new Student(
    1001,
    "Andy",
    // instantiation of subclass
    ArrayList<Friend>[
      Friend(
        {
          1002,
          "Bob"
        }
      )
    ],
    ArrayList<Schedule>[
      Schedule(
        {
          1,
          "Yoga practice"
        }
      )
    ]
  )

};

Answer 1

First, you only use friend_of_andy_1 in one place, so you can eliminate it:

List<Friend> andys_friends = new ArrayList<>();
andys_friends.add(new Friend(1002, "Bob"));

Second, if you're ok with the list having fixed size, i.e. you cannot add more elements to it, you can use Arrays.asList(), instead of creating an ArrayList:

List<Friend> andys_friends = Arrays.asList(new Friend(1002, "Bob"));

Then you can do the same for Schedule and inline that in the creation of Student:

Student student_andy = new Student(1001, "Andy",
                                   Arrays.asList(new Friend(1002, "Bob")),
                                   Arrays.asList(new Schedule(1, "Yoga practice")));

If the lists must be resizable, then use the ArrayList​(Collection<? extends E> c) constructor:

Student student_andy = new Student(
        1001,
        "Andy",
        new ArrayList<>(Arrays.asList(
                new Friend(1002, "Bob")
        )),
        new ArrayList<>(Arrays.asList(
                new Schedule(1, "Yoga practice")
        ))
);

And of course format that however you want, if you prefer the exploded style that takes up way too many lines of code:

Student student_andy = new Student(
    1001,
    "Andy",
    new ArrayList<>(
        Arrays.asList(
            new Friend(
                1002,
                "Bob"
            )
        )
    ),
    new ArrayList<>(
        Arrays.asList(
            new Schedule(
                1,
                "Yoga practice"
            )
        )
    )
);

Answer 2

Ok, so, essentially, you are missing JSON [footnote-1] too much? Understandable.

Below is a loose collection of methods for creation of instances in Java so that it looks like JSON as much as possible.

1) Arrays: Use inline array literals

They are slightly more verbose in Java, but almost as good as [ ... ] in JSON, e.g. :

new int[]{1, 2, 3}

is a literal for an array of integers.

2) Objects: Define proper constructors

If your Friend has a constructor public Friend(int id, String name), then initializing Friends is really easy and pleasant:

new Friend(1234, "Bob")

3) More objects, faster use factory methods

If you define factory methods, you can get rid of new. E.g. if you have

class Friend {
    ...
    static Friend friend(int id, String name) { return new Friend(id, name); }
}

then you can even get rid of new. This is useful in those seldom cases where you are defining some kind of embedded-DSL, and really need this constructor thousand times.

4) Lists: Use asList

You can import static methods using static imports in Java:

import static java.util.Arrays.asList;

now you have the handy asList available, so that

asList(friend(2, "John"), friend(3, "Bob"))

gives you a list of friends.

5) Maps: Use anonymous subclasses with initializer blocks.

This seemingly crazy thing works in java:

HashMap<String, Integer> hm = new HashMap<>{{
  put("foo", 10);
  put("bar", 20);
}};

this is because the inner pair of curly braces encloses an initializer block, in which you can call methods on this.

Ok, now you can easily create:

• Primitive stuff: Strings, ints, doubles
• User-defined objects (using constructors and factory methods)
• Arrays
• Lists
• Maps

This should be enough to create ad-hoc json-esque data structures in Java.

---

Now, assuming that all constructors are in place, your code becomes this:

import static java.util.Arrays.asList;

...

Student student_andy = new Student(
  1001,
  "Andy",
  asList(new Friend(1002, "Bob")),
  asList(new Schedule(1, "Yoga practice"))
)

We didn't use maps here, so the hint with initializer block is just a bonus.

[footnote-1] To be more precise: it seems as if you are missing the fragment of JavaScript which allows to easily initialize those objects which canonically map to JSON objects. JSON is of course not JavaScript. Thanks @Andreas for pointing that out.