عرض عملي: الحسابات المصرفية v1 من ملف فارغ

Written Explanation

The plan

The lab asks for an Account with an owner, a number, and a balance; a full constructor and an overloaded one; deposit and withdraw; several accounts created in main; and a static counter of accounts. The acceptance criteria are: it compiles, it works, and main contains no logic beyond wiring. "Wiring" means creating objects, calling their methods, and printing. Any rule about money, such as "you cannot withdraw more than you have", belongs in Account, not in main.

We build in this order, compiling after each step:

1. Fields.
2. The full constructor.
3. The overloaded constructor.
4. deposit and withdraw.
5. A planned mistake and its fix.
6. main as wiring.

Working in small steps matters. If the code stops compiling after a change, you know that the last few lines caused it.

Step 1: the fields

Create a new file named Account.java. (In an IDE, use the "new class" action and type the name; on the command line, create the file in an empty folder.) Write:

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

The file name matches the class name, and the fields sit outside any method. Compile it (javac Account.java on the command line, or your IDE's build action). Nothing runs yet, but the compiler accepts it.

Step 2: the full constructor

Add the constructor that sets all three fields:

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

Every parameter has the same name as its field, and every assignment starts with this.. This is the pattern from Lessons 2 and 3.

Step 3: the overloaded constructor

A new account often starts empty. Add a second constructor that forwards to the first:

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

No assignments are repeated. Only one constructor, the full one, sets fields.

Step 4: deposit and withdraw

The methods hold the rules:

void deposit(double amount) {
    if (amount > 0) {
        balance += amount;
    }
}

boolean withdraw(double amount) {
    if (amount <= 0 || amount > balance) {
        return false;
    }
    balance -= amount;
    return true;
}

deposit ignores zero and negative amounts. withdraw refuses nonsense and overdrafts, changes the balance only when it can, and tells the caller whether it worked. Add describe() from Lesson 3, which returns owner + " (" + number + "): " + balance, so that main has something to print.

Step 5: the planned mistake

Now suppose that, while editing the full constructor, you slip and write:

Account(String owner, String number, double balance) {
    owner = owner;                 // mistake: the parameter is assigned to itself
    this.number = number;
    this.balance = balance;
}

It compiles. When you run the wiring from step 6, Ana's line shows:

null (A-1): 150.0

The owner has become null, while the number and balance, which kept this., are fine. This is exactly the symptom from Lesson 3: one field is at its default although a value was passed in. Compare the three assignments: only the one without this. is wrong. Restore this.owner = owner;, run again, and the owner returns.

A tip for finding this bug fast: when a single field is wrong and the others are right, compare its assignment line with the lines that work.

Step 6: main as wiring

Create a second file, Main.java:

public class Main {
    public static void main(String[] args) {
        Account ana = new Account("Ana", "A-1", 100);
        Account omar = new Account("Omar", "A-2");
        ana.deposit(50);
        omar.deposit(20);
        boolean ok = ana.withdraw(500);
        System.out.println(ana.describe());
        System.out.println(omar.describe());
        System.out.println("Second withdrawal ok? " + ok);
    }
}

Look at what main does: create two accounts, call methods, print. It has no if, no arithmetic on balances, and no rules. When a requirement changes, only Account changes.

Compile and run both files together (javac Account.java Main.java, then java Main, or use your IDE's run action on Main). The output on JDK 21:

Ana (A-1): 150.0
Omar (A-2): 20.0
Second withdrawal ok? false

Ana started with 100 and received 50. Her attempt to withdraw 500 was refused, so her balance stayed at 150. Omar started with 0 through the overloaded constructor and received 20.

Adding the counter

The lab also asks for a static counter of accounts created. Lesson 5 shows how: add static int count = 0; to Account and count++; to the full constructor, so the overloaded constructor counts too through this(...). Then a final line in main, System.out.println("Accounts created: " + Account.count);, prints:

Accounts created: 2

Because the short constructor forwards to the full one, the counting line exists in exactly one place. If you had copied the assignments into both constructors, you would have to remember to count in both.