Practical session

/**
 * Represents a blackboard with a surface that can be written on, read and erase.
 */
public class Blackboard {
    // The surface of the blackboard, as a private attribute
    private String surface;

    /**
     * Initializes a new instance of the Blackboard class.
     */
    public Blackboard() {
        this.surface = "";
    }

    /**
     * Writes the specified text on the surface of the blackboard.
     *
     * @param text: the text to be written on the surface of the blackboard
     */
    public void write(String text) {
        if (!text.isEmpty()) {
            // Add a new line if the text is not empty
            this.surface += "\n";
        }
        this.surface += text;
    }

    /**
     * Returns the text written on the surface of the blackboard.
     * @return the text written on the surface of the blackboard
     */
    public String read() {
        return this.surface;
    }

    /**
     * Shows the text written on the surface of the blackboard.
     */
    public void show() {
        System.out.println(this.surface);
    }

    /**
     * Erases the text written on the surface of the blackboard.
     */
    public void erase() {
        this.surface = "";
    }
}

public static void main(String[] args) {
    Blackboard blackboard = new Blackboard();
    blackboard.write("Hello world!");
    blackboard.show();
    blackboard.erase();
    if (blackboard.read() != "") {
        System.out.println("Error: The blackboard should be empty");
    }
}

import java.util.ArrayList;

/**
 * Represents a bank account with a balance and a transaction history.
 */
public class BankAccount {
    private final int accountNumber; // final keyword makes the attribute immutable
    private float balance;
    private final ArrayList<Float> history;

    /**
     * Initializes a new instance of the BankAccount class.
     * @param accountNumber: the account number
     */
    public BankAccount(int accountNumber) {
        this.accountNumber = accountNumber;
        this.balance = 0;
        this.history = new ArrayList<>();
    }

    /**
     * Deposits money into the bank account.
     *
     * @param amount: the amount to be deposited
     * @throws IllegalArgumentException if the amount is not positive
     */
    public void deposit(float amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        this.balance += amount;
        this.history.add(amount);
    }

    /**
     * Withdraws money from the bank account.
     *
     * @param amount: the amount to be withdrawn
     * @throws IllegalArgumentException if the amount is not positive or greater than the balance
     */
    public void withdraw(float amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        if (this.balance < amount) {
            throw new IllegalArgumentException("Insufficient funds");
        }
        this.balance -= amount;
        this.history.add(-amount);
    }

    /**
     * Returns the account number of the bank account.
     * @return the account number
     */
    public int getAccountNumber() {
        return this.accountNumber;
    }

    /**
     * Returns the balance of the bank account.
     * @return the balance
     */
    public float getBalance() {
        return this.balance;
    }

    /**
     * Returns the transaction history of the bank account.
     * @return the transaction history
     */
    public ArrayList<Float> getTransactionHistory() {
        return this.history;
    }
}

/**
 * Represents a bank account with a balance and a transaction history.
 */
public static void main(String[] args) {
    BankAccount account = new BankAccount(1);
    try {
        myAccount.deposit(500);
        myAccount.withdraw(200);
        myAccount.deposit(-50);
        myAccount.withdraw(10000);
        myAccount.withdraw(-50);
        myAccount.deposit(100);

        System.out.println("Balance: " + myAccount.getTransactionHistory()); // Should give [500, 200, -50, 100]
        System.out.println("Transaction history: " + myAccount.getBalance()); // Should give 300
    } catch (Exception e) {
        System.out.println("ERROR " + e);
    }
}

import java.util.ArrayList;

/**
 * Represents a bank account with a balance and a transaction history.
 */
public class BankAccount {
    private final Person owner;
    private final int accountNumber;
    private float balance;
    private final ArrayList<Float> history;

    /**
     * Initializes a new instance of the BankAccount class.
     *
     * @param accountNumber: the account number
     */
    public BankAccount(int accountNumber, Person owner) {
        if (owner == null) {
            throw new IllegalArgumentException("Owner must be specified");
        }
        this.accountNumber = accountNumber;
        this.owner = owner;
        this.balance = 0;
        this.history = new ArrayList<>();
        owner.addAccount(this);
    }

