VFU SEM - PHP OOP [12.10.2013]

PHP: Hypertext
Preprocessor
PHP - OOP
@d_danailov

PHP : Intro
Dimitar Danailov
Senior Developer at 158ltd.com
dimityr.danailov[at]gmail.com
Github
Slide Share
Founder at VarnaIT

Topics Today
●
●
●
●
●
●

Object-oriented programming Overview
Objects & Classes
Abstraction and encapsulation
Inheritance
Polymorphism
Class Diagrams

OOP
Object-oriented programming (OOP) is a programming
paradigm that represents concepts as "objects" that have
data fields (attributes that describe the object) and
associated procedures known as methods. Objects, which
are usually instances of classes, are used to interact with
one another to design applications and computer
programs. C++, Objective-C, Smalltalk, Java and C# are
examples of object-oriented programming languages.

OOP (2)
●
●
●
●

Objects & Classes
Abstraction and encapsulation
Inheritance
Polymorphism

What is an object
Objects are the elements through which we perceive the
world around us. All objects have these characteristics :
● Identity
● State
● Behaviour

<?php
//Objects
$human = new stdClass();
$human->gender = 'm';
$human->age = 35;
$human->name = 'Todor Dimov';
$child1 = new stdClass();
$child1->name = 'Dimo Todorov';
$child2 = new stdClass();
$child2->name = 'Todorka Todorova';
$human->childrens = array($child1, $child2);
var_dump($human);
?>

Classes (classification of objects)
A class is a group of objects with same attributes and
behavior. The characteristics of a class are :
● A name
● Attributes
● Methods / Functions

<?php
/* Classes */
class Human {
private $name = null;
private $gender = null;
private $age = null;
private $childrens = array();
public function __construct($name, $gender, $age, $childrens
= array()) {
$this->name = $name;
$this->gender = $gender;
$this->age = $age;
$this->childrens = $childrens;
}
}
/* … */
?>

<?php
/* ... */
$child1 = new Human('Dimo Todorov', 'm', 12);
$child2 = new Human('Todorka Todorova', 'f', 16);
$childrens = array($child1, $child2);
$human = new Human('Todor Dimov', 'm', 35, $childrens);
var_dump($human);
?>

Abstraction
In computer science, abstraction is the process by which
data and programs are defined with a representation
similar in form to its meaning (semantics), while hiding
away the implementation details. Abstraction tries to
reduce and factor out details so that the programmer can
focus on a few concepts at a time. A system can have
several abstraction layers whereby different meanings
and amounts of detail are exposed to the programmer.

Encapsulation
Encapsulation is the practice of including in an object
everything it needs hidden from the other objects in the
system.

Inheritance
In object-oriented programming (OOP), inheritance is a
way to establish Is-a relationships between objects. In
classical inheritance where objects are defined by
classes, classes can inherit attributes and behavior from
pre-existing classes called base classes, superclasses, or
parent classes.

// Inheritance
class Human
{
public function __construct($name, $gender, $age) {
$this->age = $age;
}
static function prinHello($name) {
echo 'Hello, ' . $name;
}
private function greetings() {
echo 'Greetings';
}
}

class ParentClass extends Human {
private $childrens = array();
public function __construct ($name, $gender, $age) {
$this->age = $age;
}
public function getName() {
//$this->greetings();
return parent::prinHello($this->name);
}
public function getChildrens () {
return $this->childrens;
}
public function setChildren (Child $child) {
$this->childrens[] = $child;
}
}

Class Child extends Human {
private $parents = array();
public function __construct($name, $gender, $age) {
$this->age = $age;
}
public function getParents() {
return $this->parents;
}
public function setParent(ParentClass $parent) {
$this->parents[] = $parent;
}
}

Polymorphism
Polymorphism describes a pattern in object oriented
programming in which classes have different functionality
while sharing a common interface.

Class Abstraction
PHP 5 introduces abstract classes and methods. Classes
defined as abstract may not be instantiated, and any class
that contains at least one abstract method must also be
abstract. Methods defined as abstract simply declare the
method's signature - they cannot define the
implementation.

<?php
abstract class AbstractHuman {
public function __construct ($name, $gender, $age) {
$this->age = $age;
}
abstract public function getName();
abstract public function setName($name);
abstract public function getGender ();
abstract public function setGender ($gender);
abstract public function getAge();
abstract public function setAge($age);
}
?>

<?php
class ParentClass extends AbstractHuman {
return $this->name;
}
public function setName($name) {
}
public function getGender () {
return $this->gender;
}
public function setGender ($gender) {
}

// ...
}
?>

Object Interfaces
Object interfaces allow you to create code which specifies
which methods a class must implement, without having to
define how these methods are handled.
Interfaces are defined using the interface keyword, in the
same way as a standard class, but without any of the
methods having their contents defined.
All methods declared in an interface must be public, this is
the nature of an interface.

<?php
// Interfaces
interface iHuman {
public function getName();
public function setName($name);
public function getGender();
public function setGender($gender);
public function getAge();
public function setAge($age);
}
?>

<?php
class ParentClass implements iHuman {
return $this->name;
}
public function setName($name) {
}
public function getGender() {
return $this->gender;
}
public function setGender($gender) {
}
// ...
}
?>

Questions ?
Dimitar Danailov
dimityr.danailov[at]gmail.com
Github
Slide Share
Founder at VarnaIT

VFU SEM - PHP OOP [12.10.2013]

Recommandé

Recommandé

Contenu connexe

Plus de Dimitar Danailov

Plus de Dimitar Danailov (20)

Dernier

Dernier (20)

VFU SEM - PHP OOP [12.10.2013]