Abstraction, Polymorphism, Abstract Classes, and Interfaces

class Unit {
    private final String name;
    private final double readiness;

    Unit(String name, double readiness) {
        this.name = name;
        this.readiness = readiness;
    }

    String getName()      { return name; }
    double getReadiness() { return readiness; }

    // TODO: the rule most units follow
    boolean isDeployable() { return false; }
}

class Ground extends Unit {
    private final int armour;
    Ground(String name, double readiness, int armour) { super(name, readiness); this.armour = armour; }
    int getArmour() { return armour; }
    // TODO: does ground differ from Unit, or is there nothing to write here?
}

class Air extends Unit {
    private final boolean weatherClear;
    Air(String name, double readiness, boolean weatherClear) { super(name, readiness); this.weatherClear = weatherClear; }
    boolean isWeatherClear() { return weatherClear; }
    // TODO: air needs the readiness AND the weather
}

class Naval extends Unit {
    private final int displacement;
    Naval(String name, double readiness, int displacement) { super(name, readiness); this.displacement = displacement; }
    int getDisplacement() { return displacement; }
    // TODO: naval sails at 50
}

// The fourth type. It arrived after countDeployable was written, which is the point.
class Space extends Unit {
    private final int shielding;
    Space(String name, double readiness, int shielding) { super(name, readiness); this.shielding = shielding; }
    int getShielding() { return shielding; }
    // TODO: space needs 80
}

public class NoInstanceof {

    // The version to delete. It is correct today and it has to be edited
    // every time somebody adds a type. Note that it does not know about Space.
    static int countDeployable(Unit[] units) {
        int ready = 0;
        for (Unit u : units) {
            if (u instanceof Ground) {
                if (u.getReadiness() >= 60) ready++;
            } else if (u instanceof Air) {
                Air a = (Air) u;
                if (u.getReadiness() >= 60 && a.isWeatherClear()) ready++;
            } else if (u instanceof Naval) {
                if (u.getReadiness() >= 50) ready++;
            }
        }
        return ready;
    }

    public static void main(String[] args) {
        Unit[] units = {
            new Ground("Anvil", 74, 3),
            new Air("Kestrel", 88, false),
            new Naval("Trident", 55, 9000),
            new Space("Orbiter", 91, 12),
        };
        System.out.println(countDeployable(units) + " of " + units.length + " deployable");
    }
}

class Unit    { boolean deployable() { return true; } }
class AirUnit extends Unit { @Override boolean deployable() { return false; } }

public class Invokes {

    // The two the bytecode question is about. Leave them alone.
    static void over(int x)    { }
    static void over(double x) { }

    // The three the prediction questions are about. Leave these alone too.
    static String pick(int x)    { return "int"; }
    static String pick(double x) { return "double"; }
    static String pick(Object x) { return "Object"; }

    // ---- what javap showed ----
    // Compile this file, then run: javap -c Invokes
    // Read only the main method. Fill in what you see.

    // TODO: the instruction on the u.deployable() line
    static String overriddenCallInstruction() { return "?"; }

    // TODO: the class name written beside it. Read it carefully before you answer.
    static String classRecordedByThatInstruction() { return "?"; }

    // TODO: the instruction on both over(...) lines
    static String overloadedCallInstruction() { return "?"; }

    // TODO: the descriptor beside over(5), in the form javap prints it
    static String intCallDescriptor() { return "?"; }

    // TODO: the descriptor beside over(5.0)
    static String doubleCallDescriptor() { return "?"; }

    // TODO: had the compiler already picked which over() runs?
    static boolean overloadChosenByCompiler() { return false; }

    // TODO: had it already picked which deployable() runs?
    static boolean overrideChosenByCompiler() { return true; }

    // ---- predictions, from the same rule ----
    // Which pick() does the compiler choose for each of these?
    // Answer first, then run main and check.

    // TODO
    static String predictedForChar() { return "?"; }

    // TODO
    static String predictedForLong() { return "?"; }

