Encapsulation in Java: Data Hiding, Getters, and Setters

// Shows data hiding, validation in setters, read-only properties,
// computed getters, and defensive copying of mutable state.
public class EncapsulationDemo {
    private static final long MINIMUM_CENTS = 0L;
    private static final long INITIAL_CENTS = 50000L;
    private static final int FIRST = 0;
    private static final int MIN_PERCENT = 0;
    private static final int MAX_PERCENT = 100;
    private static final String NO_ITEMS = "none";
    private static final double SQUARED_SIDE = 4.0;
    // A MUTABLE FIELD WITH A VALIDATING SETTER
    public static class Account {
        private final String owner;
        private long balanceCents;
        public Account(String owner, long initialCents) {
            if (owner == null || owner.isBlank()) {
                throw new IllegalArgumentException("Owner is required");
            } if (initialCents < MINIMUM_CENTS) {
                throw new IllegalArgumentException("Balance cannot be negative");
            } this.owner = owner;
            this.balanceCents = initialCents;
        } public String getOwner() {
            return owner;
        } public long getBalanceCents() {
            return balanceCents;
        } // THE GATE, this is the whole reason the field is private
        public void setBalanceCents(long cents) {
            if (cents < MINIMUM_CENTS) {
                throw new IllegalArgumentException("Balance cannot be negative");
            } this.balanceCents = cents;
        } // A BUSINESS RULE, which a plain setter could not express
        public void deposit(long cents) {
            if (cents <= MINIMUM_CENTS) {
                throw new IllegalArgumentException("Deposit must be positive");
            } this.balanceCents = this.balanceCents + cents;
        }
    } // NO SETTER AT ALL, so this property is read-only
    public static class Temperature {
        private final double celsius;
        public Temperature(double celsius) {
            this.celsius = celsius;
        } public double getCelsius() {
            return celsius;
        }
    } // A COMPUTED GETTER, so there is no field to keep in sync
    public static class Rectangle {
        private final double width;
        private final double height;
        public Rectangle(double width, double height) {
            this.width = width;
            this.height = height;
        } public double getWidth() {
            return width;
        } public double getHeight() {
            return height;
        } public double getArea() {
            return width * height;
        } public boolean isSquare() {
            return width == height;
        }
    } // DEFENSIVE COPYING, the fix for a getter that would otherwise leak state
    public static class Playlist {
        private final java.util.List<String> tracks = new java.util.ArrayList<>();
        // Returns an unmodifiable view, so the caller cannot alter our field
        public java.util.List<String> getTracks() {
            return java.util.Collections.unmodifiableList(tracks);
        } public void addTrack(String track) {
            if (track == null || track.isBlank()) {
                throw new IllegalArgumentException("Track name is required");
            } tracks.add(track);
        } public int getTrackCount() {
            return tracks.size();
        } public String getFirstTrack() {
            if (tracks.isEmpty()) {
                return NO_ITEMS;
            } return tracks.get(FIRST);
        }
    } // A CLAMPING SETTER, which normalises instead of rejecting
    public static class Progress {
        private int percent;
        public Progress() {
            this.percent = MIN_PERCENT;
        } public int getPercent() {
            return percent;
        } public void setPercent(int value) {
            this.percent = Math.max(MIN_PERCENT, Math.min(value, MAX_PERCENT));
        }
    } // ALL FIELDS PRIVATE AND FINAL, VALIDATED ONCE, WITH NO SETTERS
    public static class Employee {
        private static final double MINIMUM_SALARY = 0.0;
        private final String name;
        private final double salary;
        public Employee(String name, double salary) {
            if (name == null || name.isBlank()) {
                throw new IllegalArgumentException("Name is required");
            } if (salary < MINIMUM_SALARY) {
                throw new IllegalArgumentException("Salary cannot be negative");
            } this.name = name;
            this.salary = salary;
        } public String getName() {
            return name;
        } public double getSalary() {
            return salary;
        } // Derived from salary, so nothing extra is stored
        public double getAnnualBonus() {
            return salary / SQUARED_SIDE;
        }
    } private static String describe(Object value) {
        if (value == null) {
            return "null";
        } return value.getClass().getSimpleName();
    } public static void main(String[] args) {
        // A VALIDATING SETTER REJECTS WHAT A PUBLIC FIELD WOULD ACCEPT
        Account account = new Account("Alice", INITIAL_CENTS);
        account.setBalanceCents(65000L);
        System.out.println("balance: " + account.getBalanceCents());
        try {
            account.setBalanceCents(-1L);
        } catch (IllegalArgumentException problem) {
            System.out.println("rejected: " + problem.getMessage());
        } // A BUSINESS RULE CANNOT BE EXPRESSED AS A PLAIN ASSIGNMENT
        account.deposit(2000L);
        System.out.println("after deposit: " + account.getBalanceCents());
        // A READ-ONLY PROPERTY, THERE IS NO setCelsius METHOD TO CALL
        Temperature warm = new Temperature(21.5);
        System.out.println("celsius: " + warm.getCelsius());
        // A COMPUTED GETTER WITH NO UNDERLYING FIELD
        Rectangle box = new Rectangle(SQUARED_SIDE, SQUARED_SIDE);
        System.out.println("area: " + box.getArea() + "  square: " + box.isSquare());
        // DEFENSIVE COPYING, THE CALLER SEES THE DATA BUT CANNOT CHANGE IT
        Playlist playlist = new Playlist();
        playlist.addTrack("Blue Monday");
        playlist.addTrack("Bizarre Love Triangle");
        System.out.println("tracks: " + playlist.getTracks());
        System.out.println("count:  " + playlist.getTrackCount());
        System.out.println("first:  " + playlist.getFirstTrack());
        try {
            playlist.getTracks().add("Injected");
        } catch (UnsupportedOperationException problem) {
            System.out.println("playlist stayed unchanged: " + playlist.getTrackCount());
        } // A CLAMPING SETTER NORMALISES INSTEAD OF REJECTING
        Progress progress = new Progress();
        progress.setPercent(140);
        System.out.println("clamped percent: " + progress.getPercent());
        progress.setPercent(-20);
        System.out.println("clamped percent: " + progress.getPercent());
        // AN OBJECT VALIDATED AT CONSTRUCTION CAN NEVER BECOME INVALID
        Employee staff = new Employee("Grace", 90000.0);
        System.out.println(staff.getName() + " earns " + staff.getSalary());
        try {
            new Employee("  ", 100.0);
        } catch (IllegalArgumentException problem) {
            System.out.println("rejected: " + problem.getMessage());
        } System.out.println("live list type: " + describe(playlist.getTracks()));
        /*
            ACTUAL OUTPUT:

                balance: 65000
                rejected: Balance cannot be negative
                after deposit: 67000
                celsius: 21.5
                area: 16.0  square: true
                tracks: [Blue Monday, Bizarre Love Triangle]
                count:  2
                first:  Blue Monday
                playlist stayed unchanged: 2
                clamped percent: 100
                clamped percent: 0
                Grace earns 90000.0
                rejected: Name is required
                live list type: Collections$UnmodifiableRandomAccessList

            THE SEVEN RULES THAT MATTER MOST
            1) PRIVATE IS THE DEFAULT. Making a field public is close to
               permanent, since every caller then depends on its name.
               Changing it to private later breaks all of them.
            2) A SETTER IS A GATE, NOT A DOOR. Its value is the check
               inside it. A setter that only assigns adds ceremony
               without adding safety.
            3) OMITTING THE SETTER IS THE POINT. A getter with no setter
               is a read-only property, which is the cheapest immutable
               shape available.
            4) NOT EVERY PROPERTY NEEDS A FIELD. A computed getter
               derives the answer, which removes any chance of a cached
               value drifting out of sync.
            5) NEVER RETURN A MUTABLE FIELD. An unmodifiable view keeps
               the object intact for almost no cost. A getter that
               hands out your private list makes private a fiction.
            6) VALIDATE AT CONSTRUCTION, NOT ON EVERY SETTER. An object
               that cannot change after construction cannot enter an
               invalid state later.
            7) PUBLIC STATIC FINAL CONSTANTS ARE FINE. The value cannot
               change, so a constant offers the same guarantee as a
               private field with a getter.
        */
    }
}