• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Object Oriented PHP: An Introduction
 

Object Oriented PHP: An Introduction

on

  • 4,162 views

Overview of OOP basics in PHP.

Overview of OOP basics in PHP.

Statistics

Views

Total Views
4,162
Views on SlideShare
4,156
Embed Views
6

Actions

Likes
6
Downloads
192
Comments
0

3 Embeds 6

http://coderwall.com 4
http://127.0.0.1:12006 1
http://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

CC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

Object Oriented PHP: An Introduction Object Oriented PHP: An Introduction Presentation Transcript

  • An Introduction Object Oriented PHP
  • Who's this guy, then?
    • PHP Developer since 2000; full-time since 2003
    • PHP Developer for Zend Technologies since 2005
    • Zend Framework contributor since January 2006
    • Zend Framework project lead since April 2009
    • I live and breathe OOP daily
  • Who Are You?
    • How many of you have used OOP before?
    • How many of you use OOP regularly?
    • If you're not using OOP, why are you interested?
  • What is OOP?
  • Object Oriented Programming Models software concepts as discrete entities , containing attributes and capable of performing actions that may optionally use those attributes.
  • Start with what you know
  • Constants and Variables define ( FOO , 'foo' ); define ( BAR , 'bar' ); $value = 'bar' ; switch ( $value ) { case FOO : // do something; break ; case BAR : // do something else break ; }
  • Associative Arrays $person = array ( 'last_name' => "Weier O'Phinney" , 'first_name' => "Matthew" , 'occupation' => 'PHP Developer' , 'gender' => 'Male' , 'email' => 'matthew@example,com' , );
  • Functions function mail ( $to , $subject , $body ) { // ... do some stuff // optionally return something: return true ; }
  • Objects group related subjects
  • Start with a class declaration class Person { }
  • Define some common class member variables class Person { public $firstName ; public $lastName ; public $occupation ; public $gender ; public $email ; }
  • Some types of class members
    • Variables Declared using a visibility operator and normal variable naming
    • Constants Declared with the “const” keyword, and no quotes
    • Methods Declared with the “function” keyword
  • define methods, which are functions inside a class class Person { // ... attributes ... public function boast () { return sprintf ( '%s %s is a %s' , $this -> firstName , $this -> lastName , $this -> occupation ); } } Instance variables!
  • Use your objects! $matthew = new Person (); $matthew -> firstName = 'Matthew' ; $matthew -> lastName = "Weier O'Phinney" ; $matthew -> email = 'matthew@example.com' ; $matthew -> gender = 'male' ; $matthew -> occupation = 'PHP Developer' ; echo $matthew -> boast (); // Matthew Weier O'Phinney is a PHP Developer
  • Why bother?
  • It's good programming
    • Scope and encapsulation
    • Re-use (both re-using a class by instantiating many objects, and class extension)
    • Type enforcement
    • Testability and maintenance
  • Some words on scope
    • Methods have access to:
      • Whatever is passed to them
      • Any class member variables, constants, or methods (with respect to visibility)
    • Use “ $this-> ” within a class to access member variables and methods (unless statically declared); use “ -> ” when consuming an instance
    • Use “ self:: ” to access member constants
  • What is this “visibility” stuff?
    • Determines scope in which a class member may be accessed.
      • Public : can be accessed via instances, anywhere within the class definition, and by any extending class.
      • Protected : can be accessed within the class definition, and by extending classes.
      • Private : may only be accessed and modified within the defining class.
  • Extension?
    • Use the extends keyword:
    class Matthew extends Person “ Extends” keyword!
  • Extension: override properties class Matthew extends Person { public $firstName = 'Matthew' ; public $lastName = "Weier O'Phinney" ; public $occupation = 'PHP Developer' ; public $email = 'matthew@example.com' ; public $gender = 'male' ; }
  • Extension: override methods class Matthew extends Person { public function boast () { // get parent value from method $boast = parent :: boast (); $boast .= ', and wrote this presentation' ; return $boast ; } } Access the original method!
  • Extension: use the new class $matthew = new Matthew (); echo $matthew -> boast (); // Matthew Weier O'Phinney is a PHP Developer, // and wrote this presentation Note: using Matthew, not Person! boast() now says something new!
  • Abstraction
    • A formal way of defining extension points
    • Two types:
      • Interfaces
      • Abstract Classes
  • Interfaces
    • Defines a public contract for classes that implement it
    • Ensures consuming classes will always have specific methods available
  • A sample interface interface Animal { public function makeNoise (); public function eat ( $food ); } “ Interface” keyword!
  • Interfaces may extend other interfaces interface Collection extends Countable , IteratorAggregate { } Collection now inherits methods from Countable and IteratorAggregate
  • Implementing an interface means defining the interfaces methods class Family extends Order implements Collection { // defined by Countable public function count () {} // defined by IteratorAggregate public function getIterator () {} } “ implements ” keyword; this object follows that contract
  • Abstract Classes
    • Sometimes it's useful to create a “base” set of functionality.
    • At the same time, you may want to leave certain details up to implementing classes.
  • Sample Abstract Class abstract class Person { public $firstName ; public $lastName ; public $email ; public $occupation ; public $gender ; public function speak () { /* implementation in here */ } // let extension define this, though: abstract public function eat ( $food ); } “ abstract” keyword; extending class must implement
  • Abstract classes can also implement interfaces abstract class Family extends Order implements Collection { }
  • Magic methods
    • Always prefixed by “ __ ” (double underscore)
    • Some tie into various object states (initialization, destruction, cloning)
    • Some allow "overloading" the functionality of the object (set or get "virtual" members; call "virtual" methods; etc.)
  • Object initialization public function __construct ( $firstName , $lastName ) { $this -> firstName = $firstName ; $this -> lastName = $lastName ; } Magic method: constructor
  • And on the subjects of scope and inheritance...
    • STATIC members:
      • Class members that do not require an object instance in order to operate.
      • “Global” state (i.e., does not vary between instances); use rarely and wisely.
      • Uses the "Paamayim Nekudotayim" operator (` :: `) for scope resolution
  • Static example class Registry { protected static $values = array (); public static function set ( $name , $value ) { static :: $values [ $name ] = $value ; } public static function get ( $name ) { if ( isset ( static :: $values [ $name ])) { return static :: $values [ $name ]; } return null ; } } Registry :: set ( 'foo' , 'bar' ); echo Registry :: get ( 'foo' ); // 'bar' The type is small because I don't want you to use statics. :)
  • Type validation
    • PHP allows you to typehint on any class, abstract class, or interface name.
    if (! $matthew instanceof Person ) { echo "Imposter!" ; }
  • Parting remarks
  • Keep your objects discrete and concise
    • All members should be related to a discrete subject
    • Methods should not do too much
    • Too many members often means you're mixing concerns, and should separate into more classes
  • Statics: don't do them
    • Static functionality is appealing and seductive, but that way leads to the Dark Side
  • Magic methods
    • Learn the magic methods, but don't lean to heavily on them
      • Except in the case of __construct() , which is almost always a good idea.
  • Learn the SPL
    • Some SPL interfaces allow array-like access to objects, including iteration, array access to properties, etc.
    • Objects like ArrayObject, SplStack , and others can be huge time savers.
    • Solutions based off of SPL will almost always be faster than userland code.
  • Use OOP … … but don't forget your procedural roots; if a function will do, use it.
  • Resources
    • http://thinkvitamin.com/author/lornajanemitchell/
    • http://php.net/oop
    • http://php.net/spl
  • Thank You!
    • These slides are online: http://slidesha.re/bctnVk
    • Rate the talk! http://joind.in/2046