Demystifying Object-Oriented Programming - PHP[tek] 2017

PHP[TEK] 2017 Wiﬁ: Sheraton Meeting Network  Pass: php2017  Twitter: #phptek Rate the talks https://joind.in/event/phptek-2017

Demystifying  Object-Oriented Programming Download Files:  https://github.com/sketchings/oop-basics https://joind.in/talk/6cf9b

Presented by: Alena Holligan • Wife and Mother of 3 young children • PHP Teacher at Treehouse • Portland PHP User Group Leader www.sketchings.com  @sketchings  alena@holligan.us

PART 1: Terminology Class (properties, methods) Object Instance Abstraction Encapsulation

PART 2: Polymorphism Inheritance Interface Abstract Class Traits

PART 3: Magic Magic Methods Magic Constants Static Properties and Methods

PART 4: Scope Property and Method Scope Finality Namespaces Type Declarations

Class A template/blueprint that facilitates creation of objects. A set of program statements to do a certain task. Usually represents a noun, such as a person, place or thing. Includes properties and methods — which are class functions

Object Instance of a class. In the real world object is a material thing that can be seen and touched. In OOP, object is a self-contained entity that consists of both data and procedures.

Instance Single occurrence/copy of an object There might be one or several objects, but an instance is a speciﬁc copy, to which you can have a reference

