Ways to Create Objects in Java

You'll write new thousands of times, but it isn't the only way an object comes into existence. Frameworks such as Spring create objects for you without a single new in your code; copying, saving and loading objects create them too. "In how many ways can you create an object in Java?" is a favorite interview question, and knowing the answer also explains what those frameworks do behind the scenes.

Five Ways

All Five in One Program

import java.io.*;
 
public class Ways {
    static class Ticket implements Cloneable, Serializable {
        String name;
        int berth;
 
        Ticket() { this("Unassigned", 0); }
        Ticket(String name, int berth) { this.name = name; this.berth = berth; }
 
        static Ticket of(String n, int b) { return new Ticket(n, b); }
 
        @Override
        public Ticket clone() throws CloneNotSupportedException {
            return (Ticket) super.clone();
        }
 
        public String toString() { return name + "/" + berth; }
    }
 
    public static void main(String[] args) throws Exception {
        Ticket t1 = new Ticket("Navika", 23);
        Ticket t2 = Ticket.of("Srihitha", 24);
        Ticket t3 = Ticket.class.getDeclaredConstructor().newInstance();
        Ticket t4 = t1.clone();
 
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (ObjectOutputStream out = new ObjectOutputStream(bytes)) {
            out.writeObject(t1);
        }
        Ticket t5;
        try (ObjectInputStream in = new ObjectInputStream(
                new ByteArrayInputStream(bytes.toByteArray()))) {
            t5 = (Ticket) in.readObject();
        }
 
        System.out.println(t1 + " " + t2 + " " + t3 + " " + t4 + " " + t5);
        System.out.println("t1 == t4: " + (t1 == t4)
                + ", t1 == t5: " + (t1 == t5));
    }
}

Navika/23 Srihitha/24 Unassigned/0 Navika/23 Navika/23
t1 == t4: false, t1 == t5: false

How it works

1. Line 22: new calls the two-argument constructor.
2. Line 23: the static factory method of calls new for us. Factory methods can have meaningful names, reuse objects, or return a subclass.
3. Line 24: reflection finds the no-arg constructor at runtime and calls it. Frameworks use this to create objects from class names in configuration.
4. Line 25: clone() copies t1's fields into a new object, without running a constructor. The class must implement Cloneable.
5. Lines 27 to 35: serialization writes t1 to bytes, and deserialization rebuilds a new object from them. The class must implement Serializable.
6. The last line shows t4 and t5 are new objects (== is false) with the same values.

The throws Exception on main, and the try (...) blocks, handle the errors these methods can report; A later lesson explains them.

Try it yourself: add System.out.println("constructor"); inside the two-argument constructor. How many times does it print, and for which objects?

Which to Use

Common Mistakes

Saying there's only one way. new is the common one; interviewers expect the other four.

Calling clone() without implementing Cloneable. Object.clone() throws CloneNotSupportedException.

Assuming constructor validation always runs. Clones and deserialized objects skip it; that matters for security-sensitive classes.

Interview Corner

Practice

1. Easy: Add a static factory method vip(String name) to Ticket that always gives berth 1.
2. Harder: Add a counter that the constructors increase, create t1 to t5 as above, and print the counter. Explain the number.

Key Takeaways