Objects in Memory: Size, Copying, Passing

public class ByValue {

    static class Unit {
        String name;
        int readiness;
        Unit(String name, int readiness) { this.name = name; this.readiness = readiness; }
        @Override public String toString() { return name + "/" + readiness; }
    }

    // Leave these four exactly as they are.
    static void changeNumber(int n)   { n = 999; }
    static void changeField(Unit u)   { u.readiness = 999; }
    static void replaceObject(Unit u) { u = new Unit("Ghost", 0); }
    static void swap(Unit a, Unit b)  { Unit t = a; a = b; b = t; }

    // Call each one and report what the CALLER sees afterwards.
    // PREDICT all four before running.
    static int    numberAfterCall()   { return -1; }  // TODO
    static int    fieldAfterCall()    { return -1; }  // TODO
    static String nameAfterReplace()  { return ""; }  // TODO
    static String afterSwap()         { return ""; }  // TODO

    // One short phrase: what does Java copy when it passes an argument?
    static String whatIsCopied() { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: run all four and check them against your predictions
    }
}

import java.util.Arrays;

public class Copying {

    static class Address {
        String city;
        Address(String city) { this.city = city; }
        @Override public String toString() { return city; }
    }

    static class Unit {
        String name;
        Address base;
        int[] history;

        Unit(String name, Address base, int[] history) {
            this.name = name; this.base = base; this.history = history;
        }

        // TODO: copy the fields one level. References get shared.
        Unit shallowCopy() { return null; }

        // TODO: give every mutable thing its own copy.
        Unit deepCopy() { return null; }
    }

    static Unit sample() { return null; }  // TODO: Atlas, Pune, {1, 2, 3}

    // Copy, change something through the COPY, report on the ORIGINAL.
    static boolean shallowSharesAddress() { return false; }  // TODO
    static boolean shallowSharesArray()   { return false; }  // TODO
    static boolean shallowSharesName()    { return false; }  // TODO
    static boolean deepSharesAddress()    { return false; }  // TODO
    static boolean deepSharesArray()      { return false; }  // TODO

    public static void main(String[] args) {
        // TODO: predict all five before running
    }
}

public class Sizes {

    // HYPOTHETICAL MODEL FOR THIS EXERCISE:
    // header 12, reference 4, int 4, long 8, double 8, boolean field 1,
    // char 2, object alignment 8. A real JVM may lay these classes out differently.

    static final int HEADER = 12;

    static class Empty { }
    static class OneInt { int a; }
    static class TwoInts { int a, b; }
    static class OneLong { long a; }
    static class ThreeRefs { String a, b, c; }
    static class Mixed { long a; int b; boolean c; String d; }

    static int roundUp(int bytes) { return 0; }  // TODO
    static int sizeOfField(String type) { return -1; }  // TODO
    static int sizeOf(String className) { return -1; }  // TODO

    // What fraction of the object is your data rather than bookkeeping?
    static double dataShare(String className) { return 0; }  // TODO

    public static void main(String[] args) {
        // TODO: print the size of all six and check them against your paper working
    }
}

import java.util.Arrays;

public class Leak {

    // Both ends are open. Leave this one as it is.
    static class LeakySquad {
        private String name;
        private int[] memberIds;
        LeakySquad(String name, int[] memberIds) { this.name = name; this.memberIds = memberIds; }
        int[] getMemberIds() { return memberIds; }
        int size() { return memberIds.length; }
    }

    // TODO: the same class with both holes closed
    static class SafeSquad {
        private final String name;
        private final int[] memberIds;
        SafeSquad(String name, int[] memberIds) { this.name = name; this.memberIds = memberIds; }
        int[] getMemberIds() { return memberIds; }
        int size() { return memberIds.length; }
    }

    // Try to change the PRIVATE array from outside. Did it work?
    static boolean leaksThroughConstructor() { return false; }  // TODO
    static boolean leaksThroughGetter()      { return false; }  // TODO
    static boolean safeThroughConstructor()  { return true; }   // TODO
    static boolean safeThroughGetter()       { return true; }   // TODO

    // How many copies does closing this properly take?
    static int copiesNeeded() { return 1; }  // TODO

    public static void main(String[] args) {
        // TODO: change a private field from outside, twice, two different ways
    }
}