Advance PHP

Advanced - Object Oriented Programming in PHP, Encapsulation, Polymorphism, Interfaces, Destructors, Constructor, Data Abstraction - web codingcage

<div dir="ltr" style="text-align: left;" trbidi="on">
Data Abstraction: Data abstraction is related to an abstract class, which means a class that cannot be instantiated on its own. The representation of data in this class and the implementation details are hidden. If you want to declare any class method to be abstract, you must have also declared the class itself as to be abstract. In data abstraction, it is a remarkable point that you can inherit from an abstract class. Any kind of class that extends an abstract parent class must create an interface of the parent abstract class includes its methods. Sometimes data abstraction can generate a fatal error. If this do not generate any kind of error. This ensures that the implementation is correct and output will be also error free. 
 
We can understand data abstraction by following example: 
Where mathematics is a abstract class and other are child class 
<pre style="background-color: #fde59c;">
<--?php

abstract class mathematics{

/**
*
* Add two to a number
*
* @access public
*
* @return int
*
**/
public function addTwo(){
  return $this->num+2;
}

} /*** end of class ***/

/*** try to create new object from the mathematics class ***/
$math = new mathematics

?-->

</pre>
 
Constructor: Advance PHP provides special function to Oops PHP called __construct() in Oops to define a constructor . These Constructor Functions are referring to a special type of functions. They are called automatically whenever there is an object created. So we can take full advantage of its behavior, by initializing many things through constructor functions. 
In following example we will create one constructor for vehicles class and it will initialize model and colour for the vehicle at the time of object creation. 
<pre style="background-color: #fde59c;">
function __construct( $par1, $par2 ){
 $this->model = $par1;
 $this->colour = $par2;
}

</pre>
 
After that we don't have need to call set function separately for setting model and colour. We can initialize these two member variables at the time of object creation only. We can understand by it following example: 
<pre style="background-color: #fde59c;">
$honda = new vehicles( "Amaze", white );
 $hyundai = new vehicles ( "Santro", silver );

/* Get those set values */
   $honda->getModel();
   $hyundai->getModel();
   $honda->getPrice();
   $hyundai->getPrice();

</pre>
 
The output will be as follow:

Amaze
 Santro
 White
 Silver
</pre>

Destructors: - We can define destructor function using function __destruct(). These destructors functions are refers for the special kind of function.  We can release all the resources with-in a destructor by using destruct() function. 
 
Interfaces: - The interfaces allow us to define a common structure for classes’ declaration. In PHP an interface cannot be instantiated on its own. As we know in all programming language Oops is re-use of code. Interfaces make this process is much easier. The interface methods have no any internal logic, they are simply a "mapping" or constraint of what kind of class or classes should be implementing. We can create multiple classes to implement with interface. These interfaces classes will not inherit from each other. When we inherit from a parent class, we have to may choose to override. If you had multiple parent class methods with the same name, but all have different functionality or characteristics, sometimes PHP would have confuse to tell which method is to be use. In PHP, classes are implementing an interface, these must implement every method. That’s why multiple inheritances do not work in PHP. 
In following example we see our vehicle class from earlier, with the addition of a stop() function:
 
<pre style="background-color: #fde59c;">
<--?php
class vehicle implements testdrive{

/*** define public properties ***/

/*** the color of the vehicle ***/
public $color;

/*** the number of doors ***/
public $num_doors;

/*** the price of the vehicle ***/
public $price;

/*** the shape of the vehicle ***/
public $shape;

/*** the brand of vehicle ***/
public $brand;

/*** the constructor ***/
public function __construct(){
  echo 'About this Vehicle.';
}

/*** define some public methods ***/

/*** a method to show the vehicle price ***/
public function showPrice(){
  echo 'This vehicle costs '.$this->price.'.';
}

/*** a method to show the number of doors ***/
public function numDoors(){
  echo 'This vehicle has '.$this->num_doors.' doors.';
}

/*** method to drive the vehicle ***/
public function drive(){
  echo 'VRRROOOOOOM!!!';
}
/**
* a method to stop the car
*
* @access public
*
**/
public function stop(){
  echo 'SSSCCRRREEEEEECCHH!!!';
}

} /*** end of class ***/

/*** declare our interface ***/
interface testdrive{
/*** some functions that must be implemented ***/
function drive();
function stop();
}

/*** an new vehicle object ***/
$object = new vehicle;

/*** call some methods ***/
$object->drive();
$object->stop();
?-->

</pre>
 
