Encapsulation, Inheritance, Packages, and `super`

public class Closed {

    static class Account {
        String owner;                 // TODO: close these two
        double balance;

        Account(String owner, double balance) {
            if (balance < 0) throw new IllegalArgumentException("negative opening balance");
            this.owner = owner;
            this.balance = balance;
        }

        String getOwner()   { return owner; }
        double getBalance() { return balance; }

        // TODO: refuse anything that is not a positive amount
        void deposit(double amount) { }

        // TODO: refuse a non positive amount, and refuse an overdraft
        void withdraw(double amount) { }
    }

    // Leave this one exactly as it is. It is here to be compared against.
    static class LooseAccount {
        private double balance;
        LooseAccount(double balance) { this.balance = balance; }
        double getBalance() { return balance; }
        void setBalance(double balance) { this.balance = balance; }
    }

    // "ok" if the account allowed it, or the exception's simple name if it refused.
    static String tryDeposit(double opening, double amount)  { return ""; }  // TODO
    static String tryWithdraw(double opening, double amount) { return ""; }  // TODO

    // What the account is left holding after the request, allowed or refused.
    static double balanceAfterWithdraw(double opening, double amount) { return -1; }  // TODO

    // The same request through LooseAccount: setBalance(getBalance() - amount).
    static double balanceIfSetterExisted(double opening, double amount) { return -1; }  // TODO

    public static void main(String[] args) {
        // TODO: ask for 500 out of a balance of 100, both ways, and compare
    }
}

import java.util.*;

public class Chain {

    static final List<String> log = new ArrayList<>();

    static class Unit {
        protected String name;
        Unit(String name) {
            log.add("Unit");
            this.name = name;
        }
    }

    static class AirUnit extends Unit {
        private int maxAltitude;
        AirUnit(String name, int maxAltitude) {
            super(name);
            log.add("AirUnit");
            this.maxAltitude = maxAltitude;
        }
    }

    static class StealthAirUnit extends AirUnit {
        StealthAirUnit(String name) {
            super(name, 20000);
            log.add("StealthAirUnit");
        }
    }

    // Build one StealthAirUnit and return the names in the order the bodies ran.
    // PREDICT the order before you run it.
    static List<String> buildOrder() { return List.of(); }  // TODO

    // The rule, not this example. Does a child compile, given what its parent offers
    // and whether the child writes its own super(...) call?
    static boolean compiles(boolean parentHasNoArgConstructor, boolean childCallsSuperExplicitly) {
        return true;  // TODO
    }

    // What does Java put in front of a constructor that calls neither super nor this?
    static String whatJavaInserts() { return ""; }  // TODO

    // Remove super(name) from AirUnit and read the error.
    static String errorReportedOn()   { return ""; }  // TODO: which class is blamed
    static String whatIsMissingIsIn() { return ""; }  // TODO: which class is short of a constructor

    public static void main(String[] args) {
        System.out.println("building: " + buildOrder());

        // TODO: remove super(name) from AirUnit. Predict the error, then read it.
        // TODO: add a no-arg Unit() and try again. Predict what changes.
    }
}

// Six proposed relationships. For each: inheritance, composition, or neither?
//
//  1. AirUnit        and Unit
//  2. Car            and Engine
//  3. Square         and Rectangle
//  4. Stack          and ArrayList
//  5. SavingsAccount and Account
//  6. Employee       and Person

public class IsA {

    static class Rectangle {
        private int width;
        private int height;
        void setWidth(int width)   { }  // TODO
        void setHeight(int height) { }  // TODO
        int area() { return 0; }        // TODO
    }

    // Number 3, with inheritance. Keep it square whatever anyone sets.
    static class Square extends Rectangle {
        // TODO: override both setters
    }

    // Number 3 again, without inheritance. It HAS a rectangle and only offers a side.
    static class SquareBySide {
        SquareBySide(int side) { }      // TODO
        void setSide(int side) { }      // TODO
        int area() { return 0; }        // TODO
    }

    // Leave this exactly as it is. It was written against Rectangle and has never
    // heard of Square, which is the entire point.
    static int resizeAndArea(Rectangle r) {
        r.setWidth(3);
        r.setHeight(4);
        return r.area();
    }

    // One lowercase word per pair: inheritance, composition or neither.
    static String relationship(int pair) { return ""; }  // TODO

    static boolean squarePassesSubstitutionTest() { return true; }  // TODO

    // Name the promise Rectangle makes that a square cannot keep.
    static String whyItFails() { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: run resizeAndArea on a Rectangle and on a Square, and compare
    }
}

// Shared by all:      name, id, readiness, active
// GroundUnit adds:    armourRating
// AirUnit adds:       maxAltitude, weatherClear
// NavalUnit adds:     displacement
//
// Deployability:      ground needs readiness >= 60
//                     air    needs readiness >= 60 AND clear weather
//                     naval  needs readiness >= 50
//
// The skeletons are here so the file compiles. Everything inside is yours.

class Unit {
    private final String name;
    private final String id;
    private final int readiness;
    private final boolean active;

    Unit(String name, String id, int readiness, boolean active) {
        // TODO: store all four
        this.name = null;
        this.id = null;
        this.readiness = 0;
        this.active = false;
    }

    String getName()     { return name; }
    String getId()       { return id; }
    int getReadiness()   { return readiness; }
    boolean isActive()   { return active; }

    // TODO: the rule that most units follow. The ones that differ override it.
    boolean isDeployable() { return false; }

    // TODO: something readable that includes the id and the name
    String describe() { return "TODO"; }
}

class GroundUnit extends Unit {
    private final int armourRating;

    GroundUnit(String name, String id, int readiness, boolean active, int armourRating) {
        super(name, id, readiness, active);
        this.armourRating = armourRating;
    }

    int getArmourRating() { return armourRating; }

    // TODO: does ground need its own rule, or is the one on Unit already right?
}

class AirUnit extends Unit {
    private final int maxAltitude;
    private final boolean weatherClear;

    AirUnit(String name, String id, int readiness, boolean active,
            int maxAltitude, boolean weatherClear) {
        super(name, id, readiness, active);
        this.maxAltitude = maxAltitude;
        this.weatherClear = weatherClear;
    }

    int getMaxAltitude()     { return maxAltitude; }
    boolean isWeatherClear() { return weatherClear; }

    // TODO: air is the only type with a second condition
}

class NavalUnit extends Unit {
    private final int displacement;

    NavalUnit(String name, String id, int readiness, boolean active, int displacement) {
        super(name, id, readiness, active);
        this.displacement = displacement;
    }

    int getDisplacement() { return displacement; }

    // TODO: naval sails ten points lower than everybody else
}

public class RegistryFamily {

    // TODO: count the deployable units. No instanceof and no casts.
    static int readyCount(Unit[] units) {
        return 0;
    }

    // TODO: one line per unit, then a summary line
    static String report(Unit[] units) {
        return "TODO";
    }

    public static void main(String[] args) {
        Unit[] units = {
            new GroundUnit("Anvil", "G-01", 74, true, 3),
            new AirUnit("Kestrel", "A-07", 88, true, 15000, false),
            new NavalUnit("Trident", "N-02", 55, true, 9000),
        };
        System.out.println(report(units));
    }
}