Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Fundamental OOP in PHP

Fundamental OOP in PHP

PHP as a language supports several programming paradigms including procedural, object-oriented, and, to some extent, functional programming. In this tutorial we will talk about the fundamentals of object-oriented design and how we can apply then using PHP. Specifically, we will cover the power of interfaces, the differences between inheritance and composition, dependency injection and inversion, and the idea of the SOLID principles. Regardless of your experience with PHP and OOP you should walk out of this tutorial with a better understanding of how to apply these ideas to your projects.

Jeff Carouth

May 19, 2015
Tweet

More Decks by Jeff Carouth

Other Decks in Programming

Transcript

  1. Agenda 1. OOP and OOD 2. Dependencies and coupling 3.

    Creating interfaces 4. Sharing Behavior through Inheritance 5. Sharing Behavior through Composition 6. The SOLID Principles
  2. We live our lives in procedural fashion. That’s what makes

    procedural programming seem so natural.
  3. In a procedural language, you have access to some data

    types, you can create variables, and you can define procedures to act upon or in response to those variables.
  4. // Procedural Shopping Cart $product = array( 'id' => 5634,

    'name' => 'Widget', 'price' => 12.99 );
  5. // Procedural Shopping Cart $product = array( 'id' => 5634,

    'name' => 'Widget', 'price' => 12.99 ); $customer = array( 'id' => 8934512, 'email' => '[email protected]' );
  6. // Procedural Shopping Cart $product = array( 'id' => 5634,

    'name' => 'Widget', 'price' => 12.99 ); $customer = array( 'id' => 8934512, 'email' => '[email protected]' ); $cart = array();
  7. // Procedural Shopping Cart $product = array( 'id' => 5634,

    'name' => 'Widget', 'price' => 12.99 ); $customer = array( 'id' => 8934512, 'email' => '[email protected]' ); $cart = array(); function add_item_to_cart($cart, $item) { if (!isset($cart['items'])) { $cart['items'] = array(); } $cart['items'][] = $item; return $cart; }
  8. function complete_purchase_of_cart($cart, $customer) { $order = array( 'line_items' => array(),

    'customer_id' => $customer['id'], 'total' => 0.00, ); foreach ($cart['items'] as $item) { $order['line_items'][] = $item; $order['total'] += $item['price']; } mail( $customer['email'], 'Order of ' . count($order['line_items']) . ' items complete.’ ); return $order; }
  9. // Procedural Shopping Cart $product = array( 'id' => 5634,

    'name' => 'Widget', 'price' => 12.99 ); $customer = array( 'id' => 8934512, 'email' => '[email protected]' ); $cart = array(); function add_item_to_cart($cart, $item) { /* ... */ } function complete_purchase_of_cart($cart, $customer) { /* ... */ }
  10. // Procedural Shopping Cart $product = array( 'id' => 5634,

    'name' => 'Widget', 'price' => 12.99 ); $customer = array( 'id' => 8934512, 'email' => '[email protected]' ); $cart = array(); function add_item_to_cart($cart, $item) { /* ... */ } function complete_purchase_of_cart($cart, $customer) { /* ... */ } $cart = add_item_to_cart($cart, $item); $order = complete_purchase_of_cart($cart, $customer);
  11. // Object-Oriented Shopping Cart class Product { private $id; private

    $name; private $price; public function __construct($id, $name, $price) { $this->id = $id; $this->name = $name; $this->price = $price; } }
  12. // Object-Oriented Shopping Cart class Cart { private $items; public

    function __construct() { $items = array(); } public function addItem($item) { $this->items[] = $item; } public function sumItemPrices() { foreach ($this->items as $item) { $sum += $item->getPrice(); } } }
  13. // Object-Oriented Shopping Cart class Customer { private $id; private

    $email; public function __construct($id, $email) { $this->id = $id; $this->email = $email; } }
  14. // Object-Oriented Shopping Cart class Order { private $items; private

    $customer; public function __construct($cart, $customer) { $this->items = $cart; $this->customer = $customer; } public function getTotal() { return $this->items->sumItemPrices(); } }
  15. // Object-Oriented Shopping Cart class OrderProcessor { public function completeOrder($order)

    { mail( $customer['email'], 'Order of ' . $order->getNumberItems() . ' items complete.’ ); } }
  16. // Object-Oriented Shopping Cart class Order { private $items; private

    $customer; public function __construct($cart, $customer) { $this->items = $cart; $this->customer = $customer; } public function getTotal() { return $this->items->sumItemPrices(); } }
  17. // Object-Oriented Shopping Cart class Cart implements Countable { private

    $items; public function __construct() { $items = array(); } public function addItem($item) { /* ... */ } public function sumItemPrices() { /* ... */ } public function count() { return count($this->items); } }
  18. // Object-Oriented Shopping Cart class Order { private $items; private

    $customer; public function __construct($cart, $customer) { $this->items = $cart; $this->customer = $customer; } public function getTotal() { /* ... */ } public function getNumberItems() { return count($this->items); } }
  19. // Object-Oriented Shopping Cart class OrderProcessor { public function completeOrder($order)

    { mail( $customer['email'], 'Order of ' . $order->getNumberItems() . ' items complete.’ ); } }
  20. // Object-Oriented Shopping Cart $product = new Product(5634, 'Widget', 12.99)

    $customer = new Customer(8934512, '[email protected]'); $cart = new Cart(); $cart->addItem($product);
  21. // Object-Oriented Shopping Cart $product = new Product(5634, 'Widget', 12.99)

    $customer = new Customer(8934512, '[email protected]'); $cart = new Cart(); $cart->addItem($product); $order = new Order($cart, $customer);
  22. // Object-Oriented Shopping Cart $product = new Product(5634, 'Widget', 12.99)

    $customer = new Customer(8934512, '[email protected]'); $cart = new Cart(); $cart->addItem($product); $order = new Order($cart, $customer); $orderProcessor = new OrderProcessor(); $orderProcessor->completeOrder($order);
  23. // Representing a bank account class Account { private $balance;

    public function __construct($startingBalance = 0.00) { $this->balance = $startingBalance; } public function getBalance() { return $this->balance; } public function setBalance($newBalance) { $this->balance = $newBalance; } }
  24. $account = new Account(); $currentBalance = $account->getBalance(); $account->setBalance($currentBalance + 3507.45);

    var_dump($account); /** output **/ object(Account)#1 (1) { ["balance":"Account":private]=> float(3507.45) }
  25. function deposit($account, $amount) { $newBalance = $account->getBalance() + $amount; $account->setBalance($newBalance);

    } $account = new Account(3507.45); deposit($account, 492.55); var_dump($account);
  26. function deposit($account, $amount) { $newBalance = $account->getBalance() + $amount; $account->setBalance($newBalance);

    } $account = new Account(3507.45); deposit($account, 492.55); var_dump($account); /** output **/ object(Account)#1 (1) { ["balance":"Account":private]=> float(4000) }
  27. function withdraw($account, $amount) { $newBalance = $account->getBalance() - $amount; $account->setBalance($newBalance);

    } $account = new Account(4000.00); withdraw($account, 4001.99); var_dump($account);
  28. function withdraw($account, $amount) { $newBalance = $account->getBalance() - $amount; $account->setBalance($newBalance);

    } $account = new Account(4000.00); withdraw($account, 4001.99); var_dump($account); /** output **/ object(Account)#1 (1) { ["balance":"Account":private]=> float(-1.9899999999998) }
  29. function better_withdraw($account, $amount) { if ($amount > $account->getBalance()) { throw

    new Exception( 'Cannot withdrawal '.$amount.' from account with only ‘ .$account->getBalance() ); } $account->setBalance($account->getBalance() - $amount); } $account = new Account(4000.00); better_withdraw($account, 4001.00);
  30. function better_withdraw($account, $amount) { if ($amount > $account->getBalance()) { throw

    new Exception( 'Cannot withdrawal '.$amount.' from account with only ‘ .$account->getBalance() ); } $account->setBalance($account->getBalance() - $amount); } $account = new Account(4000.00); better_withdraw($account, 4001.00); /** output **/ Fatal error: Uncaught exception 'Exception' with message 'Cannot withdrawal 4001 from account with only 4000'
  31. // Representing a bank account class Account { private $balance;

    public function __construct($startingBalance = 0.00) { $this->balance = $startingBalance; } public function getBalance() { return $this->balance; } public function setBalance($newBalance) { $this->balance = $newBalance; } }
  32. // Representing a bank account class Account { /* …snip…

    */ public function deposit($amount) { $this->balance += $amount; } public function withdraw($amount) { if ($amount > $this->balance) { throw new Exception( 'Cannot withdrawal ‘.$amount .’ from account with only ‘.$this->balance ); } $this->balance -= $amount; } }
  33. Dependencies are the other objects, resources, or functions any given

    object uses to accomplish its responsibility.
  34. class Bank { public function __construct() { $this->accountRepository = new

    AccountRepository(); } public function openAccount($startingBalance = 0.00) { $accountNumber = $this->accountRepository->generateAccountNumber(); $account = new Account($accountNumber, $startingBalance); $this->accountRepository->add($account); return $account; } }
  35. class AccountRepository { private $accounts; public function __construct($accounts = array())

    { $this->accounts = $accounts; } public function add($account) { $this->accounts[$account->getAccountNumber()] = $account; } public function generateAccountNumber() { do { $accountNumber = rand(1000, 5000); } while(array_key_exists($accountNumber, $this->accounts)); return $accountNumber; } }
  36. class Account { private $accountNumber; private $balance; public function __construct($accountNumber,

    $balance = 0.00) { $this->accountNumber = $accountNumber; $this->balance = $balance; } public function getAccountNumber() { return $this->accountNumber; } }
  37. $bank = new Bank(); $account = $bank->openAccount(50.00); var_dump($account); /** output

    **/ object(Account)#3 (2) { ["accountNumber":"Account":private]=> int(4481) ["balance":"Account":private]=> float(50) }
  38. $bank = new Bank(); $account = $bank->openAccount(50.00); var_dump($account); /** output

    **/ object(Account)#3 (2) { ["accountNumber":"Account":private]=> int(4481) ["balance":"Account":private]=> float(50) } $anotherAccount = $bank->openAccount(1435.56); var_dump($anotherAccount);
  39. $bank = new Bank(); $account = $bank->openAccount(50.00); var_dump($account); /** output

    **/ object(Account)#3 (2) { ["accountNumber":"Account":private]=> int(4481) ["balance":"Account":private]=> float(50) } $anotherAccount = $bank->openAccount(1435.56); var_dump($anotherAccount); /** output **/ object(Account)#4 (2) { ["accountNumber":"Account":private]=> int(2504) ["balance":"Account":private]=> float(1435.56) }
  40. class Bank { public function __construct() { $this->accountRepository = new

    AccountRepository(); } public function openAccount($startingBalance = 0.00) { $accountNumber = $this->accountRepository->generateAccountNumber(); $account = new Account($accountNumber, $startingBalance); $this->accountRepository->add($account); return $account; } }
  41. class Bank { public function __construct(AccountRepository $accountRepository) { $this->accountRepository =

    $accountRepository; } public function openAccount($startingBalance = 0.00) { $accountNumber = $this->accountRepository->generateAccountNumber(); $account = new Account($accountNumber, $startingBalance); $this->accountRepository->add($account); return $account; } }
  42. class AccountRepository { private $accounts; public function __construct($accounts = array())

    { $this->accounts = $accounts; } public function add($account) { $this->accounts[$account->getAccountNumber()] = $account; } public function generateAccountNumber() { do { $accountNumber = rand(1000, 5000); } while(array_key_exists($accountNumber, $this->accounts)); return $accountNumber; } }
  43. class InMemoryAccountRepository implements AccountRepository { private $accounts; public function __construct($accounts

    = array()) { $this->accounts = $accounts; } public function add($account) { $this->accounts[$account->getAccountNumber()] = $account; } public function generateAccountNumber() { do { $accountNumber = rand(1000, 5000); } while(array_key_exists($accountNumber, $this->accounts)); return $accountNumber; } }
  44. $bank = new Bank(new InMemoryAccountRepository()); $account = $bank->openAccount(50.00); var_dump($account); object(Account)#3

    (2) { ["accountNumber":"Account":private]=> int(3305) ["balance":"Account":private]=> float(50) } $anotherAccount = $bank->openAccount(1435.56); var_dump($anotherAccount); object(Account)#4 (2) { ["accountNumber":"Account":private]=> int(2581) ["balance":"Account":private]=> float(1435.56) }
  45. Simply put an interface is the collection of methods an

    object exposes to be interacted with.
  46. // Representing a bank account class Account { public function

    __construct($startingBalance = 0.00) { /* …snip… */ } public function getBalance() { /* …snip… */ } public function deposit($amount) { /* …snip… */ } public function withdraw($amount) { /* …snip… */ } }
  47. // Account Transactions Ledger class Account { private $balance; private

    $transactions; public function __construct($balance = 0.00) { $this->balance = $balance; $this->transactions = array(); } /* snip */ }
  48. // Account Transactions Ledger class Account { /* snip */

    public function deposit($amount) { $this->transactions[] = 'Deposited '.$amount; $this->balance += $amount; } public function withdraw($amount) { if ($amount > $this->balance) { $this->transactions[] = 'Failed to withdraw '.$amount.' when balance '. $this->balance; throw new Exception('Cannot withdraw '.$amount.' from balance '.$this- >balance); } $this->transactions[] = 'Withdrew '.$amount; $this->balance -= $amount; } }
  49. // Account Transactions Ledger class Account { /* snip */

    public function getTransactions() { return $this->transactions; } public function getBalance() { return $this->balance; } }
  50. // Account Transactions Ledger class Account { public function __construct($balance

    = 0.00) { /* snip */ } public function deposit($amount) { /* snip */ } public function withdraw($amount) { /* snip */ } public function getTransactions() { /* snip */ } public function getBalance() { /* snip */ } }
  51. // Account Transactions Ledger $account = new Account(10.00); $account->withdraw(2.86); $account->deposit(758.34);

    $account->withdraw(700.00); try { $account->withdraw(66.00); } catch (Exception $e) { //do nothing because I'm bad and I should feel bad } $account->withdraw(50.00); var_dump($account->getTransactions());
  52. // Account Transactions Ledger var_dump($account->getTransactions()); /** output **/ array(5) {

    [0]=> string(13) "Withdrew 2.86" [1]=> string(16) "Deposited 758.34" [2]=> string(12) "Withdrew 700" [3]=> string(40) "Failed to withdraw 66 when balance 65.48" [4]=> string(11) "Withdrew 50" }
  53. An Interface is a mechanism available in PHP to indicate

    that an object which implements the interface abides by the contract it specifies.
  54. The most important job of an interface in object-oriented design

    is to specify the role or roles an object fulfills.
  55. // Account Transactions Ledger interface AcceptsDeposits { public function deposit($amount);

    } class Account implements AcceptsDeposits { public function deposit($amount) { $this->transactions[] = 'Deposited '.$amount; $this->balance += $amount; } }
  56. // Account with Transactions class Account { private $balance; private

    $transactions; public function __construct($balance = 0.00) { $this->balance = $balance; $this->transactions = array(); } public function postTransaction(Transaction $transaction) { try { $newBalance = $transaction->applyTo($this->balance); $this->transactions[] = $transaction; $this->balance = $newBalance; } catch (Exception $e) { // apply fee } } }
  57. abstract class Transaction { private $amount; public function __construct($amount) {

    $this->amount = $amount; } public function applyTo($balance) { $amountToApply = $this->amount; if ($this->isDebit()) { if ($amountToApply > $balance) { throw new Exception('Whoops!'); } return $balance - $amountToApply; } else { return $balance + $amountToApply; } } abstract protected function isDebit(); }
  58. class Withdrawal extends Transaction { protected function isDebit() { return

    true; } } class Deposit extends Transaction { protected function isDebit() { return false; } }
  59. /** output **/ object(Account)#1 (2) { ["balance":"Account":private]=> float(0.010000000000005) ["transactions":"Account":private]=> array(3)

    { [0]=> object(Withdrawal)#2 (1) { ["amount":"Transaction":private]=> float(5) } [1]=> object(Deposit)#3 (1) { ["amount":"Transaction":private]=> float(75) } [2]=> object(Withdrawal)#4 (1) { ["amount":"Transaction":private]=> float(99.99) } } }
  60. When objects are combined by holding a reference to another

    object to gain functionality, this is composition.
  61. // Object-Oriented Shopping Cart class Cart { private $items; public

    function __construct() { $items = array(); } public function addItem($item) { $this->items[] = $item; } public function sumItemPrices() { foreach ($this->items as $item) { $sum += $item->getPrice(); } } }
  62. // Object-Oriented Shopping Cart class Order { private $items; private

    $customer; public function __construct($cart, $customer) { $this->items = $cart; $this->customer = $customer; } public function getTotal() { return $this->items->sumItemPrices(); } }
  63. Single Responsibility Principle A class should be responsible for doing

    one thing. It should only have one reason to change.
  64. class AccessControlManager { public function __construct(Customer $customer) { $this->customer =

    $customer; } public function login() { if ($this->customer->authenticate() && $this->customer->isAuthorized()) { return true; } return false; } }
  65. class Customer { public function getId() {} public function authenticate()

    { // check database for user } public function isAuthorized() { // check authorization against resource } }
  66. class Customer { public function getId(); } class Login {

    public function authenticate(Customer $customer) { // check customer } } class Authorize { public function isAuthorized(Customer $customer) { //validate authorization } }
  67. class AccessControlManager { public function __construct(Customer $customer, Login $login, Authorize

    $authorize) { //assign } public function login() { if ($this->login->authenticate($this->customer) && $this->authorize->isAuthorized($this->customer)) { return true; } return false; } }
  68. This sounds easy to do. But finding and separating responsibilities

    is one of the hardest parts of programming.
  69. class AccessControlManager { public function __construct(Customer $customer, Login $login, Authorize

    $authorize) { //assign } public function login() { if ($this->login->authenticate($this->customer) && $this->authorize->isAuthorized($this->customer)) { return true; } return false; } }
  70. class Login { public function authenticate(Customer $customer) { // check

    customer } protected function getRepository() {} }
  71. class Login { public function authenticate(Customer $customer) { // check

    customer } protected function getRepository() {} } class LoginOauth extends Login { public function authenticate(Customer $customer) { $token = $this->getAccessToken(); // oauth login } protected function getAccessToken() {} }
  72. class LoginDatabase implements LoginService { public function authenticate(Customer $customer) {

    // check customer } protected function getRepository() {} } class LoginOauth implements LoginService { public function authenticate(Customer $customer) { $token = $this->getAccessToken(); // oauth login } protected function getAccessToken() {} }
  73. class AccessControlManager { public function __construct(Customer $customer, LoginService $login, Authorize

    $authoize) { //assign } public function login() { if ($this->login->authenticate($this->customer) && $this->authorize->isAuthorized($this->customer)) { return true; } return false; } }
  74. The takeaway is that your code should not need to

    be modified to adapt it to new situations.
  75. Liskov Substitution Principle Objects within an application should be able

    to be replaced with their subtypes without affecting the correctness of the application.
  76. class PaymentManager { public function __construct(PayDateCalculator $calculator) {} public function

    schedulePayment(Payment $payment) { $payment->setPayDate($this->paydateCalculator->calculate()); //send to db } }
  77. class PaymentManager { public function __construct(PayDateCalculator $calculator) {} public function

    schedulePayment(Payment $payment) { $payment->setPayDate($this->paydateCalculator->calculate()); //send to db } } class PayDateCalculator { public function calculate() { $today = new DateTime(); $firstDayOfNextMonth = $today->modify('first day of next month'); return $firstDayOfNextMonth; } }
  78. class PayDateCalculator { public function calculate() { $today = new

    DateTime(); $firstDayOfNextMonth = $today->modify('first day of next month'); return $firstDayOfNextMonth; } } class LastDayPayDateCalculator extends PayDateCalculator { public function calculate() { $today = new DateTime(); $lastDayOfMonth = $today->modify('last day of this month'); return $lastDayOfMonth->format( 'F jS, Y' ); } }
  79. abstract class PayDateCalculator { public function calculate() { $today =

    new DateTime(); $payDate = $this->resolvePayDate($today); return $payDate; } abstract protected function resolvePayDate($today); } class LastDayPayDateCalculator extends PayDateCalculator { protected function resolvePayDate($today) { return $today->modify('last day of this month'); } } class FirstDayPayDateCalculator extends PayDateCalculator { protected function resolvePayDate($today) { return $today->modify('first day of next month'); }
  80. abstract class PayDateCalculator { public function calculate() { $today =

    new DateTime(); $payDate = $this->resolvePayDate($today); return $payDate; } abstract protected function resolvePayDate($today); }
  81. class LastDayPayDateCalculator extends PayDateCalculator { protected function resolvePayDate($today) { return

    $today->modify('last day of this month'); } } class FirstDayPayDateCalculator extends PayDateCalculator { protected function resolvePayDate($today) { return $today->modify('first day of next month'); } }
  82. class PaymentManager { public function __construct(PayDateCalculator $calculator) {} public function

    schedulePayment(Payment $payment) { $payment->setPayDate($this->paydateCalculator->calculate()); //send to db } }
  83. Make sure any objects which claim to implement a certain

    interface actually implement that interface.
  84. class Cart implements Countable { private $items; public function __construct()

    {} public function addItem($item) {} public function removeItem($item) {} public function emptyCart() {} public function sumItemPrices() {} public function count() {} }
  85. interface ShoppingCart { public function addItem($item); public function removeItem($item); public

    function emptyCart(); public function sumItemPrices(); public function count(); } class Cart implements ShoppingCart {}
  86. interface ShoppingCart { public function addItem($item); public function removeItem($item); public

    function emptyCart(); public function sumItemPrices(); public function count(); } interface Repository { public function addItem($item); public function removeItem($item); public function emptyCart(); }
  87. interface ShoppingCart { public function addItem($item); public function removeItem($item); public

    function emptyCart(); public function sumItemPrices(); public function count(); } interface Summable { public function sum(); }
  88. interface Repository { public function addItem($item); public function removeItem($item); public

    function emptyCart(); } interface Summable { public function sum(); } class Cart implements Countable, Summable, Repository {}
  89. Clients of your objects should not have to depend on

    extraneous methods. Keep your interfaces segregated.
  90. Dependency Inversion Principle High level modules should not depend on

    low level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.
  91. class AccessControlManager { public function __construct(Customer $customer, LoginService $login, Authorize

    $authoize) { //assign } public function login() { if ($this->login->authenticate($this->customer) && $this->authorize->isAuthorized($this->customer)) { return true; } return false; } }
  92. class Authorize { public function isAuthorized(Customer $customer) { //validate authorization

    } } class Customer { public function getId() { return $this->id; } } interface IdentityService { public function getId(); } class Customer implements IdentityService { public function getId() { return $this->id; } }
  93. class Customer { public function getId() { return $this->id; }

    } interface IdentityService { public function getId(); }
  94. interface IdentityService { public function getId(); } class Customer implements

    IdentityService { public function getId() { return $this->id; } }
  95. class AccessControlManager { public function __construct(IdentityService $user, LoginService $login, Authorize

    $authoize) { //assign } public function login() { if ($this->login->authenticate($this->user) && $this->authorize->isAuthorized($this->user)) { return true; } return false; } }