PHP OOP

$x instanceof Foo is true when $x is an object of class Foo, of a subclass, or of a class implementing the interface Foo — it walks the whole hierarchy, not just the exact class. On a non-object it returns false rather than throwing.

An interface is a pure contract — method signatures and constants, no state — and a class may implement many of them at once. An abstract class is a partial base with properties, a constructor and concrete methods, but a class extends only one.

protected members are visible in the declaring class and in every subclass. private members are visible only inside the declaring class, so a child cannot touch the parent's private property and may redeclare its own of the same name.

A static method belongs to the class, is called as Foo::bar() without an object, has no $this and can touch only static members. An instance method is called on an object, receives $this and reads that object's properties.

A class constant is fixed, cannot be reassigned and is read as Foo::NAME. A static property is a single mutable slot shared by every instance, read as Foo::$name. Use a constant for a value that never changes; a static property is shared mutable state.

Putting a visibility modifier on a constructor parameter — __construct(private Logger $log) — declares the property and assigns the argument in one step, removing the declare-then-$this->log = $log boilerplate. The result is an ordinary typed property.

A pure enum's cases are singletons carrying only a name. A backed enum declares a scalar type — enum Status: string — so each case also has a value and gains from()/tryFrom() to map a scalar back to a case. Back it when the value is persisted.

PHP has single inheritance of implementation: a class extends one parent, so two parents can never supply conflicting method bodies. Interfaces carry no bodies and no state, so implements B, C merely merges contracts and cannot conflict.

A readonly typed property can be written exactly once, from inside the declaring class — normally the constructor. Any later write throws an Error, even from within the class. It is shallow: the reference is frozen, but the object it points to stays mutable.

A trait is a bag of methods and properties copied into a class at compile time, letting unrelated classes share an implementation without a common parent. It is horizontal reuse: a trait is not a type, is never instantiated, and instanceof never matches it.

self:: binds at compile time to the class the code is written in, so an inherited method always hits the parent's version. static:: is late static binding — it resolves at runtime to the class actually called, so a parent's new static() reached via Child::create() builds a Child.

PHP resolves a method call at runtime, so $x->pay() works on any object that happens to have pay() — that is duck typing, and polymorphism needs nothing more. Typing the parameter as an interface makes the contract explicit and checked at the boundary, turning a deep runtime Error into a TypeError at the door.

Every chainable method mutates the builder and returns $this, typed static so a subclass keeps chaining — that is what lets calls be strung together. toSql() is the terminal method: it returns the assembled string, not the builder, so the chain ends there.

Magic methods are __-prefixed hooks the engine calls for you. __get/__set fire only when a property is undeclared or inaccessible from the calling scope; __call fires only when the method is missing. Others include __toString, __invoke and __clone.

__get fires only when the property is undeclared, unset, or inaccessible from the calling scope — a declared, initialised public property never reaches it. Magic properties are invisible to static analysis and IDEs, cost a method call per access, and need __isset for isset() to work.

Make __construct private so new is blocked, keep the instance in a private static slot, and hand it out from getInstance(). Then close two back doors: a private __clone() makes clone fatal, and __wakeup() must throw, since unserialize() rebuilds an object without the constructor.

Two traits declaring the same method is a fatal error unless the use block disambiguates: insteadof picks which trait's method wins, and as gives the loser an alias so it stays reachable. as can also change the visibility of the imported method.

It splits read visibility from write visibility: public private(set) int $total is readable anywhere but writable only inside the class. Unlike readonly, the class may keep changing it — the limit is on who writes, not how often. PHP 8.4 added it; 8.5 extended it to static properties.

PHP 8.5 turned clone into a function too: clone(object $object, array $withProperties = []): object. Called inside the class as clone($this, ['statusCode' => $code]), it copies the object and applies those properties during the clone — the one moment a readonly field may be re-set.

A hook attaches get/set logic to a declared property, so reading $obj->total runs code while the member stays an ordinary typed property. Unlike __get, the property really exists and stays visible to static analysis, and the hook fires on every access, not only an inaccessible one.

Pin behaviour first: characterization tests driven through the HTTP entry point, so any break is visible. Then carve seams — wrap each global function or superglobal read behind a thin class with an interface, and leave the old function as a one-line adapter so existing call sites keep working. Convert leaf-first: extract a service, inject its collaborators, delete the global.

A trait is copy-pasted into the using class at compile time, so its members become that class's own: a renamed property is a silent break for anyone touching $meta, and a class that already declares its own toArray() wins over the trait's and never picks up the new field. Stage it — new behaviour under a new name, the old member kept as a deprecated alias, removed only in a major release.