Object Oriented PHP: An Introduction
Upcoming SlideShare
Loading in...5
×
 

Object Oriented PHP: An Introduction

on

  • 4,227 views

Overview of OOP basics in PHP.

Overview of OOP basics in PHP.

Statistics

Views

Total Views
4,227
Slideshare-icon Views on SlideShare
4,221
Embed Views
6

Actions

Likes
6
Downloads
195
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
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    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