الدوال البانية (Constructors)

Written Explanation

The shape of a constructor

A constructor looks like a method, with two differences: its name is exactly the class name, and it has no return type, not even void.

public class Account {
    String owner;
    String number;
    double balance;

    Account(String owner, String number, double balance) {
        this.owner = owner;
        this.number = number;
        this.balance = balance;
    }
}

You do not call a constructor by name. It runs automatically as part of new:

Account a = new Account("Ana", "A-1", 120.5);

What happens here, step by step: Java creates a new object with all fields at their defaults (the table from Lesson 1), then runs the constructor body with the arguments you passed, and finally new gives you a reference to the finished object. By the time you can use a, the three fields are set.

A short word about this.owner = owner;. Inside the constructor, owner on the right is the parameter, and this.owner on the left is the field of the object being built. this means "the object I am working on". The next lesson explains this fully, including what goes wrong without it. For now, copy the pattern: this.field = parameter;.

The free no-argument constructor, and when it vanishes

In Lesson 1 you wrote new Account() and it compiled even though the class had no constructor. That is because, as the Java tutorial states, the compiler provides a no-argument default constructor for any class that declares no constructors.

The moment you write any constructor yourself, the free one is gone. With the three-argument constructor above in place, this fails:

Account c = new Account();

Bad.java:3: error: no suitable constructor found for Account(no arguments)
        Account c = new Account();
                    ^
    constructor Account.Account(String,String,double) is not applicable
      (actual and formal argument lists differ in length)
1 error

This is a feature, not a nuisance. By writing a constructor that requires an owner, you have said "an Account must have an owner", and the compiler now enforces it everywhere. If you still want a no-argument form, write one explicitly.

Overloading constructors

A class may have several constructors, as long as their parameter lists differ in number or types. This is the same overloading you used for methods. Java picks the one that matches the arguments:

Account(String owner, String number, double balance) { ... }
Account(String owner, String number) { ... }   // new account, no money yet

new Account("Ana", "A-1", 120.5) uses the first; new Account("Omar", "A-2") uses the second.

Reusing code with this(...)

The second constructor must also set all three fields. Copying the three assignment lines would repeat code, and if the rules ever change, you would have to fix two places. Instead, one constructor can call another in the same class with this(...):

Account(String owner, String number) {
    this(owner, number, 0.0);
}

"Set the balance to 0.0, and let the full constructor do the work." The call this(...) has to be the first statement in the constructor. The compiler rejects it elsewhere (JDK 21):

Late.java:6: error: call to this must be first statement in constructor
        this(n, 1);
            ^

A good habit: one constructor, usually the one with the most parameters, does the real work; all other constructors forward to it with this(...).

What a constructor should do

A constructor's job is to put the object into a valid starting state. That means assigning fields, and perhaps a quick check of the arguments. It should not do heavy work: reading files, calling a web service, or talking to a database. If that work is slow or fails, new fails with it, and the failure shows up in an unexpected place. Keep constructors short and predictable, and do the heavy work in separate methods that you call deliberately.

Two traps. First, adding a return type turns a constructor into an ordinary method:

void Account(String owner) { ... }   // NOT a constructor: a method that happens to be called Account

It compiles, which makes it hard to spot. Second, a constructor cannot be called like a method (a.Account(...) is an error). It only runs through new.