    /**
     * Deposits money into the bank account.
     *
     * @param amount: the amount to be deposited
     * @throws IllegalArgumentException if the amount is not positive
     */
    public void deposit(float amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        this.balance += amount;
        this.history.add(amount);
    }

    /**
     * Withdraws money from the bank account.
     *
     * @param amount: the amount to be withdrawn
     * @throws IllegalArgumentException if the amount is not positive or greater than the balance
     */
    public void withdraw(float amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        if (this.balance < amount) {
            throw new IllegalArgumentException("Insufficient funds");
        }
        this.balance -= amount;
        this.history.add(-amount);
    }

    /**
     * Returns the account number of the bank account.
     *
     * @return the account number
     */
    public int getAccountNumber() {
        return this.accountNumber;
    }

    /**
     * Returns the balance of the bank account.
     *
     * @return the balance
     */
    public float getBalance() {
        return this.balance;
    }

    /**
     * Returns the transaction history of the bank account.
     *
     * @return the transaction history
     */
    public ArrayList<Float> getTransactionHistory() {
        return this.history;
    }

    /**
     * Returns the owner of the bank account.
     *
     * @return the owner
     */
    public Person getOwner() {
        return this.owner;
    }

    /**
     * Returns a string representation of the bank account.
     *
     * @return a string representation of the bank account
     */
    // The annotation indicates that the following method overrides a method in the superclass, here Object.
    // This annotation is optional, but it is very good practice to use it.
    @Override
    public String toString() {
        return "Account number " + this.accountNumber + " from " + this.owner.fullName() + " has " +
                this.balance + " € and has done " + this.history.size() + " transactions";
    }
}

import java.util.ArrayList;

/**
 * Represents a person with a name, firstname, age and the list of bank accounts.
 */
public class Person {

    private final String firstName;
    private final String lastName;
    private int age; // not final because it can change
    private final ArrayList<BankAccount> accounts;

    /**
     * Initializes a new instance of the Person class with the specified first name, last name, and age.
     *
     * @param lastName  the last name
     * @param firstName the first name
     * @param age       the age
     */
    public Person(String lastName, String firstName, int age) {
        this.lastName = lastName.toUpperCase();
        this.firstName = firstName;
        this.age = age;
        this.accounts = new ArrayList<>();
    }

    /**
     * Returns the full name of the person.
     *
     * @return the full name
     */
    public String fullName() {
        return this.firstName + " " + this.lastName;
    }

    /**
     * Returns a list that contains all the bank accounts of the person.
     *
     * @return the list of bank accounts
     */
    public ArrayList<BankAccount> getAccounts() {
        return accounts;
    }

    /**
     * Add a bank account to the person.
     * If the account is already added, it will not be added again.
     *
     * @param account the account to add
     * @throws IllegalArgumentException if the account is null
     */
    public void addAccount(BankAccount account) {
        if (account == null) {
            throw new IllegalArgumentException("Account cannot be null");
        }
        if (!this.accounts.contains(account)) {
            this.accounts.add(account);
        }
    }

    /**
     * Remove a bank account from the person, if it exists.
     *
     * @param account the account to remove
     */
    public void removeAccount(BankAccount account) {
        this.accounts.remove(account);
    }

    /**
     * Returns a string representation of the person.
     * @return a string representation of the person
     */
    // The annotation indicates that the following method overrides a method in the superclass, here Object.
    // This annotation is optional, but it is very good practice to use it.
    @Override
    public String toString() {
        return firstName + " " + lastName + " (" + age + " old) has " + accounts.size() + " bank accounts";
    }

