PHP as OOP

Object Oriented Concepts

• Class − This is a programmer-defined data type, which includes local functions as well as local data. You can think of a class as a template for making many instances of the same kind (or class) of object. A class is a template for an object, and an object is an instance of a class. Because an object is an instance of a class, you will often see the two words object and instance used interchangeably.
• Object − An individual instance of the data structure defined by a class. You define a class once and then make many objects that belong to it. Objects are also known as instance. Instance mesans 'Can holds it's state'.
• Member Variable − These are the variables defined inside a class. This data will be invisible to the outside of the class and can be accessed via member functions. These variables are called attribute of the object once an object is created. The data, or variables, defined within a class are called instance variable because each instance of the class (that is, each object of the class) contains its own copy of these variables.
• Member function − These are the function defined inside a class and are used to access object data.
• Inheritance − When a class is defined by inheriting existing function of a parent class then it is called inheritance. Here child class will inherit all or few member functions and variables of a parent class.
• Parent class − A class that is inherited from by another class. This is also called a base class or super class.
• Child Class − A class that inherits from another class. This is also called a subclass or derived class.
• Polymorphism(বহুরুপতা) − This is an object oriented concept where same function can be used for different purposes. For example function name will remain same but it make take different number of arguments and can do different task.
• Overloading − a type of polymorphism in which some or all of operators have different implementations depending on the types of their arguments. Similarly functions can also be overloaded with different implementation. [PHP supports overloading in a different way]
• Overriding – Same method name with same number of property. Used in inheritance.
• Data Abstraction(গোপন করন) − Any representation of data in which the implementation details are hidden (abstracted).
• Encapsulation(মোড়ানো) − Wrapping up data member and method together into a single unit (i.e. Class) is called Encapsulation.
• Constructor − refers to a special type of function which will be called automatically whenever there is an object formation from a class.
• Destructor − refers to a special type of function which will be called automatically whenever an object is deleted or goes out of scope.
• Namespace – Used to remove naming conflicts and to classify files in a project. Details.
• Class name are noun and method or function names are verb. Interface names are generally prefixed with I.
• In PHP, keywords (e.g. if, else, while, echo, etc.), classes, functions, and user-defined functions are not case-sensitive. However; all variable names are case-sensitive!

Constructor Functions

function __construct( $par1, $par2 ) {
   $this->title = $par1;
   $this->price = $par2;
}

$physics = new Books( "Physics for High School", 10 );
$maths = new Books ( "Advanced Chemistry", 15 );
$chemistry = new Books ("Algebra", 7 );

/* Get those set values */
$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();

$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Physics for High School
  Advanced Chemistry
  Algebra
  10
  15
  7

Destructor

Inheritance

class Child extends Parent {
   <definition body>
}

• Automatically has all the member variable declarations of the parent class.
• Automatically has all the same member functions as the parent, which (by default) will work the same way as those functions do in the parent.

Function Overriding

Public Members

• From outside the class in which it is declared
• From within the class in which it is declared
• From within another class that implements the class in which it is declared

Private members

class MyClass {
   private $car = "skoda";
   $driver = "SRK";
   
   function __construct($par) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
   
   function myPublicFunction() {
      return("I'm visible!");
   }
   
   private function myPrivateFunction() {
      return("I'm  not visible outside!");
   }
}

Protected members

class MyClass {
   protected $car = "skoda";
   $driver = "SRK";

   function __construct($par) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
   
   function myPublicFunction() {
      return("I'm visible!");
   }
   
   protected function myPrivateFunction() {
      return("I'm  visible in child class!");
   }
}

Inheritance

Trait

Interfaces

interface Mail {
   public function sendMail();
}

class Report implements Mail {
   // sendMail() Definition goes here
}

Constants

class MyClass {
   const requiredMargin = 1.7;
   
   function __construct($incomingValue) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
}

Abstract Classes

abstract class MyAbstractClass {
   abstract function myAbstractFunction() {
   }
}

Use of abstract and interface

1. One typical example is a plugin architecture. Developer A writes the main app, and wants to make certain that all plugins written by developer B, C and D conform to what his app expects of them.
2. If I’m writing a library of code, then any random person can come along, create a class that implements that interface, instantiate an object of that class and pass it to my library code and expect it to work. Note: it is of course possible to strictly implement an interface while ignoring the intention of the interface, so merely implementing an interface is no guarantee that things will work. Stupid always finds a way! 

Static Keyword

<?php
   class Foo {
      public static $my_static = 'foo';
      
      public function staticValue() {
         return self::$my_static;
      }
   }
 
   print Foo::$my_static . "\n";
   $foo = new Foo();
   
   print $foo->staticValue() . "\n";
?>

Final Keyword

<?php

   class BaseClass {
      public function test() {
         echo "BaseClass::test() called<br>";
      }
      
      final public function moreTesting() {
         echo "BaseClass::moreTesting() called<br>";
      }
   }
   
   class ChildClass extends BaseClass {
      public function moreTesting() {
         echo "ChildClass::moreTesting() called<br>";
      }
   }
?>

Namespace

:: vs ->

Scope Resolution Operator (::)

$this vs self vs static vs parent

1. $this vs self: Use $this to refer to the current object. Use self to refer to the current class. In other words, use $this->member for non-static members, use self::$member for static members.
2. self:: vs static:: : If the self keyword is defined in parent class and called through the child class, will refer to the parent class. Where the static class will refer to the current (child) class. This is called Late Static Bindings.
3. parent:: refers to the parent class name.

::class

use \App\Console\Commands\Inspire;

//...

protected $commands = [
    Inspire::class, // Equivalent to "App\Console\Commands\Inspire"
];

Singleton pattern

<?php
    class DBConn {

        private static $obj;

        private final function  __construct() {
            echo __CLASS__ . " initializes only once\n";
        }

        public static function getConn() {
            if(!isset(self::$obj)) {
                self::$obj = new DBConn();
            }
            return self::$obj;
        }
    }

    $obj1 = DBConn::getConn();
    $obj2 = DBConn::getConn();

    var_dump($obj1 == $obj2);
?>

DBConn initializes only once
bool(true)

            _______________________
           |                       |
$obj1 ---->|  Instance of DBConn   |<----- $obj2
           |_______________________|