The document discusses inheritance in PHP, including vertical inheritance using abstract classes and interfaces, and horizontal inheritance using traits. Vertical inheritance follows an "is-a" relationship where a child class inherits from a parent class. Abstract classes and interfaces are used for vertical inheritance. Traits are used for horizontal inheritance and allow code reuse without extending classes. The document provides examples of each and discusses when to use vertical vs horizontal inheritance as well as considerations around complexity, testability, and leveraging inheritance in projects.

1. Inheritance: Vertical
or Horizontal?
Mark Niebergall
https://joind.in/talk/77415

2. About Mark Niebergall
• PHP since 2005
• Masters degree in MIS
• Senior Software Engineer
• Drug screening project
• UPHPU President
• CSSLP, SSCP Certified and SME
• Drones, fishing, skiing, father, husband

3. About Mark Niebergall
• Twitter @mbniebergall
• phpug.slack.com
• phpchat.slack.com
• phpcommunity.slack.com
• utos.slack.com

5. Inheritance: Vertical or
Horizontal?

8. Inheritance: Vertical or
Horizontal?
• Objective
- Solid understanding of how inheritance works in PHP
- Know when and how to use inheritance in PHP
- Able to apply material to current projects

9. Inheritance: Vertical or
Horizontal?
• The Problem
• Vertical inheritance
• Horizontal inheritance
• Applied use
• Considerations

10. The Problem

11. The Problem
• Copy and paste

12. The Problem
• Procedural code
- Simple
- Efficient

13. The Problem
• Procedural code
- Lacks organization
- Difficult to scale

14. The Problem
• Functions
- Reusable
- Some organization
- No grouping

15. The Problem
• Concrete Class
- Basic code organization with classes
- Concrete class can be instantiated

16. The Problem
• Concrete Class
- Properties
- Constants
- Methods
- Magic methods

17. The Problem
• Concrete Class
- class X {
const SOME_THING = ‘Thing’;
protected $flag = true;
private function secretStuff() {…}
public function doSomething() {…}
}

18. The Problem
• Concrete Class
- Problems by themselves
‣ Code reuse, duplication
‣ Code enforcement
‣ Code organization

19. The Problem
• Concrete Class
- Problems by themselves
‣ Classes can become bloated
‣ No separation of services
‣ Complicated code

20. The Problem
• Concrete Class
- Problems by themselves
‣ Hard to debug
‣ Testability goes down

21. The Problem
• Concrete Class
- Some problems solved with Dependency Injection (DI)
‣ public function __construct(Dependency $d) {
$this->dependency = $d;
}
public function setThing(Thing $thing) {
$this->thing = $thing;
}
public function __set($key, $value) {
if ($value instanceof Thing) {$this->thing = $value;}
}

22. The Problem
• Concrete Class
- Problems solved with inheritance

23. The Problem
• Concrete Class
- Composition over Inheritance
- Inheritance over Composition

24. Vertical Inheritance

25. Vertical Inheritance
• Family
- Olsen line
‣ Stature
‣ Stubbornness
- Niebergall
‣ Engineering

26. Vertical Inheritance
• Service provider
- Education
‣ University
- Utilities
‣ Garbage collection

27. Vertical Inheritance
• Animal
- Pet
‣ Dog
• German Shepard
‣ Cat
• Short-hair

28. Vertical Inheritance
• Abstract
• Interface

29. Vertical Inheritance
• Abstract
- X is a Y

30. Vertical Inheritance
• Abstract
- X is a Y
‣ Mark is a Niebergall
‣ Garbage Collection is a Utility
‣ Cat is a Pet

31. Vertical Inheritance
• Abstract
- X is a Y
‣ Pet is an Animal
• Cat is a Pet
• Short-hair is a Cat

32. Vertical Inheritance
• Abstract
- abstract class Animal {…}
‣ abstract class Pet extends Animal {…}
• abstract class Cat extends Pet {…}
• class class ShortHair extends Cat {…}

33. Vertical Inheritance
• Abstract
- abstract class Animal {
abstract public function breathe(Lungs $lungs) : Lungs;
private function beAlive() : Animal {…}
}
abstract class Cat {
public function breathe(Lungs $lungs) : Lungs {…}
final protected function purr() {…}
}

34. Vertical Inheritance
• Abstract
- class ShortHair {
public function takeNap() {
$this->goToSleep();
}
public function getPetted() {
$this->purr();
}
}