    /**
     * Compares two Person objects.
     *
     * @param obj the object to compare
     * @return true if the objects are equal, false otherwise.
     * Two persons are equal if they have the same lastname, firstname and age.
     */
    @Override
    public boolean equals(Object obj) {
        // First, check if the object given is an instance of Person
        if (obj instanceof Person) {
            // If it is, cast it to a Person object
            Person person = (Person) obj;
            // Then, compare the fields of the two objects
            return this.firstName.equals(person.firstName) && this.lastName.equals(person.lastName) && this.age == person.age;
        }
        return false;
    }
}

public static void main(String[] args) {
    // Create a person
    Person alice_weber = new Person("Weber", "Alice", 33);
    System.out.println(alice_weber); // Should give no bank account

    // Create a bank account for Alice
    BankAccount alice_account1 = new BankAccount(1, alice_weber);
    try {
        alice_weber.addAccount(null);
    } catch (IllegalArgumentException e) {
        System.out.println("ERROR. No added account. Account cannot be None");
    }

    // Create another bank account for Alice
    BankAccount alice_account2 = new BankAccount(2, alice_weber);
    System.out.println(alice_weber); // Should give two bank accounts

    // Remove the second bank account from Alice's accounts
    alice_weber.removeAccount(alice_account2);
    System.out.println(alice_weber); // Should give one bank account

    // Create a third bank account for Alice
    BankAccount alice_account3 = new BankAccount(3, alice_weber);

    // Test equals method
    Person new_alice = new Person("Weber", "Alice", 33);
    if (alice_account1.getOwner().equals(new_alice)) {
        System.out.println("getOwner Success");
    } else {
        System.out.println("getOwner Failure");
    }

    if (alice_account1.getBalance() == 0) {
        System.out.println("getBalance Success");
    } else {
        System.out.println("getBalance Failure");
    }

    if (alice_account1.getTransactionHistory().isEmpty()) {
        System.out.println("getTransactionHistory Success");
    } else {
        System.out.println("getTransactionHistory Failure");
    }

    //  Add some transactions to alice_account1
    alice_account1.deposit(500);
    alice_account1.withdraw(200);

    System.out.println(alice_account1.getBalance()); // Should give 300.0
    System.out.println(alice_account1.getTransactionHistory()); // Should give [500.0, -200.0]

    ArrayList<BankAccount> elements = alice_weber.getAccounts();
    System.out.println(elements); // Should give [alice_account1, alice_account3]

    System.out.println(alice_account1.getOwner());
}

// If Person class is in the same package, there is no need to import it
// Otherwise:
// import package.of.Person;
import java.util.ArrayList;
/**
 * Represents an elected official with a list of assistants.
 * It inherits from the Person class.
 */
public class ElectedOfficial extends Person {

    // The list of assistants of the elected official
    private final ArrayList<Person> assistants;

    /**
     * Constructs a new ElectedOfficial object with the specified lastname, firstname, age
     * He/she has no assistants.
     *
     * @param lastName  the last name
     * @param firstName the first name
     * @param age       the age
     */
    public ElectedOfficial(String lastName, String firstName, int age) {
        super(lastName, firstName, age);
        this.assistants = new ArrayList<>();
    }

    /**
     * Adds the specified assistant to the list of assistants of the elected official if it is not already in it.
     *
     * @param assistant the assistant to add
     */
    public void hireAssistant(Person assistant) {
        if (assistant != null) {
            this.assistants.add(assistant);
        }
    }

    /**
     * Removes the specified assistant from the list of assistants of the elected official.
     *
     * @param assistant the assistant to remove
     */
    public void fireAssistant(Person assistant) {
        if (assistant != null) {
            this.assistants.remove(assistant);
        }
    }

    /**
     * Returns the list of assistants of the elected official.
     *
     * @return the list of assistants of the elected official
     */
    public ArrayList<Person> getAssistants() {
        return assistants;
    }

    /**
     * Distributes the specified amount equally between the assistants of the elected official if the amount is positive.
     *
     * @param amount the amount to distribute
     */
    public void spendAllocation(float amount) {
        if (amount > 0) {
            for (Person assistant : assistants) {
                assistant.addBudget(amount / assistants.size());
            }
        }
    }

