Default Constructor

// ── Constructor anatomy: ─────────────────────────────────────────────
public class Person {
    //          ┌── same name as class
    //          │       ┌── no return type (not even void)
    public Person() {
        // constructor body — initialise fields here
    }
}

// ── Constructor is called by new: ────────────────────────────────────
Person p = new Person();
//           ↑         ↑
//           new       calls the no-arg constructor
//           allocates memory on the heap

// ── Constructor vs method — key differences: ─────────────────────────
public class Example {

    // CONSTRUCTOR — same name as class, no return type:
    public Example() {
        System.out.println("Constructor called");
    }

    // METHOD — different name, has return type (void here):
    public void example() {
        System.out.println("Method called");
    }

    // COMPILE ERROR — looks like a constructor but has return type:
    // public void Example() { }   // this is actually a method, not a constructor!
}

// ── What constructors can and cannot do: ─────────────────────────────
public class Account {
    private String id;
    private double balance;

    public Account() {
        this.id      = generateId();    // ✓ call methods
        this.balance = 0.0;             // ✓ initialise fields
        System.out.println("Account created: " + id); // ✓ print
        // return this;                 // ✗ cannot return a value
        // return;                      // ✓ bare return is allowed (early exit)
    }

    private String generateId() {
        return "ACC-" + System.currentTimeMillis();
    }
}

// ── No constructor defined — compiler inserts default: ───────────────
public class Box {
    private double width;
    private double height;
    private double depth;
    // No constructor written — compiler inserts:
    // public Box() { super(); }
}

Box box = new Box();    // works — uses compiler-generated default constructor
// box.width  = 0.0    (default value for double)
// box.height = 0.0
// box.depth  = 0.0

// ── The default constructor disappears when you add any constructor: ──
public class Product {
    private String name;
    private double price;

    // Adding this constructor REMOVES the compiler-generated default:
    public Product(String name, double price) {
        this.name  = name;
        this.price = price;
    }
}

// Product p1 = new Product();               // COMPILE ERROR — no default constructor
Product p2 = new Product("Laptop", 999.99);  // ✓ only this form works now

// ── To restore the no-arg form, define it explicitly: ─────────────────
public class Product {
    private String name;
    private double price;

    public Product() {
        this.name  = "Unknown";
        this.price = 0.0;
    }

    public Product(String name, double price) {
        this.name  = name;
        this.price = price;
    }
}

Product p1 = new Product();                  // ✓ uses explicit no-arg
Product p2 = new Product("Laptop", 999.99);  // ✓ uses parameterised

// ── When the default constructor is important: ────────────────────────
// Many frameworks (Hibernate, Jackson, Spring) require a no-arg
// constructor to instantiate objects reflectively.
// If you add a parameterised constructor, you must ALSO explicitly
// write the no-arg constructor for these frameworks to work.

// ── Visibility of the default constructor mirrors the class: ──────────
public  class A { }   // compiler inserts: public  A() { super(); }
        class B { }   // compiler inserts: (package-private) B() { super(); }
// private class C { } // compiler inserts: private C() { super(); }

// ── Default field values for all types: ──────────────────────────────
public class DefaultValues {
    // These fields are automatically initialised to defaults:
    byte    b;       // 0
    short   s;       // 0
    int     i;       // 0
    long    l;       // 0L
    float   f;       // 0.0f
    double  d;       // 0.0
    boolean flag;    // false
    char    c;       // '' (null character)
    String  str;     // null
    int[]   arr;     // null (the array reference, not the array contents)
    Object  obj;     // null
}

public static void main(String[] args) {
    DefaultValues dv = new DefaultValues();

    System.out.println("int:     " + dv.i);     // 0
    System.out.println("double:  " + dv.d);     // 0.0
    System.out.println("boolean: " + dv.flag);  // false
    System.out.println("char:    " + (int)dv.c);// 0
    System.out.println("String:  " + dv.str);   // null
    System.out.println("array:   " + dv.arr);   // null
}

// ── Instance fields get defaults — local variables do NOT: ────────────
public void demonstrate() {
    int localVar;
    // System.out.println(localVar);   // COMPILE ERROR — variable not initialised
    // Local variables must be explicitly initialised before use.

    int initialised = 0;
    System.out.println(initialised);   // 0 — fine, explicitly set
}

// ── Default values are set BEFORE constructor body runs: ──────────────
public class Counter {
    private int count;          // default: 0
    private String label;       // default: null

    public Counter() {
        // count is already 0 here — no need to write: this.count = 0;
        this.label = "default";  // explicitly set — null is not useful here
        System.out.println("count before set: " + count);   // 0
    }
}

// ── Danger: null default for reference types: ─────────────────────────
public class Order {
    private List<String> items;     // null by default — NOT an empty list!

    public Order() {
        // Without initialisation, items is null.
        // Calling items.add("x") would throw NullPointerException.
        this.items = new ArrayList<>();  // initialise to empty list in constructor
    }
}

// ── Explicit no-arg constructor with meaningful initialisation: ───────
public class ShoppingCart {
    private List<Item>  items;
    private String      sessionId;
    private LocalDateTime createdAt;
    private double      discount;

    // Explicit no-arg — sets everything to a valid starting state:
    public ShoppingCart() {
        this.items     = new ArrayList<>();          // empty, not null
        this.sessionId = UUID.randomUUID().toString();
        this.createdAt = LocalDateTime.now();
        this.discount  = 0.0;
        System.out.println("Cart created: " + sessionId);
    }

    public void addItem(Item item) {
        items.add(item);    // safe — items is never null
    }

    public double getTotal() {
        double total = items.stream()
            .mapToDouble(Item::getPrice)
            .sum();
        return total * (1 - discount);
    }
}

ShoppingCart cart = new ShoppingCart();
// cart.items is an ArrayList — never null
// cart.sessionId is a UUID string
// cart.createdAt is the current time

// ── No-arg constructor required for framework reflection: ─────────────
// Hibernate (JPA) needs to instantiate entities via reflection.
// Jackson needs to deserialise JSON into POJOs.
// Spring needs to instantiate beans.
// All of these require a no-arg constructor.

@Entity
public class UserEntity {
    @Id
    private Long   id;
    private String email;

    // Required by JPA — without this, Hibernate cannot instantiate:
    public UserEntity() { }

    // Also provide a useful constructor for application code:
    public UserEntity(String email) {
        this.email = email;
    }
}

// ── Explicit no-arg calling superclass: ───────────────────────────────
public class Animal {
    private String species;

    public Animal(String species) {         // only parameterised constructor
        this.species = species;
    }
}

public class Dog extends Animal {
    private String name;

    public Dog() {
        super("Canis lupus familiaris");    // must call superclass constructor
        this.name = "Unknown";
    }

    public Dog(String name) {
        super("Canis lupus familiaris");    // required — Animal has no no-arg ctor
        this.name = name;
    }
}