Polymorphism: Polymorphism is an object oriented concept .The word polymorphism is derived from two words. One is Poly and other is Morph. These are words of Greek language where poly means MANY and Morph means FORM.  So polymorphism is work as many forms. In polymorphism method we can use same functions for different purposes. In oops under polymorphism a function makes different number of arguments but function name will be remain same. Polymorphism can do different task also. In oops we can invoke the correct method by passing the correct method. Polymorphism works on to invoke a function call that is made by inspecting the object. 
<pre style="background-color: #fde59c;">

Syntax for polymorphism programming:
Class Baseclass {
     Public function mymethod() {
          Echo “BaseClass method called”;
          }
         }
       Class DerivedClass extends BaseClass {   
            Public function mymethod() {
                  Echo “DerivedClass method called”;
                  }
         }

</pre> 
We can understand by it following example:

<pre style="background-color: #fde59c;">
class Honda {
 var $name;
 function __construct($name) {
 $this->name = $name;
 }
}

class Passion extends Honda {
    function wheels() {
        return "two wheeler!";
    }

class Amaze extends Honda {
    function wheels() {
        return "four wheeler";
    }
}

</pre>
 
Encapsulation: This method is like enclosing in a capsule. Encapsulation refers to a concept where we encapsulate all the data, related operations, and member functions together to form an object. Simply encapsulation works on wrapping up data members and member function together into a single component. Encapsulation hides the internal details of the object. It prevents the client and user from how an object does work and it’s inside view. Encapsulation is a technique that implemented the behavior of abstraction and protects the information of a object from other objects. Encapsulation also protects the data code from accidental corruption by making an impenetrable wall. The features of encapsulation are supported for classes which are using in object oriented programming. Sometimes it is also possible in non- object oriented language. In PHP encapsulation hide the data for purpose such as making the variable as private which would be public as well as expose the property to access the private data. 
We can understand encapsulation by following Example:
 
<pre style="background-color: #fde59c;">
	<--?php
	Class YourMarks
	{
	Private $marks;
	Public marks
	{
	Get {return $mark; }
	Set { if ($mark>0) $mark = 20; else $mark = 0; }
	}
	}
	?-->

</pre>

Thanks and Happy Coding. Don't forget to give feedback. 
 </div>

Advanced - Object Oriented Programming in PHP, Encapsulation, Polymorphism, Interfaces, Destructors, Constructor, Data Abstraction - web codingcage

Data Abstraction: Data abstraction is related to an abstract class, which means a class that cannot be instantiated on its own. The repres...

<div dir="ltr" style="text-align: left;" trbidi="on">
Object Oriented Programming: - There is no constant definition of object oriented programming. We can understand is that in our surroundings everything is made of some objects. Our nature is made of trees, rivers, mountains, fountains etc. Just like a house is made of bricks, cement, wood etc. Similarly, Object Oriented Programming assumes everything as an object. This programming is known as oops. Oops was created with purpose of practical modelling in simula-67. The concept of oops to implement a software with using different objects. It treats function and data as a object, where keywords are objects. Oops is work on how data and functions represents as a form of reusable object. 
 
There are some important terms which related to object oriented programming: 
Class: -   A class contains the methods, properties and characteristics of the object. It defines the object. The class may include local functions local data type. We can say class is a programmer defined data type. It is the blueprint for the object. We can assume class as template to make many instance of the similar type of object and class. We can understand it by an example. We use different smart phones. All smart phones have same characteristics, like they have battery, Sim card, they are painted some colour, and they each have a price. All smart phones do similar things also, turn on, turn off, play games, play music, store data, capturing image etc. These can be described as functions. Same way in OOPs methods the class keeps definition, and object keeps the value. In PHP we declare class by using the class keyword. 
 
 
Parent class: Parent class is inherited by another class. This is also called a primary class, super class or base class. 
Child Class: Child class is inherited by another class. This is also called a subclass or derived class. 
 
The syntax for defining a new class in PHP is as follows: 
<pre style="background-color: #fde59c;">
<--?php
class phpClass{
 var $var1;
 var $var2 = "constant string";
 function myfunc ($arg1, $arg2) {
 [..]
 }
 [..]
}
?-->
</pre>
 
Description of each statement: 
•    The special form class, followed by the name of the class that we want to define. 
•    A set of braces {} enclosing the number of variable declarations and function definitions. 
•    Variable declarations start with the special form var. It is followed by a conventional $ variable name; they also have an initial assignment for a constant value. 
•    Functions definitions are local to the class and will be used to set and access object data. They look like standalone PHP functions. 
 
 
Example: 
 An example for defines a class of vehicle type: 
<pre style="background-color: #fde59c;">
<--?php
class Vehicles{
 /* Member variables */
 var $colour;
 var $model;
 /* Member functions */
 function setcolour($par){
 $this->colour = $par;
 }
 function getcolour(){
 echo $this->colour;
 }
 function setmodel($par){
 $this->model = $par;
 }
 function getmodel(){
 echo $this->model;
 }
}
?-->

</pre>
 
Here variable $this is a special variable. It refers to the same object. 
 
Object:  In Oops objects are known as instances. The object is an individual instance of the data structure. It is defined by a class. We have to define a class only once and then can make many objects that belong to defined class. An object is a bunch of variables and functions. They all lumped into a single entity. An object contains the methods and properties. Here methods are functions that manipulate data within the object and the properties are variable those keeps information about the object. For creating new object from the class we have to use new keyword. 
After defined a class, we can create as many objects like of declared class type. There is an example of how to create object by using new operator. 
<pre style="background-color: #fde59c;">
$honda = new vehicles;
$hyudai = new vehicles;

</pre>
 
In above case we have created two objects and these objects are independent of each other.  Both of two have their existence separately. Here we will know how to access member function and process member variables. 
Calling Member Functions: - Member Functions are defined inside the class. These are using for accessing object data. After creating objects for class, we are able to call member functions related to objects and one and other member function is able to process member variable and its related object. 
Following example shows how to set model and colour for the two vehicles by calling member functions. 
<pre style="background-color: #fde59c;">
 $honda->setModel( "Amaze" );
 $hyundai->setModel( "Santro" );

$honda->setcolour( white );
   $hyundai->setcolour( silver );

</pre> 
Now we call another member functions to get the values set by in above example: 
<pre style="background-color: #fde59c;">
 $honda->getmodel();
 $hyundai->getmodel();
 
