`static` and `final`

public class Counting {

    static class Unit {
        static int created = 0;      // shared
        int serial;                  // one per object

        Unit() {
            created++;
            serial = created;
        }
    }

    static void reset() { }  // TODO: put the counter back to zero

    static int[] serialsOfThree()   { return new int[0]; }  // TODO
    static int createdAfterThree()  { return -1; }          // TODO

    static boolean allObjectsSeeTheSameCount() { return false; }  // TODO

    // With three objects made, how many copies of each field exist?
    static int copiesOf(String field) { return -1; }  // TODO

    // Do you need an object to read a static field?
    static boolean staticNeedsAnObject() { return true; }  // TODO

    public static void main(String[] args) {
        // TODO: make three units and print their serials and the shared count
    }
}

public class Args {

    static int count(String[] args) { return -1; }  // TODO

    // "0=10 1=20 2=30", empty string for no arguments.
    static String listThem(String[] args) { return ""; }  // TODO

    // Add them up. Skip anything that is not a number rather than failing.
    static int sumNumbers(String[] args) { return -1; }  // TODO
    static int countUnparseable(String[] args) { return -1; }  // TODO

    // "nothing was typed", or a summary.
    static String describe(String[] args) { return ""; }  // TODO

    // Does the standard java launcher pass null when no arguments were typed?
    static boolean standardLauncherPassesNull() { return true; }  // TODO

    public static void main(String[] args) {
        // TODO: report how many arguments arrived, and print each with its index
        // TODO: run it with numbers, with no arguments, and with a word
    }
}

import java.util.*;

public class FinalTrap {

    static class Squad {
        final String name;
        final int[] memberIds;
        final List<String> notes;

        Squad(String name, int[] memberIds) {
            this.name = name;
            this.memberIds = memberIds;
            this.notes = new ArrayList<>();
        }
    }

    static Squad sample() { return null; }  // TODO: "Alpha", {1, 2, 3}

    // Try to change things through the FINAL fields. Predict each first.
    static boolean canChangeArrayContents() { return false; }  // TODO
    static boolean canAddToFinalList()      { return false; }  // TODO

    // Try assigning a new array to the final field. Does it compile?
    static boolean canRepointFinalField() { return true; }  // TODO

    // TODO: a FrozenSquad that really is frozen
    static class FrozenSquad {
    }

    static boolean frozenResistsArrayChange() { return false; }  // TODO
    static String frozenListRejectsAdd()      { return ""; }     // TODO

    public static void main(String[] args) {
        // TODO: change a final field's contents three ways before fixing anything
    }
}

public class RegistryStats {

    static int bannerCount = 0;
    static void banner() { bannerCount++; }

    static class Unit {
        // TODO: decide static or not for each of these, and comment why:
        //   MAX_READINESS = 100.0, ORGANISATION = "Layers of Logic Registry"
        //   totalCreated, totalDeployments, nextId
        //   name, id, readiness, deployments

        // TODO: a constructor taking a name and a readiness, assigning the id automatically
        // TODO: void deploy()  -> increases this unit's count AND the shared total
        // TODO: static String report()  -> a line naming the organisation and both totals
        // TODO: a static block that calls banner() during Unit initialization
    }

    static void reset() { }  // TODO: put the shared counters back

    static boolean shouldBeStatic(String field) { return false; }  // TODO

    public static void main(String[] args) {
        // TODO: make two units, deploy a few times, and print the report
    }
}

import java.util.*;

public class Order {

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

    static class Noisy {
        static int staticCounter = report("1. static field initialiser");
        static { report("2. static block"); }

        int instanceField = report("3. instance field initialiser");
        { report("4. instance block"); }

        Noisy() { report("5. constructor body"); }

        Noisy(String tag) {
            this();
            report("6. second constructor, after this()");
        }
    }

    static int report(String what) { return 0; }  // TODO: record it

    // PREDICT each of these before running.
    static List<String> firstObject()          { return List.of(); }  // TODO
    static List<String> secondObject()         { return List.of(); }  // TODO
    static List<String> viaChainedConstructor(){ return List.of(); }  // TODO

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

    public static void main(String[] args) {
        // TODO: write down your predicted order, then run all three
    }
}