객체 지향 프로그래밍

A change in one place that used to mean a change in fifty

• A program stores a customer's balance as a public number. Twenty routines read it and fifteen write it. Now the balance must never go negative.
• Without objects, that rule has to be added at fifteen places, and the day someone adds a sixteenth writer it is broken again.
• With objects, the balance is private and the only way to change it is a method that enforces the rule. There is one place to add it and no way round it.
• That is encapsulation 封装, and it is the reason object-oriented programming exists. This lesson is objects, classes 类, and the four pillars.

Objects and classes

• An object 对象 combines attributes, its data, with methods, the operations that act on that data. It is a unit of state and behaviour together.
• A class is the blueprint: it defines what attributes and methods every object of that kind will have. An object is an instance 实例 of a class, with its own values.
• One Taxi class, and each actual taxi is an object with its own registration and capacity.

Attributes above, methods below, and their visibility marked

Constructors, getters and setters

• A constructor 构造函数 is a special method that runs when an object is created, to set up its attributes to valid initial values.
• Because attributes are private, a class provides get methods to read a value and set methods to change one. A set method is where a rule such as "never negative" is enforced.
• That is what makes the private attribute worth having: the rule is enforced on every change, because there is no other route to the data.

CLASS Taxi
    PRIVATE Capacity : INTEGER
    PUBLIC PROCEDURE NEW(StartCapacity : INTEGER)
        Capacity ← StartCapacity
    ENDPROCEDURE
    PUBLIC FUNCTION GetCapacity() RETURNS INTEGER
        RETURN Capacity
    ENDFUNCTION
ENDCLASS

Pillar 1: encapsulation

• Encapsulation means an object's data is hidden behind its methods. Attributes are private; outside code uses the public methods.
• Two benefits, and the exam wants both: the object can enforce its own rules on every change, and the internal representation can be changed safely later, because no outside code depends on it.
• Store the balance in pounds today and in pennies tomorrow: every user of the class still calls GetBalance() and nothing outside breaks.

Pillar 2: inheritance

• Inheritance 继承 lets a subclass 子类 be defined in terms of a superclass 父类, taking all its attributes and methods and then adding its own or overriding them.
• It models an "is-a" relationship: a Manager is an Employee, so Manager inherits from Employee and adds a department.
• The benefit is that shared code is written once in the superclass, and a change to it reaches every subclass.

The shared part lives above; the differences live below

Pillars 3 and 4: polymorphism and abstraction

• Polymorphism 多态 means different objects respond to the same method call in their own way. Every Shape has an Area() method; Circle and Rectangle each implement it differently.
• Its value: code can loop over a list of shapes calling Area() on each, without knowing or caring which kind each one is. Add a Triangle class later and that loop needs no change at all.
• Abstraction 抽象 means showing a simple interface and hiding the complexity behind it: the caller of Area() need not know any geometry.

Worked example: name the pillar

Worked example: why OOP for a large system

A team has players; it is not a player

• Containment 包含 means an object holds another object as one of its attributes. In aggregation 聚合, the contained object can exist independently: a Team holds references to Player objects that can move to another team.
• Choose by the relationship: a Goalkeeper is a Player, so use inheritance; a Team has players, so use aggregation. A team inheriting a player's Kick() method is a design error, even if the team would enjoy taking a penalty.

Worked example: design a team without copying its players

Player object: name = "Sam"
Team object: Members = [reference to Sam's Player object]
Goalkeeper class: inherits the Player attributes and methods

Marks that slip away

You've got it