Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

PHPID online Learning #6 Migration from procedural to OOP

157 views

Published on

In this presentation, we will be talking about a migration of PHP development model from Procedural to OOP (Object Oriented Programming). This slide is a part of PHP ID (PHP Indonesia) Online Learning #6

Published in: Software
  • Be the first to comment

  • Be the first to like this

PHPID online Learning #6 Migration from procedural to OOP

  1. 1. Migration from procedural to OOP PHPID Online Learning #6 Achmad Mardiansyah (achmad@glcnetworks.com) IT consultant for 15 years+
  2. 2. Agenda ● Introduction ● Procedural PHP ● OOP in PHP ● Migration to OOP ● QA 2
  3. 3. Introduction 3
  4. 4. About Me 4 ● Name: Achmad Mardiansyah ● Base: bandung, Indonesia ● Linux user since 1999 ● Write first “hello world” 1993 ● First time use PHP 2004, PHP OOP 2011. ○ Php-based web applications ○ Billing ○ Radius customisation ● Certified Trainer: Linux, Mikrotik, Cisco ● Teacher at Telkom University (Bandung, Indonesia) ● Website contributor: achmadjournal.com, mikrotik.tips, asysadmin.tips ● More info: http://au.linkedin.com/in/achmadmardiansyah
  5. 5. About GLCNetworks ● Garda Lintas Cakrawala (www.glcnetworks.com) ● Based in Bandung, Indonesia ● Scope: IT Training, Web/Application developer, Network consultant (Mikrotik, Cisco, Ubiquity, Mimosa, Cambium), System integrator (Linux based solution), Firewall, Security ● Certified partner for: Mikrotik, Ubiquity, Linux foundation ● Product: GLC billing, web-application, customise manager 5
  6. 6. prerequisite ● This presentation is not for beginner ● We assume you already know basic skills of programming and algorithm: ○ Syntax, comments, variables, constant, data types, functions, conditional, loop, arrays, etc ● We assume you already have experience to create a web-based application using procedural method 6
  7. 7. Procedural PHP 7
  8. 8. Procedural PHP ● Code executed sequentially ● Easy to understand ● Faster to implement ● Natural ● Program lines can be very long ● Need a way to architect to: ○ Manage our code physically ○ Manage our application logic 8 <?php define DBHOST define DBUSER $variable1 $variable2 if (true) { code... } for ($x=0; $x<=100; $x++) { echo "The number is: $x <br>";
  9. 9. Basic: Constant vs Variable ● Both are identifier to represent data/value ● Constant: ○ Value is locked, not allowed to be changed ○ Always static: memory address is static ● Variable: ○ Static: ■ Memory address is static ○ Dynamic ■ Memory address is dynamic ■ Value will be erased after function is executed 9 <?php define DBHOST define DBUSER $variable1 $variable2 } ?>
  10. 10. Basic: static vs dynamic (non-static) variable ● Static variable ○ Memory address is static ○ The value is still keep after function is executed ● Non-static variable ○ Memory address is dynamic ○ The value is flushed after execution 10 function myTest() { static $x = 0; echo $x; $x++; } myTest(); myTest(); myTest();
  11. 11. Efficient code: using functions 1111 <?php define DBHOST define DBUSER $variable1 $variable2 if (true) { code... } for ($x=0; $x<=100; $x++) { echo "The number is: $x <br>"; } 1111 <?php function calcArea () { Code… } define DBHOST define DBUSER $variable1 $variable2 calcArea(); ?> before after
  12. 12. Efficient code: include 1212 <?php function calcArea () { Code… } define DBHOST define DBUSER $variable1 $variable2 calcArea(); ?> <?php include file_function.php define DBHOST define DBUSER $variable1 $variable2 calcArea(); ?> before after
  13. 13. <?php $name = array("david", "mike", "adi", “doni”); $arrlength = count($name); for($x = 0; $x < $arrlength; $x++) { echo $name[$x].”<br>”; } ?> Efficient code: array/list (indexed array) <?php $name1=david; $name2=mike; $name3=adi; $name4=doni; echo $name1.”<br>”; echo $name2.”<br>”; echo $name3.”<br>”; echo $name4.”<br>”; } ?> 1313 before after
  14. 14. <?php $name = array("david"=>23, "mike"=>21, "adi"=>25); foreach($name as $x => $x_value) { echo "name=".$x." age ".$x_value."<br>"; } ?> Efficient code: Associative Arrays / dictionary <?php $name1=david; $name1age=23 $name2=mike; $name2age=21 $name3=adi; $name3age=25 echo $name1.” ”.$name1age.”<br>”; echo $name2.” ”.$name2age.”<br>”; echo $name3.” ”.$name3age.”<br>”; } ?> 1414 before after
  15. 15. We need more features... ● Grouping variables / functions -> so that it can represent real object ● Define access to variables/functions ● Easily extend current functions/group to have more features without losing connections to current functions/group 15
  16. 16. OOP in PHP 16
  17. 17. ● Class is a group of: ○ Variables -> attributes/properties ○ Functions -> methods ● We call the class first, and then call what inside (attributes/methods) ● The keyword “$this” is used when a thing inside the class, calls another thing inside the class CLASS → instantiate→ object To access the things inside the class: $object->variable $object->method() OOP: Class and Object 17 <?php class Fruit { // Properties public $name; public $color; // Methods function set_name($name) { $this->name = $name; } function get_name() { return $this->name; } } $apple = new Fruit(); $banana = new Fruit(); $apple->name='manggo'; $apple->set_name('Apple'); $banana->set_name('Banana'); echo $apple->get_name()."<br>"; echo $banana->get_name(); ?>
  18. 18. OOP: inheritance ● Class can have child class ● Object from child class can access things from parent class ● Implemented in many php framework ● This is mostly used to add more functionality of current application ● Read the documentation of the main class 18 <?php class Fruit { public $name; public $color; public function __construct($name, $color) { $this->name = $name; $this->color = $color; } public function intro() { echo "The fruit is {$this->name} and the color is {$this->color}."; } } class Strawberry extends Fruit { public function message() { echo "Am I a fruit or a berry? "; } } $strawberry = new Strawberry("Strawberry", "red"); $strawberry->message(); $strawberry->intro(); ?>
  19. 19. OOP: method chain ● Object can access several method in chains ● Similar to UNIX pipe functions ● For example: text processing with various method 19 <?php class fakeString { private $str; function __construct() { $this->str = ""; } function addA() { $this->str .= "a"; return $this; } function addB() { $this->str .= "b"; return $this; } function getStr() { return $this->str; } } $a = new fakeString(); echo $a->addA()->addB()->getStr(); ?>
  20. 20. OOP: constructor ● Is a method that is executed automatically when a class is called 20 <?php class Fruit { public $name; public $color; function __construct($name, $color) { $this->name = $name; $this->color = $color; } function get_name() { return $this->name; } function get_color() { return $this->color; } } $apple = new Fruit("Apple", "red"); echo $apple->get_name(); echo "<br>"; echo $apple->get_color(); ?>
  21. 21. OOP: destructor ● Is the method that is called when the object is destructed or the script is stopped or exited 21 <?php class Fruit { public $name; public $color; function __construct($name) { $this->name = $name; } function __destruct() { echo "The fruit is {$this->name}."; } } $apple = new Fruit("Apple"); ?>
  22. 22. OOP: access modifier (attribute) ● Properties and methods can have access modifiers which control where they can be accessed. ● There are three access modifiers: ○ public - the property or method can be accessed from everywhere. This is default ○ protected - the property or method can be accessed within the class and by classes derived from that class ○ private - the property or method can ONLY be accessed within the class 22 <?php class Fruit { public $name; protected $color; private $weight; } $mango = new Fruit(); $mango->name = 'Mango'; // OK $mango->color = 'Yellow'; // ERROR $mango->weight = '300'; // ERROR ?>
  23. 23. OOP: access modifier (method) ● Properties and methods can have access modifiers which control where they can be accessed. ● There are three access modifiers: ○ public - the property or method can be accessed from everywhere. This is default ○ protected - the property or method can be accessed within the class and by classes derived from that class ○ private - the property or method can ONLY be accessed within the class 23 <?php class Fruit { public $name; public $color; public $weight; function set_name($n) { $this->name = $n; } protected function set_color($n) { $this->color = $n; } private function set_weight($n) { $this->weight = $n; } } $mango = new Fruit(); $mango->set_name('Mango'); // OK $mango->set_color('Yellow'); // ERROR $mango->set_weight('300'); // ERROR ?>
  24. 24. OOP: abstract ● Abstract classes and methods are when the parent class has a named method, but need its child class(es) to fill out the tasks. ● An abstract class is a class that contains at least one abstract method. ● An abstract method is a method that is declared, but not implemented in the code. ● When inheriting from an abstract class, the child class method must be defined with the same name, and the same or a less restricted access modifier ● 24 <?php abstract class Car { public $name; public function __construct($name) { $this->name = $name; } abstract public function intro() : string; } // Child classes class Audi extends Car { public function intro() : string { return "German quality! $this->name!"; } } // Create objects from the child classes $audi = new audi("Audi"); echo $audi->intro(); echo "<br>"; ?>
  25. 25. OOP: trait ● Traits are used to declare methods that can be used in multiple classes. ● Traits can have methods and abstract methods that can be used in multiple classes, and the methods can have any access modifier (public, private, or protected). 25 <?php trait message1 { public function msg1() { echo "OOP is fun! "; } } class Welcome { use message1; } $obj = new Welcome(); $obj->msg1(); ?>
  26. 26. OOP: static properties ● Attached to the class ● Can be called directly without instance ● Keyword “::” ● Calling inside the class, use keyword self:: ● From child class, use keyword parent 26 <?php class pi { public static $value=3.14159; public function staticValue() { return self::$value; } } class x extends pi { public function xStatic() { return parent::$value; } } //direct access to static variable echo pi::$value; echo x::$value; $pi = new pi(); echo $pi->staticValue(); ?>
  27. 27. OOP: static method ● Attached to the class ● Can be called directly without instance ● Keyword “::” ● Calling inside the class, use keyword self:: ● From child class, use keyword parent 27 <?php class greeting { public static function welcome() { echo "Hello World!"; } public function __construct() { self::welcome(); } } class SomeOtherClass { public function message() { greeting::welcome(); } } //call function without instance greeting::welcome(); new greeting(); ?>
  28. 28. Migration to OOP 28
  29. 29. Several checklist on OOP ● Step back -> planning -> coding ● Design, design, design -> architecture ○ Its like migrating to dynamic routing ○ Class design ■ Attribute ■ Method 29
  30. 30. OOP myth / ● Its better to learn programming directly to OOP ● Using OOP means we dont need procedural ● OOP performs better ● OOP makes programming more visual. OOP != visual programming (drag & drop) ● OOP increases reuse (recycling of code) ● 30
  31. 31. QA 31
  32. 32. End of slides Thank you for your attention 32

×