Classes — Find the Bug¶

class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int width)   { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    public int  area()                { return width * height; }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;   // a square keeps sides equal
    }
    @Override
    public void setHeight(int height) {
        this.width = height;
        this.height = height;
    }
}

// A utility that works on any Rectangle:
class Geometry {
    /** Grows the rectangle to a target width, then asserts the area. */
    static void growToWidthAndCheck(Rectangle r, int newWidth) {
        int originalHeight = r.height;
        r.setWidth(newWidth);
        // The height was untouched, so area must be newWidth * originalHeight.
        assert r.area() == newWidth * originalHeight
            : "expected " + (newWidth * originalHeight) + " got " + r.area();
    }
}

// Caller:
Geometry.growToWidthAndCheck(new Square(), 5); // started 0x0

class CountingList<E> {
    private final List<E> items = new ArrayList<>();
    private int addCount = 0;

    public void add(E item) {
        addCount++;
        items.add(item);
    }

    public void addAll(Collection<? extends E> c) {
        for (E item : c) {
            add(item);     // delegate to add() so the count stays correct
        }
    }

    public int getAddCount() { return addCount; }
    public int size()        { return items.size(); }
}

// A subclass that wants to also keep a running total of string lengths:
class LengthTrackingList extends CountingList<String> {
    private int totalLength = 0;

    @Override
    public void add(String item) {
        totalLength += item.length();
        super.add(item);
    }

    @Override
    public void addAll(Collection<? extends String> c) {
        for (String s : c) {
            totalLength += s.length();
        }
        super.addAll(c);   // base class also tracks the count
    }

    public int getTotalLength() { return totalLength; }
}

// Caller:
var list = new LengthTrackingList();
list.addAll(List.of("ab", "cde"));
System.out.println(list.getTotalLength()); // expected 5

abstract class Report {
    private final String header;

    Report() {
        this.header = buildHeader();   // call a method subclasses define
    }

    /** Subclasses provide the title used in the header. */
    protected abstract String title();

    protected String buildHeader() {
        return "=== " + title().toUpperCase() + " ===";
    }

    public String header() { return header; }
}

class SalesReport extends Report {
    private final String region;

    SalesReport(String region) {
        super();                 // runs Report() first
        this.region = region;
    }

    @Override
    protected String title() {
        return "Sales for " + region;   // uses the field set in the subclass
    }
}

// Caller:
Report r = new SalesReport("EMEA");
System.out.println(r.header()); // expected: === SALES FOR EMEA ===

// "I want a list I can read but not modify — I'll reuse ArrayList's storage."
class ReadOnlyList<E> extends ArrayList<E> {

    ReadOnlyList(Collection<? extends E> initial) {
        super(initial);   // populate once, at construction
    }

    @Override
    public boolean add(E e) {
        throw new UnsupportedOperationException("read-only");
    }

    @Override
    public E remove(int index) {
        throw new UnsupportedOperationException("read-only");
    }
}

// Caller hands the read-only view to a logging routine:
void publish(List<String> tags) {
    ReadOnlyList<String> view = new ReadOnlyList<>(tags);
    audit(view);                 // third-party code, takes a List<String>
    System.out.println(view);    // expected: still the original tags
}

void audit(List<String> list) {
    list.removeIf(s -> s.startsWith("_"));   // strips internal tags for the log
}

class Widget {
    // "Default" CSS classes every widget starts with.
    protected static final List<String> DEFAULT_CLASSES =
        new ArrayList<>(List.of("widget"));

    protected List<String> cssClasses = DEFAULT_CLASSES;   // start from defaults

    public void addClass(String c) {
        cssClasses.add(c);
    }

    public List<String> classes() { return cssClasses; }
}

class Button extends Widget {
    Button() {
        addClass("button");   // buttons add their own class
    }
}

// Caller:
Button a = new Button();
Button b = new Button();
System.out.println(a.classes()); // expected: [widget, button]