Static Nested, Inner, Local, and Anonymous Classes

public class Nested {
    private String orgName = "Layers of Logic";
    private static String version = "1.0";

    static class Entry {
        String name;
        Entry(String name) { this.name = name; }

        String show() {
            return name + " v" + version;
            // return name + " " + orgName;   // uncomment: does this compile? why not?
        }
    }

    class Auditor {
        String report() {
            return "auditing " + orgName + " v" + version;
        }
    }

    // TODO: build a Nested, then an Auditor from it, and return the report.
    // The syntax for creating an inner object is unusual. Work it out.
    static String makeAuditorReport() {
        return "TODO";
    }

    // ---- what you worked out ----

    // TODO: can Entry read orgName?
    static boolean entryCanReadOuterInstanceField() { return true; }

    // TODO: compile, then run  javap -p 'Nested$Auditor'  and read the field list.
    // What is the field called that you never wrote?
    static String hiddenFieldName() { return "?"; }

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

    // TODO: now run javap -p 'Nested$Entry' and compare
    static boolean entryHasHiddenField() { return true; }

    // TODO: one word. Which of the two should you reach for by default?
    static String defaultChoice() { return "?"; }

    public static void main(String[] args) {
        System.out.println(new Entry("Atlas").show());
        System.out.println(makeAuditorReport());
    }
}

import java.util.*;

public class Pin {

    static class Holder {
        private final byte[] hugeBuffer;
        private final String label;

        Holder(int megabytes, String label) {
            this.hugeBuffer = new byte[megabytes * 1_000_000];
            this.label = label;
        }

        String getLabel()  { return label; }
        int bufferBytes()  { return hugeBuffer.length; }

        // Inner, and it reads an outer field.
        class UsingListener {
            String describe() { return "listener for " + label; }
        }

        // Inner, and it touches nothing outer. Predict what the compiler does with this one.
        class BlindListener {
            String describe() { return "listener for nobody"; }
        }

        // Static nested.
        static class StaticListener {
            String describe() { return "listener for nobody"; }
        }

        UsingListener makeUsing() { return new UsingListener(); }
        BlindListener makeBlind() { return new BlindListener(); }
        static StaticListener makeStatic() { return new StaticListener(); }
    }

    static long usedMB() {
        Runtime rt = Runtime.getRuntime();
        System.gc();
        try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return (rt.totalMemory() - rt.freeMemory()) / (1024 * 1024);
    }

    // ---- what you found ----

    // TODO: the field name from the previous exercise
    static String hiddenFieldName() { return "?"; }

    // TODO: run the three loops, then run javap -p on each listener class
    static boolean usingListenerPinsHolder()  { return false; }

    // TODO: this one is the surprise. Check it before you answer.
    static boolean blindListenerPinsHolder()  { return true; }

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

    // TODO: the megabytes you actually saw, in the using run and the static run
    static long recordedUsingMB()  { return 0; }
    static long recordedStaticMB() { return 0; }

    // TODO: one word, on the nested class
    static String oneKeywordFix() { return "?"; }

    // TODO: could a change that says nothing about memory create this leak?
    static boolean addingOneLineCanCreateTheLeak() { return false; }

    public static void main(String[] args) {
        System.out.println("start        : " + usedMB() + " MB");

        List<Object> kept = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            kept.add(new Holder(12, "unit-" + i).makeUsing());   // keep only the tiny listener
        }
        System.out.println("5 using inner: " + usedMB() + " MB");

        // TODO: repeat with makeStatic, and then with makeBlind, and compare all three
    }
}

import java.util.*;

interface Greeter { String greet(String name); }

// TODO 1. a named class implementing Greeter
class NamedGreeter implements Greeter {
    @Override public String greet(String name) { return "TODO"; }
}

public class Anonymous {

    static Greeter namedGreeter() { return new NamedGreeter(); }

    // TODO 2. the same behaviour using an anonymous class
    static Greeter anonymousGreeter() {
        return null;
    }

    // TODO 3. the same behaviour using a lambda
    static Greeter lambdaGreeter() {
        return null;
    }

    // TODO 4. sort by length, as an anonymous Comparator
    static Comparator<String> anonymousLengthComparator() {
        return null;
    }

    // TODO 5. the same comparison behaviour, as a lambda
    static Comparator<String> lambdaLengthComparator() {
        return null;
    }

    // ---- what the folder showed ----
    // Compile, then list the class files in the folder.

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

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

    // ---- what the lambda removed, and how the compiler already knew it ----

    // TODO: the interface name is gone. Where did the compiler get it?
    static boolean lambdaInterfaceNameComesFromTheTarget() { return false; }

    // TODO: the method name is gone too
    static boolean lambdaMethodNameComesFromTheInterface() { return false; }

    // TODO: and the parameter type
    static boolean lambdaParameterTypeIsInferred() { return false; }

    // TODO: how many abstract methods can an interface have and still accept a lambda?
    static int abstractMethodsALambdaTargetCanHave() { return 0; }

    public static void main(String[] args) {
        // TODO: call all three greeters and print the class each one really is

        List<String> units = new ArrayList<>(List.of("Cipher", "Atlas", "Drift", "Beacon"));

        // TODO: sort a copy with each comparator and confirm the results match
        if (units.isEmpty()) System.out.println();
    }
}

interface Task { String run(); }

public class Effectively {

    static Task makeTask() {
        int counter = 0;
        String label = "task";

        Task t = new Task() {
            @Override public String run() {
                return label + " " + counter;
            }
        };

        // counter++;      // uncomment: what happens, and on which line is it reported?
        return t;
    }

    // TODO: a task that counts. Every call returns the next number, starting at 1,
    // as a String. Two tasks made separately must count separately.
    static Task makeCountingTask() {
        int counter = 0;
        return () -> String.valueOf(counter);
    }

    // ---- what you worked out ----

    // TODO: was the error on the line that READS counter, or the line that CHANGES it?
    static boolean errorIsReportedOnTheUsingLine() { return false; }

    // TODO: one word. "stack" or "heap"
    static String whereLocalsLive() { return "?"; }

    // TODO: one word. Where does the task object live?
    static String whereTheObjectLives() { return "?"; }

    // TODO: how did run() still have the values after makeTask returned?
    static boolean valuesAreCopiedIntoTheObject() { return false; }

    // TODO: why is copying only safe when the original cannot change?
    static boolean aChangingLocalWouldMakeTwoAnswers() { return false; }

    public static void main(String[] args) {
        Task t = makeTask();
        System.out.println(t.run());        // makeTask has already returned by now

        // TODO: run the counting task three times and check the number moves
    }
}