 $honda->getcolour();
 $hyundai->getcolour();

</pre> 
The output will be as follow:- 
<pre style="background-color: #fde59c;">
 Amaze
 Santro
 White
 Silver
</pre>
 
Public: It is a property or permission that accessible from anywhere in the application. Here all class members are public default. 
 
Protected: It is a property or permission that accessible only from a class. It extends from the parent class. 
Private: It is a property or permission that accessible only within the current working class. 
 
Inheritance: Inheritance is the greatest feature of Object Oriented Programming. In PHP when a class is defined by optionally inheriting existing function of a parent class using extends clause. It is called inheritance. It has the ability to extend the child class and inherit the characteristics of parent class. In inheritance child class will inherit the variables of a parent class and all or few member functions. The output of an extend class has characteristics of the parent class, whatever is in the new child, or extended class. 
 
The syntax of inheritance is as follows: 
<pre style="background-color: #fde59c;">

class Child extends Parent {
     --definition body--
  }

</pre>
 
The effect of inheritance is that the child class, subclass or derived class has the following characteristics: 
•    It has all the member variable declarations of the parent class automatically. 
•    It has all the same member functions as the parent. They will work the same way by default as those functions do in the parent. 
This example inherits vehicles class and adds more functionality based on the requirement. 
<pre style="background-color: #fde59c;">
class Wheelers extends Vehicless{
 var manufaturer;
 function setManufacturer($par){
 $this->manufacturer = $par;
 }
 function getManufacturer(){
 echo $this->manufacturer;
 }
}

</pre>
Class wheelers keeps two additional member functions apart from inherited functions. 
 
Overloading: Overloading is a kind of polymorphism. It works on Function definitions in the child class and override definitions respect to same name in the parent classes. Here in child class, we can also do modify the definition of a function inherited from parent class. In overloading all kind of functions are overloaded with different implementation. Similarly, some or all of operators can be overloaded which has different creation and implementations that are depending on the types of their arguments. The overloading refers to the property and ability to able to get and set objects properties. While __set() is called when we change that properties value. 
 
In this following example getColour and getModel functions are overridden for return values. 
 
<pre style="background-color: #fde59c;">
function getcolour(){
 echo $this->color;
 return $this->color;
 }
 function getmodel(){
 echo $this->model;
 return $this->model;
 }
</pre>
 
If you face any difficulty to understand this then feel free to contact me through below contact form. 
Don't Forget to send your feedback. Thanks
</div>

Advanced - Object Oriented Programming in PHP, class program, member function, overloading in php - webcodingcage

Object Oriented Programming: - There is no constant definition of object oriented programming. We can understand is that in our surroundin...

+ Read more »

Advanced - Object Oriented Programming in PHP, Encapsulation, Polymorphism, Interfaces, Destructors, Constructor, Data Abstraction - web codingcage

Advanced - Object Oriented Programming in PHP, class program, member function, overloading in php - webcodingcage

Terms and Conditions

Privacy Policy

About Us