    // TODO
    static String predictedForInteger() { return "?"; }

    // TODO
    static String predictedForNull() { return "?"; }

    public static void main(String[] args) {
        Unit u = new AirUnit();
        System.out.println(u.deployable());

        over(5);
        over(5.0);

        char c = 'x';
        long millis = 5L;
        Integer boxed = 7;
        System.out.println("char    -> " + pick(c));
        System.out.println("long    -> " + pick(millis));
        System.out.println("Integer -> " + pick(boxed));
        System.out.println("null    -> " + pick(null));
    }
}

// You are modelling a fleet. Decide abstract class or interface for each,
// and implement all four.
//
//  Vehicle      - every vehicle has a name and a fuel level, and can refuel
//  Flyable      - can take off and land. Applies to planes AND to some drones.
//  Trackable    - reports a position. Applies to vehicles AND to cargo crates.
//  Repairable   - can be damaged and repaired. Applies to almost everything.
//
// Then build: Plane (a Vehicle that is Flyable, Trackable, Repairable)
//             Crate (not a Vehicle at all, and still Trackable)
//
// Decide each one and write the reason down before you write any code.

// TODO: class or interface?
abstract class Vehicle {
    // TODO: name, fuel level, a constructor, getName, getFuelLevel, refuel
}

// TODO: class or interface?
interface Flyable {
    // TODO: takeOff, land, isAirborne
}

// TODO: class or interface?
interface Trackable {
    // TODO: position
}

// TODO: class or interface?
interface Repairable {
    // TODO: takeDamage, repair, isDamaged
}

// TODO
class Plane {
}

// TODO: what must Crate NOT extend?
class Crate {
}

public class Choose {

    // TODO: accept anything trackable and return each position, in order
    static String[] positionsOf(Trackable[] items) {
        return new String[0];
    }

    // ---- the reasons, written down ----

    // TODO: could Vehicle have been an interface?
    static boolean vehicleCanBeAnInterface() { return true; }

    // TODO: is a field declared in an interface one value shared by everybody?
    static boolean interfaceFieldsAreShared() { return false; }

    // TODO: can an interface hold data that differs from object to object?
    static boolean interfaceCanHoldPerObjectState() { return true; }

    // TODO: in your design, is a Crate a Vehicle?
    static boolean crateIsAVehicle() { return true; }

    public static void main(String[] args) {
        // TODO: build a Plane and a Crate, and pass both through positionsOf
    }
}

class Unit {
    boolean isDeployable(double minReadiness) { return true; }
    String describe() { return "a unit"; }
    static String kind() { return "unit"; }
}

class AirUnit extends Unit {
    boolean isDeployable(int minReadiness) { return false; }   // note the type
    String describ() { return "an air unit"; }                 // note the spelling
    static String kind() { return "air"; }
}

public class NotAnOverride {

    // ---- predictions about the BROKEN version above, before you change anything ----

    // TODO: what does System.out.println(u.isDeployable(60.0)) print?
    static boolean predictedDeployableLine() { return false; }

    // TODO: what does System.out.println(u.describe()) print?
    static String predictedDescribeLine() { return "?"; }

    // TODO: what does System.out.println(Unit.kind()) print, with u declared as a Unit?
    static String predictedKindLine() { return "?"; }

    // ---- now add @Override to both instance methods and count what the compiler says ----

    // TODO: how many errors appeared?
    static int overrideAnnotationErrors() { return 0; }

    // ---- then fix both, and look at the static one again ----

    // TODO: "variable" or "object"? Which one decides that Unit.kind runs?
    static String kindIsChosenBy() { return "?"; }

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

    // TODO: "hiding" or "overriding"? What is AirUnit.kind doing to Unit.kind?
    static String hidingOrOverriding() { return "?"; }

    public static void main(String[] args) {
        Unit u = new AirUnit();
        System.out.println(u.isDeployable(60.0));
        System.out.println(u.describe());
        System.out.println(Unit.kind());
        System.out.println(AirUnit.kind());
    }
}