35. Vertical Inheritance
• Abstract
- Extend only one class at a time
- Can have multiple levels of inheritance
- Can not instantiate abstract

36. Vertical Inheritance
• Abstract
- Abstract functions must be implemented
- Signatures must match

37. Vertical Inheritance
• Abstract
- Benefits
‣ Reduce code duplication
‣ Code organization
‣ Logical flow

38. Vertical Inheritance
• Abstract
- Push code up the vertical inheritance chain as far as it
logically makes sense

39. Vertical Inheritance
• Abstract
- Questions?

40. Vertical Inheritance
• Interface

41. Vertical Inheritance
• Interface
- interface X {
const SOME_VALUE = 123;
public function processThing(Thing $thing) : Thing;
}

42. Vertical Inheritance
• Interface
- Object interface

43. Vertical Inheritance
• Interface
- Connect two things together
‣ User interface
‣ Driver and vehicle
‣ Controller

44. Vertical Inheritance
• Interface
- Contract defining what needs to happen but not how
- Contract between concept and implementation

45. Vertical Inheritance
• Interface
- Define interaction requirements
- Leaves implementation to be handled in classes
- Can not be instantiated

46. Vertical Inheritance
• Interface
- Class can implement multiple interfaces
- Can be used with abstract and class
- Can not be used with a trait
‣ RFC in discussion about that

47. Vertical Inheritance
• Interface
- interface X {…}
- class A implements X {…}
- abstract class Z implements V, W, X {…}

48. Vertical Inheritance
• Interface
- Interface method signatures are defined
- No method content
- Method signature must match when implemented
- Methods must be implemented
- Interface can extend one or many interfaces

49. Vertical Inheritance
• Interface
- All methods must be public
- Properties are not allowed
- Can have public constants

50. Vertical Inheritance
• Interface
- Light from different sources
- interface LightInterface {
const LIGHT_SPEED = 299792458;
public function shine(Energy $energy) : Light;
public function travel(float $x, float $y, float $z);
}

51. Vertical Inheritance
• Interface
- Laptop computer
‣ USB
‣ Video and audio output
‣ Card reader

52. Vertical Inheritance
• Interface
- interface Power {
public function receivePower(Volt $v, Current $i);
}
interface Usb extends Power{
public function transferData(Data $data);
}
interface Hdmi {
public function transmitVideo(Video $video);
}
abstract class Laptop implements Usb, Hdmi {…}

53. Vertical Inheritance
• Interface
- Underwater pets
- Auditing
- Authentication methods
- Request and response
‣ Middleware

54. Vertical Inheritance
• Interface
- Questions?

55. Vertical Inheritance

56. Horizontal Inheritance

57. Horizontal Inheritance
• Personal characteristics
- Hair color
- Personality

58. Horizontal Inheritance
• Underwater creature
- Fish
- Mammal
- Reptile

59. Horizontal Inheritance
• Trait

