Anonymous Object

// ── Named object — variable holds the reference: ─────────────────────
StringBuilder namedBuilder = new StringBuilder();
namedBuilder.append("Hello");
namedBuilder.append(" World");
String result = namedBuilder.toString();
System.out.println(result);

// ── Anonymous object — used once, no variable: ────────────────────────
// Object created → method called → result used → object eligible for GC
System.out.println(new StringBuilder("Hello World").toString());

// ── The lifecycle of an anonymous object: ────────────────────────────
// 1. new StringBuilder("Hello") → object created on heap
// 2. .append(" World")          → method called on the new object
// 3. .toString()                → another method called
// 4. println(...)               → result used
// 5. Expression evaluated       → no variable holds the object
// 6. Object becomes unreachable → eligible for garbage collection

// ── Comparison — both produce the same result: ────────────────────────
// Named:
StringBuilder sb = new StringBuilder();
sb.append("Name: ").append("Alice").append(", Age: ").append(30);
System.out.println(sb.toString());

// Anonymous — no sb variable needed:
System.out.println(
    new StringBuilder().append("Name: ").append("Alice")
                        .append(", Age: ").append(30).toString()
);
// Both output: Name: Alice, Age: 30

// ── 1. Passing anonymous object as method argument: ──────────────────
public static void printDetails(Person person) {
    System.out.println("Name: " + person.getName() +
                       ", Age: " + person.getAge());
}

// Named — variable created just to be passed immediately:
Person namedPerson = new Person("Alice", 30);
printDetails(namedPerson);   // namedPerson never used again

// Anonymous — cleaner when object is used only as an argument:
printDetails(new Person("Alice", 30));

// ── 2. Returning anonymous object from a method: ──────────────────────
public static Point midpoint(double x1, double y1, double x2, double y2) {
    return new Point((x1 + x2) / 2, (y1 + y2) / 2);   // anonymous
}

// ── 3. Anonymous object in collections: ──────────────────────────────
List<Person> team = new ArrayList<>();
team.add(new Person("Alice",   30));   // all anonymous
team.add(new Person("Bob",     25));
team.add(new Person("Charlie", 35));

// ── 4. Chained method calls on anonymous object: ─────────────────────
String result = new StringBuilder()
    .append("Hello")
    .append(", ")
    .append("World")
    .append("!")
    .toString();
System.out.println(result);   // Hello, World!

// ── 5. Anonymous object in stream operations: ─────────────────────────
List<String> names = List.of("Alice", "Bob", "Charlie");
names.stream()
    .map(name -> new Person(name, 0))   // anonymous Person in map
    .map(Person::getName)
    .forEach(System.out::println);

// ── 6. Starting a thread with an anonymous Runnable object: ───────────
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in: " + Thread.currentThread().getName());
    }
}).start();   // Thread object is anonymous — fire and forget

// Modern equivalent with lambda (anonymous Runnable):
new Thread(() -> System.out.println("Lambda thread")).start();

// ── 7. Anonymous objects in test assertions: ──────────────────────────
// In JUnit tests — creating expected values inline:
assertEquals(new Point(3.0, 4.0), midpoint(0, 0, 6, 8));
assertEquals(new Address("123 Main", "London", "EC1A 1BB"),
             service.findAddressForUser("alice"));

// ── When anonymous objects are ideal: ────────────────────────────────

// GOOD: immutable value used once as argument:
double dist = origin.distanceTo(new Point(3.0, 4.0));

// GOOD: building a result to return immediately:
public Address getDefaultAddress() {
    return new Address("Unknown", "Unknown", "N/A", "N/A");
}

// GOOD: test assertion with expected value:
assertThat(calculator.add(2, 3)).isEqualTo(5);

// GOOD: one-time use in a stream:
List<String> emails = users.stream()
    .map(u -> new EmailBuilder(u.getEmail()).build())
    .collect(toList());

// ── When named objects are better: ────────────────────────────────────

// BAD: object used multiple times — needs a name:
System.out.println(new Person("Alice", 30).getName());
System.out.println(new Person("Alice", 30).getAge());  // creates TWO objects!

// GOOD: name it, use it multiple times:
Person alice = new Person("Alice", 30);
System.out.println(alice.getName());
System.out.println(alice.getAge());

// BAD: mutable object that needs to be referenced later:
// new StringBuilder().append("start").append(moreData);
// Can't append more later — lost the reference!

// GOOD: name the mutable object:
StringBuilder sb = new StringBuilder();
sb.append("start");
if (condition) sb.append(" more");
sb.append(" end");
return sb.toString();

// BAD: complex construction that might throw — hard to debug anonymously:
processOrder(new Order(customerId, items, new Date(), discount, "PENDING"));
// If Order constructor throws, the stack trace shows the line but not
// which argument caused it.

// GOOD: named construction for debuggability:
Order order = new Order(customerId, items, new Date(), discount, "PENDING");
processOrder(order);