Objects & Data Structures — Find the Bug¶

public class ShoppingCart {
    private final List<LineItem> items = new ArrayList<>();
    private BigDecimal discountRate = BigDecimal.ZERO; // e.g. 0.10 = 10% off

    public List<LineItem> getItems() { return items; }
    public BigDecimal getDiscountRate() { return discountRate; }
    public void setDiscountRate(BigDecimal r) { this.discountRate = r; }
}

// Caller A — the checkout screen, computes the order total:
BigDecimal subtotal = BigDecimal.ZERO;
for (LineItem item : cart.getItems()) {
    subtotal = subtotal.add(item.getPrice().multiply(BigDecimal.valueOf(item.getQty())));
}
BigDecimal total = subtotal.subtract(subtotal.multiply(cart.getDiscountRate()));
// total = subtotal * (1 - rate), with HALF_UP rounding applied once at the end

// Caller B — the invoice PDF generator (written by a different team):
BigDecimal sum = BigDecimal.ZERO;
for (LineItem item : cart.getItems()) {
    BigDecimal line = item.getPrice().multiply(BigDecimal.valueOf(item.getQty()));
    line = line.subtract(line.multiply(cart.getDiscountRate())); // discount each line
    sum = sum.add(line.setScale(2, RoundingMode.HALF_UP));       // round per line
}
// sum = Σ round(linePrice * (1 - rate))

public final class Coordinate {
    public int x;
    public int y;

    public Coordinate(int x, int y) { this.x = x; this.y = y; }

    @Override public boolean equals(Object o) {
        if (!(o instanceof Coordinate c)) return false;
        return x == c.x && y == c.y;
    }
    @Override public int hashCode() { return Objects.hash(x, y); }
}

// Game board: each occupied cell maps to the unit standing on it.
Map<Coordinate, Unit> board = new HashMap<>();

Coordinate pos = new Coordinate(2, 3);
board.put(pos, knight);

// Later, the unit moves. We update its position object in place:
pos.x = 5;
pos.y = 7;

Unit u = board.get(new Coordinate(5, 7)); // expecting the knight
System.out.println(u); // null

public class Inventory {
    private final Map<String, Integer> stock = new HashMap<>();

    public void receive(String sku, int qty) {
        stock.merge(sku, qty, Integer::sum);
    }

    public Map<String, Integer> getStock() {
        return stock; // hand out the live map
    }

    public boolean inStock(String sku) {
        return stock.getOrDefault(sku, 0) > 0;
    }
}

// Caller — a reporting module that wants "only items we currently hold":
Map<String, Integer> snapshot = inventory.getStock();
snapshot.entrySet().removeIf(e -> e.getValue() == 0); // drop sold-out SKUs for the report

// Meanwhile, elsewhere:
boolean canSell = inventory.inStock("SKU-123");

public class Employee {
    private Address address;
    public Address getAddress() { return address; }
    public void setAddress(Address a) { this.address = a; }
}

public class Address {
    private String city;
    public String getCity() { return city; }
    public void setCity(String c) { this.city = c; }
}

// HR onboards two employees who happen to share an office address.
Address office = new Address();
office.setCity("Boston");

Employee alice = new Employee();
Employee bob   = new Employee();
alice.setAddress(office);
bob.setAddress(office);

// Bob relocates. The UI does a Demeter reach-through:
bob.getAddress().setCity("Denver");

System.out.println(alice.getAddress().getCity()); // "Denver" ?!

public class Order {
    public List<LineItem> lines = new ArrayList<>();
    public BigDecimal totalCents = BigDecimal.ZERO; // cached running total
    public OrderStatus status = OrderStatus.OPEN;
}

public class OrderService {
    public void addLine(Order o, LineItem line) {
        o.lines.add(line);
        o.totalCents = o.totalCents.add(line.subtotal());
    }
}

// Caller A — correct path:
orderService.addLine(order, new LineItem("SKU-1", 2, cents(300)));

// Caller B — a CSV importer, written later, that doesn't know about OrderService:
order.lines.add(new LineItem("SKU-2", 5, cents(200))); // forgot to update totalCents

// Caller C — a "fix-up" job that cancels a line directly:
order.lines.remove(0); // totalCents not adjusted either

BigDecimal charged = order.totalCents; // used to charge the customer