60. Horizontal Inheritance
• Trait
- trait M {
protected $thing;
public function doThing(Thing $thing) : Thing {…}
}
class X {
use M;
protected function something(Thing $thing) : Thing {
return $this->doThing($this->thing($thing);
}
}

61. Horizontal Inheritance
• Trait
- Promotes code reuse
- Unrestricted by inheritance hierarchies
- Available since PHP 5.4.0

62. Horizontal Inheritance
• Trait
- Pull in grouped functionality
- Multiple inheritance horizontally
- Similar to a concrete class but cannot be instantiated

63. Horizontal Inheritance
• Trait
- “Aware” of a concept
‣ ContainerAware
‣ AuditAware
‣ AdapterAware

64. Horizontal Inheritance
• Trait
- Can be used alongside abstracts and interfaces in a class
- Class can use multiple traits
- Used in abstract class or concrete class
- Can have properties and methods

65. Horizontal Inheritance
• Trait
- Can not be instantiated
- Can not implement an interface
- Can not extend a class

66. Horizontal Inheritance
• Trait
- Methods and properties in trait(s) become available to
class
- Traits can not have class constants

67. Horizontal Inheritance
• Trait
- Order of precedence
‣ Class and trait method naming collisions
• Current class
• Trait
• Parent class

68. Horizontal Inheritance
• Trait
- abstract class TheBase {
public function hello() { echo ‘Hello from the base.’; }
}
trait TheTrait {
public function hello() { echo ‘Hello from the trait.’; }
}
class TheClass extends TheBase {
use TheTrait;
public function hello() { echo ‘Hello from the class.’; }
}

69. Horizontal Inheritance
• Trait
- trait TheTrait {
public function hello() { echo ‘Hello from the trait.’; }
}
class TheClass extends TheBase {
use TheTrait {
TheTrait::hello as helloTrait;
};
public function hello() { echo ‘Hello from the class.’; }
public function helloBase() { parent::hello(); }
}

70. Horizontal Inheritance
• Trait
- Naming conflicts must be resolved
‣ Fatal error if not

71. Horizontal Inheritance
• Trait
- ‘insteadof’ to use just one
- ‘as’ to alias and allow using more than one

72. Horizontal Inheritance
• Trait
- class Thing {
use TraitA, TraitB {
TraitA::doThing insteadof TraitB;
TraitA::doOtherThing as doOtherThingA;
TraitB::doOtherThing as doOtherThingB;
}
}
$thing->doThing();
$thing->doOtherThingA();
$thing->doOtherThingB();

73. Horizontal Inheritance
• Trait
- Can change visibility modifier
‣ use Trait { methodName as protected; }
‣ class Thing {
use Trait {
Trait::doThing as public;
}
}
$thing->doThing();

74. Horizontal Inheritance
• Trait
- Traits can have properties
- Class properties must match visibility and initial value if
same name
‣ trait X {
public $something = ‘something’;
}
class Z {
use X;
public $something = ‘something’;
}

75. Horizontal Inheritance
• Trait
- Traits can use other traits
‣ trait Thing {
use ThingA, ThingB;
}

76. Horizontal Inheritance
• Trait
- Traits can have abstract methods
‣ trait Thing {
abstract protected function doSomething();
}
class X {
use Thing;
protected function doSomething() {
echo ‘doing something’;
}
}

77. Horizontal Inheritance
• Trait
- Traits can have static methods
‣ trait Thing {
public static function anotherThing();
}
class X { use Thing; }
X::anotherThing();

78. Horizontal Inheritance
• Trait
- Recap
‣ Overcome multiple inheritance problem
‣ Horizontal inheritance

79. Horizontal Inheritance

80. Applied Use

81. Applied Use
• Vertical or Horizontal inheritance?
- Vertical: abstract, interface
- Horizontal: trait

82. Applied Use
• Vertical or Horizontal inheritance?
- Vertical is heavily used
- Most concrete classes extend an abstract in projects

83. Applied Use
• Vertical or Horizontal inheritance?
- My experience
‣ Most use vertical
‣ Few use horizontal

84. Applied Use
• Vertical or Horizontal inheritance?
- My experience with concrete classes
‣ Most extend an abstract
‣ Some implement an interface
‣ Few use trait

85. Considerations

86. Considerations
• Open discussion

87. Considerations
• Why need for abstracts, interfaces, and traits

88. Considerations
• Benefits of using combinations of abstracts, interfaces, and
traits

89. Considerations
• Traits vs Dependency Injection

90. Considerations
• Role of Dependency Injection

91. Considerations
• Code complexity
- How far to take abstraction
- Readability
- Code consolidation

92. Considerations
• Code testability
- Unit tests
- Testing abstract instead of concrete implementation

93. Considerations
• Evaluating current projects
- Static code analysis
- Leverage inheritance

94. Questions?
• Please rate this talk
- https://joind.in/talk/77415

95. Sources
• https://en.wikipedia.org/wiki/Convair_B-36_Peacemaker
• http://www.boeing.com/resources/boeingdotcom/commercial/737ng/assets/images/
marquee.jpg
• https://www.gannett-cdn.com
• http://pop.h-cdn.co/assets/15/20/1600x800/landscape-1431629947-marty-delorean.jpg
• http://www.sbs.com.au/movies/sites/sbs.com.au.film/files/styles/full/public/Dynamite_704.jpg?
itok=_XPK3CbV&mtime=1404453609
• http://latimesblogs.latimes.com/.a/6a00d8341c630a53ef01310f8dd9fe970c-pi
• https://i.pinimg.com/474x/f8/32/b4/f832b4c3b92cc4ccd19a285f68a4197a--merlin-olsen-little-
houses.jpg
• php.net