Mastering OOP: Encapsulation, Inheritance, and Polymorphism Explained

Object‑oriented programming (OOP) treats real‑world entities as objects. The three fundamental mechanisms—encapsulation, inheritance, and polymorphism—address distinct problems: protecting internal state, reducing duplicate code, and enabling flexible behavior.

Encapsulation: hide details, expose only what’s needed

The article defines encapsulation as hiding internal data and implementation behind a limited, safe interface. The milk‑tea shop analogy shows customers interacting only with ordering, payment, and pickup, while the kitchen’s recipes and processes remain hidden.

Key benefits include data safety (preventing illegal values such as negative prices or excessive sugar), ease of use (callers need not know how tea is made), and maintainability (changing the kitchen process does not affect the front‑desk code).

public class MilkTea {
    // hidden fields
    private String name;
    private int sugarLevel;
    private double price;
    private String teaBase;

    // constructor sets base info
    public MilkTea(String name, double price, String teaBase) {
        this.name = name;
        this.price = price;
        this.teaBase = teaBase;
        this.sugarLevel = 5; // default
    }

    // safe setter with validation
    public void setSugarLevel(int level) {
        if (level < 0 || level > 10) {
            System.out.println("糖量只能0-10分，设置失败");
            return;
        }
        this.sugarLevel = level;
    }

    public int getSugarLevel() { return sugarLevel; }
    public double getPrice() { return price; }

    public void make() {
        System.out.println("后厨开始制作：" + name);
        System.out.println("煮" + teaBase + "茶底 + 加" + sugarLevel + "分糖");
        System.out.println("摇茶、装杯、出餐");
    }
}

Common misconceptions are addressed: encapsulation is not about hiding everything, and merely adding getter/setter methods without validation does not constitute true encapsulation.

Inheritance: reuse parent code and extend it

Inheritance lets a subclass automatically acquire the parent class’s fields and methods, avoiding repetitive code. The analogy describes a base drink class that contains shared attributes (name, price, capacity) and methods (fillCup, make). Specific drinks such as PearlMilkTea or FruitTea inherit these and add their own features.

public class BaseDrink {
    protected String name;
    protected double price;
    protected int capacity; // ml

    public void fillCup() {
        System.out.println("装入" + capacity + "ml杯子");
    }

    public void make() {
        System.out.println("制作基础饮品：" + name);
        fillCup();
    }
}

public class PearlMilkTea extends BaseDrink {
    private String pearlSize; // 大珠/小珠
    public void addPearl() {
        System.out.println("加入" + pearlSize + "珍珠");
    }
    @Override
    public void make() {
        System.out.println("制作珍珠奶茶：" + name);
        System.out.println("煮红茶底 + 加奶");
        addPearl();
        fillCup();
        System.out.println("摇茶15秒");
    }
}

public class FruitTea extends BaseDrink {
    private String fruitMix;
    @Override
    public void make() {
        System.out.println("制作水果茶：" + name);
        System.out.println("切水果：" + fruitMix);
        System.out.println("加绿茶底 + 加冰");
        fillCup();
    }
}

Core inheritance rules covered: single inheritance only, public/protected members are inherited, private members stay hidden, method overriding requires identical signatures, and a practical depth limit of three levels.

Benefits include massive reduction of duplicate code and centralized updates—changing a price or adding a packaging fee in the base class instantly propagates to all drinks. Pitfalls such as inheriting for unrelated functionality (e.g., a cat inheriting from an alarm clock) are warned against.

Polymorphism: same command, different behavior

Polymorphism allows a single method call to produce different results depending on the actual object type. The article stresses three prerequisites: a parent‑child relationship, method overriding, and a parent‑type reference pointing to a child object.

public class MilkTeaShop {
    /**
     * Unified ordering method; accepts any BaseDrink subclass.
     */
    public void orderDrink(BaseDrink drink) {
        System.out.println("===== 顾客点单 =====");
        drink.make(); // dynamic dispatch
        System.out.println("制作完成，价格：" + drink.getPrice() + "元");
    }

    public static void main(String[] args) {
        MilkTeaShop shop = new MilkTeaShop();
        BaseDrink milkTea = new PearlMilkTea();
        milkTea.setName("招牌珍珠奶茶");
        milkTea.setPrice(16);
        BaseDrink fruitTea = new FruitTea();
        fruitTea.setName("满杯鲜橙");
        fruitTea.setPrice(18);
        shop.orderDrink(milkTea);
        shop.orderDrink(fruitTea);
    }
}

The output demonstrates that the same orderDrink method drives completely different preparation steps for pearl milk tea and fruit tea, illustrating open‑closed principle compliance.

Common mistakes highlighted: confusing method overloading with polymorphism and forcing inheritance solely to achieve polymorphism.

One‑sentence relationship recap

Encapsulation secures an object’s internal state, inheritance shares common code, and polymorphism leverages that shared structure to enable flexible, extensible behavior without modifying existing code.