    /**
     * Returns a string representation of the ElectedOfficial object.
     * Uses the parent method to get a string representation of the ElectedOfficial object.
     * @return a string representation of the ElectedOfficial object
     */
    @Override
    public String toString() {
        return super.toString() + " with " + assistants.size() + " assistants";
    }
}

/**
 * Represents a thrifty elected representative.
 * Each assistant receives no more than the minimum wage (1766.92 euros gross), and, if there's any money left over, it's not spent.
 */
public class ThriftyElectedRepresentative extends ElectedOfficial {

    // Minimum wage in euros
    // The variable is declared as a static final variable to be shared among all instances of the class
    private static final float MINIMUM_WAGE = 1766.92f;

    /**
     * Constructs a new ThriftyElectedRepresentative object with the specified lastname, firstname, age.
     *
     * @param lastName  the last name
     * @param firstName the first name
     * @param age       the age
     */
    public ThriftyElectedRepresentative(String lastName, String firstName, int age) {
        super(lastName, firstName, age);
    }

    /**
     * Distributes the specified amount of money to the assistants.
     * Each assistant receives no more than the minimum wage (1766.92 euros gross).
     * If there's any money left over, it's not spent.
     *
     * @param amount the amount of money to distribute
     */
    @Override
    public void spendAllocation(float amount) {
        if (amount > MINIMUM_WAGE) {
            for (Person assistant : getAssistants()) {
                assistant.addBudget(MINIMUM_WAGE);
                amount -= MINIMUM_WAGE;
            }
        } else if (amount > 0) {
            super.addBudget(amount);
        }
    }
}

/**
 * Represents a Russian doll with a size, a state (opened or closed), a content and a container.
 */
public class RussianDoll{

    private final int size;
    private boolean opened;
    private RussianDoll content;
    private RussianDoll placedIn;

    /**
     * Initializes a new instance of the RussianDoll class.
     *
     * @param size the size of the doll
     */
    public RussianDoll(int size) {
        this.size = size;
        this.opened = false;
        this.content = null;
        this.placedIn = null;
    }

    /**
     * Opens the doll if it is not already open and if it is not inside another doll.
     */
    public void open() {
        if (!opened && placedIn == null) {
            opened = true;
        }
    }

    /**
     * Closes the doll if it is not already closed and if it is not inside another doll.
     */
    public void close() {
        if (opened && placedIn == null) {
            opened = false;
        }
    }

    /**
     * Places the current doll in doll p, if possible.
     * The current doll must be closed and not already inside another doll.
     * p must be opened and contain no doll, and it must be larger than the current doll.
     *
     * @param p the doll in which to place the current doll
     */
    public void placeIn(RussianDoll p) {
        if (!opened && placedIn == null && p.opened && p.content == null && p.size > size) {
            placedIn = p;
            p.content = this;
        }
    }

    /**
     * Takes the current doll out of doll p if it's in p and if p is open.
     *
     * @param p the doll from which to take out the current doll
     */
    public void getOut(RussianDoll p) {
        if (placedIn == p && p.opened) {
            placedIn = null;
            p.content = null;
        }
    }
}

/**
 * Represents an ingredient with a name, quantity, state, unit and price.
 */
public class Ingredient {
    private final String name;
    private final int quantity;
    private final String state;
    private final String unit;
    private final float price;

