Objects, messages and the principles

you stopped caring which of the three implementations you had, and the code got shorter in every caller.

Abstraction

the type on the field is the interface, and the only line that names the concrete class is the one that builds it.

Programming to an interface

the base class does half the job and leaves a method for you to fill in, and you cannot instantiate it on its own.

Abstract class

the same call site does three different things depending on what was passed in, and there is no branch anywhere.

Polymorphism

the method that runs is chosen by what the object actually is at that moment, not by the type the variable was declared with.

Dynamic dispatch

the subclass replaces the parent's version of a method, and every existing caller silently starts getting the new one.

Method overriding

there are four methods with the same name and different parameters, and the compiler picks one before the program ever runs.

Method overloading

you got twenty methods you never asked for along with the one you wanted, and you cannot give any of them back.

Inheritance

you said it out loud — a Stack is a List — and it sounded fine right up until someone called insert in the middle of it.

Is-a vs has-a

you deleted the order and the line items went with it, but the customer stayed, because only one of them belonged to it.

Aggregation vs composition

the method body is one line that calls the same method on a field, and that is the whole class's job for that method.

Delegation

a harmless-looking change inside the parent broke three subclasses in another repository that you had never seen.

Fragile base class

adding a third colour to a hierarchy that already had four shapes meant writing twelve classes instead of one.

Subclass explosion

the class picks up three methods from somewhere that is not its parent, and finding where they came from takes a search.

Mixin

two parents both define the method and the language has to pick one, and which one is a rule you had to look up.

Diamond problem

nothing declared a shared type anywhere, and the code worked because both objects happened to have the method.

Duck typing

the object had every method the interface asked for and the compiler still refused it, because it had not said it implemented it.

Nominal vs structural typing

a list of cats would not go where a list of animals was expected, and the compiler was right even though it felt wrong.

Covariance and contravariance

someone rejected the pull request citing a five-letter acronym, and only two of the five letters were actually about the problem.

SOLID

adding the fourth payment method meant editing the same switch statement for the fourth time.

Open–closed principle

the subclass threw on a method the parent promised, and every caller written against the parent was suddenly wrong.

Liskov substitution principle

you implemented an eleven-method interface to get at one of them and threw not-implemented from the other ten.

Interface segregation principle

the method states what must be true when you call it and what will be true when it returns, and it checks both.

Design by contract

there is a rule that is true of the object at every moment a caller can see it, and the constructor is where it starts being true.

Class invariant

the thing most likely to change is the only thing behind the interface, and nobody outside can name it.

Information hiding

every field is private with a public pair of methods around it, which is the same as public with more typing.

Getters and setters

the caller pulled three fields out, decided something, and wrote one back — a decision the object should have made itself.

Tell, don't ask

you put it in a set, put an identical one in, and the set had two of them.

Object equality

you passed it to a function, the function changed it, and your copy changed too — or it did not, and you had to know which.

Reference vs value semantics

you handed the object a list, changed your list afterwards, and the object's state changed with it.

Defensive copy

two pieces of code have to change together, and you can say precisely what kind of agreement binds them.

Connascence

the interface is three methods and the implementation is two thousand lines, and that ratio is the point.

Deep module