class User { //class  public $name; //property  public function getName() { //method  echo $this->name; //current object property  }  } $user1 = new User(); //ﬁrst instance of object $user2 = new User(); //second instance of object

Abstraction Managing the complexity of the system Dealing with ideas rather than events This is the class architecture itself. Use something without knowing inner workings

Encapsulation Binds together the data and functions that manipulate the data, and keeps both safe from outside interference and misuse. Properties Methods

Team-up OOP is great for working in groups

Team Challenges Write a class with properties and methods Example: User class with name, title, and salutation

PART 2: Polymorphism D-R-Y  Sharing Code

pol·y·mor·phism /ˌpälēˈmôrﬁzəm/ The condition of occurring in several different forms BIOLOGY GENETICS BIOCHEMISTRY COMPUTING

Terms Polymorphism Inheritance Interface Abstract Class Traits

Inheritance: passes knowledge down Subclass, parent and a child relationship, allows for reusability, extensibility. Additional code to an existing class without modifying it. Uses keyword “extends” NUTSHELL: create a new class based on an existing class with more data, create new objects based on this class

Creating a child class class Developer extends User {  public $skills = array(); //additional property public function getSkillsString(){ //additional method  return implode(", ",$this->skills);  } public function getSalutation() {//override method  return $this->title . " " . $this->name. ", Developer";  }  }

Using a child class $developer = new Developer();  $developer->setName(”Jane Smith”);  $developer->setTitle(“Ms”);  echo $developer->getFormatedSalutation(); $developer->skills = array("JavasScript", "HTML", "CSS");  $developer->skills[] = “PHP";  echo $developer->getSkillsString(); When the script is run, it will return: Ms Jane Smith, Developer JavasScript, HTML, CSS, PHP

Team Challenges Extend the User class for another type of user, such as our Developer example

Interface Interface, speciﬁes which methods a class must implement. All methods in interface must be public. Multiple interfaces can be implemented by using comma separation Interface may contain a CONSTANT, but may not be overridden by implementing class

interface UserInterface { public function getFormattedSalutation(); public function getName(); public function setName($name); public function getTitle(); public function setTitle($title); } class User implements UserInterface { … }

Team Challenges Add an Interface for your Class

Abstract Class An abstract class is a mix between an interface and a class. It can deﬁne functionality as well as interface. Classes extending an abstract class must implement all of the abstract methods deﬁned in the abstract class.

abstract class User { //abstract class public $name; //class property public getName() { //class method  echo $this->name;  } abstract public function setName($name); //abstract method  } class Developer extends User {  public setName($name) { //implementing the method  …

Team Challenges Change to User class to an abstract class. Try instantiating the User class

Traits Composition Horizontal Code Reuse Multiple traits can be implemented

Creating Traits trait Toolkit {  public $tools = array();  public function setTools($task) {  switch ($task) {  case “eat":  $this->tools =   array("Spoon", "Fork", "Knife");  break;  ...  }  }  public function showTools() {  return implode(", ",$this->skills);  }  }

Using Traits class Developer extends User {  use Toolkit;  ...  } $developer = new Developer();  $developer->setTools("Eat");  echo $developer->showTools(); When run the script returns: Spoon, Fork, Knife

When run, the script returns: Ms Jane Smith Spoon, Fork, Knife

Team Challenges Add a trait to the User

Magic Methods Setup just like any other method The Magic comes from the fact that they are triggered and not called For more see http://php.net/manual/en/ language.oop5.magic.php

Magic Constants Predeﬁned functions in PHP For more see http://php.net/manual/en/ language.constants.predeﬁned.php

Using Magic Methods and Constants class User { ...    public function __construct($name, $title) {  $this->name = $name;  $this->title = $title;  }    public function __toString() {  return __CLASS__. “: “  . $this->getFormattedSalutation();  }  ...  }

Creating / Using the Magic Method $user = new User("Jane Smith","Ms");  echo $user; When the script is run, it will return: User: Ms Jane Smith

Challenges Add a Magic Method Add a Magic Constants

Static Properties and Methods class User {  public static $encouragements = array(  “You are beautiful!”,  “You have this!”,    public static function encourage()  {  $int = rand(count($this->encouragements));  return self::encouragements[$int];  }  ...  }

Using the Static Method echo User::encourage(); When the script is run, it will return: You have this!

Team Challenge Add and use a Static Method

Part 3: Scope Property and Method Scope Finality Namespaces Type Declarations

Property and Method Scope Controls who can access what. Restricting access to some of the object’s components (properties and methods), preventing unauthorized access. Public - everyone Protected - inherited classes Private - class itself, not children

class User {  private $name;  protected $title;  public function getFormattedSalutation() {  return $this->getSalutation();  }  protected function getSalutation() {  return $this->title . " " . $this->name;  } class Developer extends User {  private $name; //second property  protected $title; //override property  public function getSalutation() {  return parent::getSalutation()   . ", Developer";  }

Creating / Using the object Instance $developer = new Developer(  "Jane Smith”,”Ms"  );  echo $developer->getFormattedSalutation(); When the script is run, it will return: Ms Jane Smith, Developer

Team Challenges Restrict properties Restrict a method

The FINAL Keyword Prevents child classes from overriding a method by prefixing the definition with final. If the class itself is being defined final then it cannot be extended.

class User { //can extend  ﬁnal public getName() { //cannot extend  echo $this->name;  } ﬁnal class Developer extends User { //cannot extend  public getName() { //error  echo “My Name is: ” .$this->name;  } class Manager extends Developer {…} //error

Team Challenges Deﬁne a parent method as FINAL and try to override in the child Deﬁne a class as FINAL and try to create a child

Namespaces Prevent Code Collision Help create a new layer of code encapsulation Keep properties from colliding between areas of your code Only classes, interfaces, functions and constants are affected Anything that does not have a namespace is considered in the Global namespace (namespace = "")

Namespaces Must be declared first (except 'declare) Can define multiple in the same file You can define that something be used in the "Global" namespace by enclosing a non-labeled namespace in {} brackets. Use namespaces from within other namespaces, along with aliasing

//can build namespace myUser; class User {  …  } //utilize use myUser; class Developer extends myUserUser  {  …   }

Team Challenge Deﬁning types AND try accepting/returning the wrong types

Available Type Declarations PHP 5.4 Class/Interface, self, array, callable PHP 7 bool ﬂoat int string

Type Declarations class Conference {  public $title;  private $attendees = array();  public function addAttendee(User $person) {  $this->attendees[] = $person;  }  public function getAttendees(): array {  foreach($this->attendees as $person) {  $attendee_list[] = $person;   }  return $attendee_list;  }  }

Using Type Declarations $tek = new Conference();  $tek->title = ”PHP[tek] 2017”;  $tek->addAttendee($user);  echo $tek->title;  echo implode(", “, $tek->getAttendees()); When the script is run, it will return the same result as before: PHP[tek] 2017  Ms Jane Smith

Resources LeanPub: The Essentials of Object Oriented PHP Head First Object-Oriented Analysis and Design

Presented by: Alena Holligan • Wife and Mother of 3 young children • PHP Teacher at Treehouse • Portland PHP User Group Leader www.sketchings.com  @sketchings  alena@holligan.us Download Files: https://github.com/sketchings/oop-basics https://joind.in/talk/6cf9b

Demystifying Object-Oriented Programming - PHP[tek] 2017

More Related Content

What's hot

Similar to Demystifying Object-Oriented Programming - PHP[tek] 2017

More from Alena Holligan

Recently uploaded

Demystifying Object-Oriented Programming - PHP[tek] 2017