    /**
     * Initializes a new instance of the Ingredient class.
     *
     * @param name: the name of the ingredient
     * @param quantity: the quantity of the ingredient
     * @param state: the state of the ingredient (raw or cooked)
     * @param unit: the unit of the ingredient (g, kg, ml, cl, l)
     * @param price: the price of the ingredient
     * @throws IllegalArgumentException if the quantity is negative, the unit is not valid, the state is not valid or the price is negative
     */
    public Ingredient(String name, int quantity, String state, String unit, float price) {
        if (quantity < 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        if (!unit.toLowerCase().matches("g|kg|ml|cl|l")) {
            throw new IllegalArgumentException("Unit must be 'g','kg', 'ml', 'cl', or 'l'");
        }
        if (!state.toLowerCase().matches("raw|cooked")) {
            throw new IllegalArgumentException("State must be 'raw' or 'cooked'");
        }
        if(price < 0) {
            throw new IllegalArgumentException("Price must be positive");
        }
        this.name = name;
        this.quantity = quantity;
        this.state = state.toLowerCase();
        this.unit = unit.toLowerCase();
        this.price = price;
    }

    /**
     * Returns the price of the ingredient.
     * @return the price of the ingredient
     */
    public float getPrice() {
        return price;
    }

    /**
     * Returns a string representation of the Ingredient object.
     * @return a string representation of the Ingredient object
     */
    @Override
    public String toString() {
        return quantity + unit + " " + name + " (" + state + ", " + price + "€)";
    }

    /**
     * Compares two Ingredient objects.
     * Two ingredients are equal if they have the same name and state.
     *
     * @param obj the ingredient to compare with
     * @return true if the ingredients are equal, false otherwise
     */
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Ingredient) {
            Ingredient other = (Ingredient) obj;
            return name.equals(other.name) && state.equals(other.state);
        }
        return false;
    }
}

/**
 * Represents a meal with a name and a list of ingredients.
 */
public class Meal {
    private final String name;
    private final List<Ingredient> ingredients;

    /**
     * Initializes a new instance of the Meal class.
     *
     * @param name: the name of the meal
     * @param ingredients: the list of ingredients of the meal, may be empty
     */
    public Meal(String name, List<Ingredient> ingredients) {
        this.name = name;
        this.ingredients = new ArrayList<>(ingredients);
    }

    /**
     * Initializes a new instance of the Meal class.
     *
     * @param name: the name of the meal
     */
    public Meal(String name) {
        this(name, new ArrayList<>());
    }

    /**
     * Adds an ingredient to the meal.
     *
     * @param ingredient: the ingredient to add
     */
    public void addIngredient(Ingredient ingredient) {
        ingredients.add(ingredient);
    }

    /**
     * Removes an ingredient from the meal.
     *
     * @param ingredient: the ingredient to remove
     */
    public void removeIngredient(Ingredient ingredient) {
        ingredients.remove(ingredient);
    }

    /**
     * Returns a string representation of the Meal object.
     * @return a string representation of the Meal object
     */
    @Override
    public String toString() {
        return name + " - " + ingredients.stream().mapToDouble(Ingredient::getPrice).sum() + "€ \n"
                + ingredients.stream().map(ing -> "- " + ing + "\n").reduce("", String::concat);
    }

    /**
     * Compares two Meal objects.
     * Two meals are equal if they contain the same ingredients.
     *
     * @param obj the meal to compare with
     * @return true if the meals are equal, false otherwise
     */
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Meal) {
            Meal other = (Meal) obj;
            return ingredients.equals(other.ingredients);
        }
        return false;
    }
}

public static void main(String[] args) {
    // Pizza Margherita
    Ingredient pizzaDough = new Ingredient("Pizza Dough", 260, "raw", "g", 1.15f);

    Ingredient tomatoSauce = new Ingredient("Tomato Sauce", 200, "cooked", "g", 2.27f);
    Ingredient mozzarella = new Ingredient("Mozzarella", 125, "raw", "g", 1.19f);
    Ingredient parmigiano = new Ingredient("Parmigiano Reggiano", 60, "raw", "g", 1.83f);
    Ingredient basil = new Ingredient("Fresh Basil", 30, "raw", "g", 1.4f);

    Meal pizza = new Meal("Pizza Margherita");
    pizza.addIngredient(dough);
    pizza.addIngredient(tomatoSauce);
    pizza.addIngredient(mozzarella);
    pizza.addIngredient(parmigiano);
    pizza.addIngredient(basil);

    System.out.println(pizza);
}