├── assets
    └── img
    │   ├── xampp-app.png
    │   ├── xampp-download.png
    │   └── xampp-homepage.png
├── 01-classes.php
├── 03-methods.php
├── 05-setters.php
├── mobileLibs.php
├── 06-constructors.php
├── 11-const.php
├── oop-pill
    ├── practical-pill.php
    └── respuestas-teoricas.html
├── 14-overriding.php
├── 02-properties.php
├── 04-getters.php
├── 10-static.php
├── 15-overloading.php
├── 12-abstract-classes.php
├── 08-inheritance-solution.php
├── 07-inheritance-problem.php
├── 13-interfaces.php
├── 09-public-private-protected.php
├── 16-namespaces.php
└── README.md


/assets/img/xampp-app.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/juliomc23/oop-basics/HEAD/assets/img/xampp-app.png


--------------------------------------------------------------------------------
/assets/img/xampp-download.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/juliomc23/oop-basics/HEAD/assets/img/xampp-download.png


--------------------------------------------------------------------------------
/assets/img/xampp-homepage.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/juliomc23/oop-basics/HEAD/assets/img/xampp-homepage.png


--------------------------------------------------------------------------------
/01-classes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 01 - Classes */
 7 | 
 8 | // To create classes we use reserved word class.
 9 | class Mobile
10 | {
11 | }
12 | 
13 | // We can instantitate classes like this
14 | $modernMobile = new Mobile();
15 | $oldMobile = new Mobile();
16 | 
17 | // we can use var_dump so we can visualize our new class objects
18 | 
19 | var_dump($modernMobile);
20 | echo "<br>";
21 | var_dump($oldMobile);
22 | 


--------------------------------------------------------------------------------
/03-methods.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 03 - Properties */
 7 | 
 8 | // in a class we have properties and methods. This methods act like functions and allow classes to develop tasks and functionalities.
 9 | class Mobile
10 | {
11 |     public $name;
12 |     public $chipset;
13 |     public $internalMemory;
14 | 
15 |     // method that returns class properties in a string.
16 |     public function showSpecs()
17 |     {
18 |         return $this->name . " includes a " . $this->chipset . " chipset and " . $this->internalMemory . "GB of internal memory";
19 |     }
20 | }
21 | 
22 | 
23 | $modernMobile = new Mobile();
24 | $modernMobile->name = "Samsung s20";
25 | $modernMobile->chipset = "Exynos";
26 | $modernMobile->internalMemory = 128;
27 | 
28 | echo $modernMobile->showSpecs();
29 | 


--------------------------------------------------------------------------------
/05-setters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 05 - Setters */
 7 | 
 8 | // Setters are methods for modifying properties values
 9 | class Mobile
10 | {
11 |     public $name;
12 |     public $chipset;
13 |     public $internalMemory;
14 | 
15 |     public function getInternalMemory()
16 |     {
17 |         return $this->internalMemory;
18 |     }
19 | 
20 |     // setters are methods for changing properties
21 |     public function setInternalMemory($internalMemory)
22 |     {
23 |         echo "* CHANGED internal memory from " . $this->internalMemory;
24 |         $this->internalMemory = $internalMemory;
25 |         echo " to " . $this->internalMemory;
26 |     }
27 | }
28 | 
29 | echo "<br>";
30 | 
31 | $modernMobile = new Mobile();
32 | $modernMobile->name = "Samsung s20";
33 | $modernMobile->chipset = "Exynos";
34 | $modernMobile->internalMemory = 128;
35 | 
36 | 
37 | echo "<br>";
38 | echo $modernMobile->getInternalMemory();
39 | echo "<br>";
40 | $modernMobile->setInternalMemory(256);
41 | echo "<br>";
42 | echo $modernMobile->getInternalMemory();
43 | 


--------------------------------------------------------------------------------
/mobileLibs.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | //we set namespace name
 4 | namespace Lib;
 5 | 
 6 | // External library interface with same name as main one
 7 | interface mobileApp {
 8 |     // Interfaces cannot have properties
 9 | 
10 |     // All interface methods must be public
11 |     public static function showSplashScreen();
12 |     public static function getData();
13 |     public static function showData();
14 | }
15 | 
16 | // External library classes with also same name
17 | class assemblerApp implements mobileApp{
18 | 
19 |     const APPNAME = 'LIB APP';
20 |     public static $data;
21 | 
22 |     public static function showSplashScreen()
23 |     {
24 |         echo "@@@ " . self::APPNAME . " @@@";
25 |     }
26 | 
27 |     public static function getData()
28 |     {
29 |         self::$data = self::APPNAME . " " . Internet::connectInternet();
30 |     }
31 | 
32 |     public static function showData()
33 |     {
34 |         echo self::$data;
35 |     }
36 | 
37 |     public static function  exitApp()
38 |     {
39 |         echo "@@@ BYE " . self::APPNAME . " BYE @@@";
40 |     }
41 | }
42 | 
43 | 
44 | class Internet {
45 |     const SERVER = '122.23.4.9';
46 | 
47 |     public static function connectInternet()
48 |     {
49 |         return "connecting to " . self::SERVER . "...";
50 |     }
51 | }


--------------------------------------------------------------------------------
/06-constructors.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 06 - Constructors & Destructors */
 7 | 
 8 | class Mobile
 9 | {
10 |     public $name;
11 |     public $chipset;
12 |     public $internalMemory;
13 | 
14 |     // in PHP we use __construct to tell our class that this is the constructor method, it will be called automatically when an object of this class is created
15 |     public function __construct($name, $chipset, $internalMemory)
16 |     {
17 |         // when we create a constructor we can add arguments and then initialize the properties with those argument values
18 |         $this->name = $name;
19 |         $this->chipset = $chipset;
20 |         $this->internalMemory = $internalMemory;
21 |         echo "+ " . $this->name . " CREATED +<br>";
22 |     }
23 | 
24 |     // PHP will call __destruct at the end of the script, when the object is destructed or the script is stopped or exited.
25 |     function __destruct()
26 |     {
27 |         echo "- DESTROYED : " . $this->name . " includes a " . $this->chipset . " chipset and " . $this->internalMemory . "GB of internal memory -<br>";
28 |     }
29 | }
30 | 
31 | // Now we can instantiate a mobile object passing arguments in the correct order
32 | $modernMobile = new Mobile('Samsung s20', 'Exynos', 128);
33 | $oldMobile = new Mobile('BlackBerry', 'ARM', 1);
34 | echo "<br>";
35 | 


--------------------------------------------------------------------------------
/11-const.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 11 - Constants */
 7 | 
 8 | // constants are unchangeable, we can use the word const to create them. The default visibility of class constants is public.
 9 | const APPNAME = 'ASSEMBLER APP';
10 | 
11 | class Internet
12 | {
13 |     const SERVER = '122.23.4.5';
14 | 
15 |     public static function connectInternet()
16 |     {
17 |         // We can refer to constants inside our class with self and double colon
18 |         return "connecting to " . self::SERVER . "...";
19 |     }
20 | }
21 | 
22 | class Mobile
23 | {
24 |     public $name;
25 |     protected $chipset;
26 |     protected $internalMemory;
27 |     private $imei;
28 | 
29 |     public function __construct($name, $chipset, $internalMemory, $imei)
30 |     {
31 |         $this->name = $name;
32 |         $this->chipset = $chipset;
33 |         $this->internalMemory = $internalMemory;
34 |         $this->imei = $imei;
35 |         echo "+ CREATED " . $this->name . " WITH " . $this->internalMemory . " INTERNAL MEMORY +<br>";
36 |     }
37 | 
38 |     // We can access constants with just name
39 |     public function runMobileApp()
40 |     {
41 |         return $this->name . " RUNS " . APPNAME . " : " . Internet::connectInternet();
42 |     }
43 | }
44 | 
45 | $samsung = new Mobile('Samsung s20', 'Exynos', 128, '000111222333');
46 | echo $samsung->runMobileApp();
47 | 


--------------------------------------------------------------------------------
/oop-pill/practical-pill.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Vehicle implements iVehicle{
 4 |     public $motor;
 5 |     public $volante;
 6 |     public $ruedas;
 7 |     public $velocimetro;
 8 | 
 9 |     public function __construct(){
10 |         echo "Building a vehicle";
11 |     }
12 | 
13 |     public function __destruct(){
14 |         echo "Destroying vehicle";
15 |     }
16 | 
17 |     public function setMotor($motor){
18 |         return $this->motor = $motor;
19 |     }
20 | 
21 |     public function setVolante($volante){
22 |         return $this->volante = $volante;
23 |     }
24 | 
25 |     public function setRuedas($ruedas){
26 |         return $this->ruedas = $ruedas;
27 |     }
28 | 
29 |     public function acelerar()
30 |     {
31 |         return $this->velocimetro++;
32 |     }
33 | 
34 |     public function frenar()
35 |     {
36 |         return $this->velocimetro--;
37 |     }
38 | }
39 | 
40 | $coche = new Vehicle;
41 | $coche->setMotor(124);
42 | var_dump($coche);
43 | 
44 | 
45 | class Camion extends Vehicle{
46 | 
47 |     static $remolque;
48 | 
49 |     public function getRemolque(){
50 |         echo "Enganchando el remolque";
51 |     }
52 | }
53 | 
54 | $trailer = new Camion;
55 | $trailer->getRemolque();
56 | var_dump($trailer);
57 | 
58 | abstract class Tanque extends Vehicle{
59 |     
60 |     private $cañon;
61 |     private $cabeza;
62 | 
63 |     private function disparar(){
64 |         echo "Disparandooo";
65 |     }
66 | 
67 |     private function girarCabeza(){
68 |         echo "girando cabezal";
69 |     }
70 | }
71 | 
72 | interface iVehicle{
73 | 
74 |     public function acelerar();
75 |     public function frenar();
76 | 
77 | }
78 | 


--------------------------------------------------------------------------------
/14-overriding.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 14 - Overriding */
 7 | 
 8 | // In function overriding, both parent and child classes should have
 9 | // same function name with and number of arguments. It is used to replace
10 | // parent method in child class. The purpose of overriding is to change
11 | // the behavior of parent class method. The two methods with the same
12 | // name and same parameter is called overriding.
13 | 
14 | class iPhone
15 | {
16 |     public $name;
17 |     public $internalMemory;
18 | 
19 |     public function __construct($name, $internalMemory)
20 |     {
21 |         $this->name = $name;
22 |         $this->internalMemory = $internalMemory;
23 |     }
24 | 
25 |     public function getName()
26 |     {
27 |         return $this->name;
28 |     }
29 | 
30 |     public function getInternalMemory()
31 |     {
32 |         return $this->internalMemory;
33 |     }
34 | }
35 | 
36 | // When you extend a class, the subclass inherits all of the public and protected methods from the parent class.
37 | class iPhonePlus extends iPhone
38 | {
39 |     //Here we are overriding this method adding extra features that the previous "getName" doesn't have.
40 |     public function getName()
41 |     {
42 |         return "¡The name of this iPhone is $this->name!";
43 |     }
44 | }
45 | 
46 | $iPhone = new iPhone("iPhone X", "64");
47 | echo $iPhone->getName() . "\n";
48 | 
49 | $iPhonePlus = new iPhonePlus("iPhone X Plus", "128");
50 | echo $iPhonePlus->getName();
51 | 


--------------------------------------------------------------------------------
/02-properties.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 02 - Properties */
 7 | 
 8 | // classes have properties that contain information about that object defined by the class
 9 | class Mobile {
10 |     public $name; // Public makes sure we can access this properties outside the class.
11 |     public $chipset;
12 |     public $internalMemory;
13 | }
14 | 
15 | $modernMobile = new Mobile();
16 | 
17 | // in OOP and PHP we use the arrow operator ( -> ) for accessing properties
18 | 
19 | // we can assign those public properties in our class with this syntax
20 | $modernMobile->name = "Samsung s20";
21 | $modernMobile->chipset = "Exynos";
22 | $modernMobile->internalMemory = 128;
23 | 
24 | echo "<br>";
25 | 
26 | // we can also access properties value by the arrow operator
27 | echo $modernMobile->chipset;
28 | 
29 | // what happens if we assign a non existing value or a wrong value?
30 | $modernMobile->ramMemory = 1;
31 | $modernMobile->internMemory = 8;
32 | 
33 | echo "<pre>";
34 | var_dump($modernMobile);
35 | echo "</pre>";
36 | 
37 | echo "<br>";
38 | 
39 | //-----------------------------------------------------
40 | // arrow operator is unique in objects and must not be
41 | // confused with double arrow operator used in arrays
42 | //-----------------------------------------------------
43 | 
44 | // this is an example using an array and double arrow operators
45 | $mobileArray = [
46 |     'name' => 'Xiaomi Mi10',
47 |     'chipset' => 'Snapdragon',
48 |     'internalMemory' => 64
49 | ];
50 | echo $mobileArray['chipset'];


--------------------------------------------------------------------------------
/04-getters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 04 - Getters */
 7 | 
 8 | // Encapsulation is one of the principles in OOP, we use getters methods in order to keep information safe.
 9 | class Mobile
10 | {
11 |     public $name;
12 |     public $chipset;
13 |     public $internalMemory;
14 | 
15 |     // methods for getting properties
16 |     public function getName()
17 |     {
18 |         return "--- " . $this->name . " ---";
19 |     }
20 | 
21 |     public function getChipset()
22 |     {
23 |         return $this->chipset;
24 |     }
25 | 
26 |     public function getInternalMemory()
27 |     {
28 |         return $this->internalMemory;
29 |     }
30 | }
31 | 
32 | 
33 | $modernMobile = new Mobile();
34 | $modernMobile->name = "Samsung s20";
35 | $modernMobile->chipset = "Exynos";
36 | $modernMobile->internalMemory = 128;
37 | 
38 | echo "--- GETTERS ---";
39 | echo "<br>";
40 | echo $modernMobile->getName();
41 | echo "<br>";
42 | echo $modernMobile->getChipset();
43 | echo "<br>";
44 | echo $modernMobile->getInternalMemory();
45 | 
46 | 
47 | //-----------------------------------------------------
48 | // with this scenario where all properties are public
49 | // there won't be any differences between using getters
50 | // or accessing  the properties via arrow operator
51 | //-----------------------------------------------------
52 | 
53 | echo "<br><br>";
54 | echo "--- ARROW OPERATOR ---";
55 | echo "<br>";
56 | 
57 | echo $modernMobile->name;
58 | echo "<br>";
59 | echo $modernMobile->chipset;
60 | echo "<br>";
61 | echo $modernMobile->internalMemory;
62 | 


--------------------------------------------------------------------------------
/10-static.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 10 - Static Methods */
 7 | 
 8 | // static methods can be called without creating an instance of the class and are declared with the static keyword
 9 | class Internet
10 | {
11 |     public static $company = "orange";
12 | 
13 |     public static function connectInternet()
14 |     {
15 |         return "connecting to the internet...";
16 |     }
17 | 
18 |     // self word must be used to call static elements inside the same class
19 |     public function __construct()
20 |     {
21 |         echo self::connectInternet();
22 |     }
23 | }
24 | 
25 | class Mobile
26 | {
27 |     public $name;
28 |     protected $chipset;
29 |     protected $internalMemory;
30 |     private $imei;
31 | 
32 |     public function __construct($name, $chipset, $internalMemory, $imei)
33 |     {
34 |         $this->name = $name;
35 |         $this->chipset = $chipset;
36 |         $this->internalMemory = $internalMemory;
37 |         $this->imei = $imei;
38 |         echo "+ CREATED " . $this->name . " WITH " . $this->internalMemory . " INTERNAL MEMORY +<br>";
39 |     }
40 | 
41 |     public function connectMobileInternet()
42 |     {
43 |         // we can call static methods without instantiating directly with class name and double colon
44 |         return $this->name . " : " . Internet::connectInternet();
45 |     }
46 | }
47 | 
48 | // we can acces to static properties without instanciating the class
49 | echo "<br>";
50 | $company = Internet::$company;
51 | 
52 | echo $company;
53 | echo "<br><br>";
54 | 
55 | 
56 | $samsung = new Mobile('Samsung s20', 'Exynos', 128, '000111222333');
57 | echo $samsung->connectMobileInternet();
58 | 


--------------------------------------------------------------------------------
/15-overloading.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 14 - Overloading */
 7 | 
 8 | // Function overloading contains same function name and that function performs
 9 | // different task according to number of arguments. Like other OOP languages
10 | // function overloading can not be done by native approach.
11 | // In PHP function overloading is done with the help of magic function __call().
12 | // This function takes function name and arguments.
13 | 
14 | class App
15 | {
16 |     public $dni;
17 |     public $name;
18 | 
19 |     // The "__call" method will be called when it cannot find the method that the user is trying to call.
20 |     function __call($methodName, $arguments)
21 |     {
22 |         switch ($methodName) {
23 |                 // Here we see if the method introduced by the user exists in our casuistry
24 |             case $methodName == "login":
25 |                 if ($arguments != null) {
26 |                     if (count($arguments) == 2 && is_int($arguments[0])) {
27 |                         return call_user_func_array(array($this, "loginShortDNI"), $arguments);
28 |                     } else if (is_string($arguments[0])) {
29 |                         return call_user_func_array(array($this, "loginFullDNI"), $arguments);
30 |                     }
31 |                 }
32 |                 break;
33 |         }
34 |     }
35 | 
36 |     public function loginShortDNI(int $dni, string $name)
37 |     {
38 |         $this->dni = $dni;
39 |         $this->name = $name;
40 |         return "¡Login with short DNI!";
41 |     }
42 | 
43 |     public function loginFullDNI(string $dni)
44 |     {
45 |         $this->dni = $dni;
46 |         return "¡Login with full DNI!";
47 |     }
48 | }
49 | 
50 | $app = new App();
51 | echo $app->login(53123456, "Pau") . "\n";
52 | echo $app->login("53123456K");
53 | 


--------------------------------------------------------------------------------
/12-abstract-classes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 12 - Abstract classes */
 7 | 
 8 | // An abstract class cannot be instantiated, only inherited. We can declare an abstract class with the keyword abstract.
 9 | // When inheriting from an abstract class, all methods marked abstract in the parent's class declaration must be defined by the child.
10 | const APPNAME = 'ASSEMBLER APP';
11 | 
12 | class Internet
13 | {
14 |     const SERVER = '122.23.4.5';
15 | 
16 |     public static function connectInternet()
17 |     {
18 |         return "connecting to " . self::SERVER . "...";
19 |     }
20 | }
21 | 
22 | // We convert Mobile class into an abstract class
23 | abstract class Mobile
24 | {
25 |     public $name;
26 |     protected $chipset;
27 |     protected $internalMemory;
28 |     private $imei;
29 | 
30 |     public function __construct($name, $chipset, $internalMemory, $imei)
31 |     {
32 |         $this->name = $name;
33 |         $this->chipset = $chipset;
34 |         $this->internalMemory = $internalMemory;
35 |         $this->imei = $imei;
36 |         echo "+ CREATED " . $this->name . " WITH " . $this->internalMemory . " INTERNAL MEMORY +<br>";
37 |     }
38 | 
39 |     public function runMobileApp()
40 |     {
41 |         return $this->name . " RUNS " . APPNAME . " : " . Internet::connectInternet();
42 |     }
43 | }
44 | 
45 | class Blackberry extends Mobile
46 | {
47 |     public $keyboard;
48 | 
49 |     public function __construct($name, $chipset, $internalMemory, $imei, $keyboard)
50 |     {
51 |         parent::__construct($name, $chipset, $internalMemory, $imei);
52 |         $this->keyboard = $keyboard;
53 |     }
54 | }
55 | 
56 | $blackberry = new BlackBerry('BlackBerry', 'ARM', 1, '99966688555', 'qwerty');
57 | echo $blackberry->runMobileApp();
58 | 
59 | // We cannot instantiate an abstract class by itself!!
60 | $samsung = new Mobile('Samsung s20', 'Exynos', 128, '000111222333'); // Fatal error: Uncaught Error: Cannot instantiate abstract class Mobile


--------------------------------------------------------------------------------
/08-inheritance-solution.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 08 - Inheritance solution */
 7 | 
 8 | // Let's apply inheritance in latest example
 9 | 
10 | class Mobile
11 | {
12 |     public $name;
13 |     public $chipset;
14 |     public $internalMemory;
15 | 
16 |     public function __construct($name, $chipset, $internalMemory)
17 |     {
18 |         // when we create a constructor we can add arguments and then initialize the properties with those argument values
19 |         $this->name = $name;
20 |         $this->chipset = $chipset;
21 |         $this->internalMemory = $internalMemory;
22 |     }
23 | 
24 |     public function getName()
25 |     {
26 |         return $this->name;
27 |     }
28 | 
29 |     public function getChipset()
30 |     {
31 |         return $this->chipset;
32 |     }
33 | 
34 |     public function getInternalMemory()
35 |     {
36 |         return $this->internalMemory;
37 |     }
38 | 
39 |     public function getMobileDetails()
40 |     {
41 |         return "Name: $this->name, Chipset: $this->chipset, Internal Memory: $this->internalMemory";
42 |     }
43 | }
44 | 
45 | // When you extend a class, the subclass inherits all of the public and protected methods from the parent class.
46 | class Blackberry extends Mobile
47 | {
48 |     public $keyboard;
49 | 
50 |     // in php we use __construct to tell our class that this is the constructor method
51 |     public function __construct($name, $chipset, $internalMemory, $keyboard)
52 |     {
53 |         // we use same constructor as father class with parent keyword and double colon
54 |         parent::__construct($name, $chipset, $internalMemory);
55 |         // and add new arguments necessary for the new son class
56 |         $this->keyboard = $keyboard;
57 |     }
58 | 
59 |     //new method for getting keyboard type
60 |     public function getKeyboard()
61 |     {
62 |         return $this->keyboard;
63 |     }
64 | }
65 | 
66 | $samsung = new Mobile('Samsung s20', 'Exynos', 128);
67 | $blackberry = new BlackBerry('BlackBerry', 'ARM', 1, 'qwerty');
68 | echo $blackberry->getName();
69 | echo "\n";
70 | echo $blackberry->getMobileDetails();
71 | 


--------------------------------------------------------------------------------
/07-inheritance-problem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 07 - Why Inheritance?  */
 7 | 
 8 | // Inheritance is another basic principle of OOP
 9 | 
10 | class Samsung
11 | {
12 |     public $name;
13 |     public $chipset;
14 |     public $internalMemory;
15 | 
16 |     public function __construct($name, $chipset, $internalMemory)
17 |     {
18 |         // when we create a constructor we can add arguments and then initialize the properties with those argument values
19 |         $this->name = $name;
20 |         $this->chipset = $chipset;
21 |         $this->internalMemory = $internalMemory;
22 |         echo "+ " . $this->name . " CREATED +<br>";
23 |     }
24 | 
25 |     function __destruct()
26 |     {
27 |         echo "- DESTROYED : " . $this->name . " includes a " . $this->chipset . " chipset and " . $this->internalMemory . "GB of internal memory -<br>";
28 |     }
29 | }
30 | 
31 | // We need a class for mobiles with extra properties and methods that won't have every mobile
32 | // For example we could need a class for a mobile device with physical keyboard so we create a new one
33 | 
34 | class Blackberry
35 | {
36 |     public $name;
37 |     public $chipset;
38 |     public $internalMemory;
39 |     public $keyboard;
40 | 
41 | 
42 |     public function __construct($name, $chipset, $internalMemory, $keyboard)
43 |     {
44 |         $this->name = $name;
45 |         $this->chipset = $chipset;
46 |         $this->internalMemory = $internalMemory;
47 |         $this->keyboard = $keyboard;
48 |         echo "+ " . $this->name . " CREATED +<br>";
49 |     }
50 | 
51 |     //new method for getting keyboard type
52 |     public function getKeyboard()
53 |     {
54 |         return $this->keyboard;
55 |     }
56 | 
57 |     function __destruct()
58 |     {
59 |         echo "- DESTROYED : " . $this->name . " includes a " . $this->chipset . " chipset and " . $this->internalMemory . "GB of internal memory. It uses " . $this->keyboard . " Keyboard -<br>";
60 |     }
61 | }
62 | 
63 | $samsung = new Samsung('Samsung s20', 'Exynos', 128);
64 | $blackberry = new BlackBerry('BlackBerry', 'ARM', 1, 'qwerty');
65 | echo "<br>";
66 | 
67 | // Seems that we are repeating too much code...


--------------------------------------------------------------------------------
/13-interfaces.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 13 - Interfaces */
 7 | 
 8 | // Interfaces allows specifying what methods a class should implement.
 9 | // they make it easy to use a variety of different classes in the same way.
10 | // When one or more classes use the same interface, it is referred to as "polymorphism".
11 | // Interfaces are declared with the interface keyword
12 | interface iMobileApp
13 | {
14 |     // Interfaces cannot have properties
15 | 
16 |     // All interface methods must be public
17 |     public function showSplashScreen();
18 |     public function login($username, $password);
19 |     public function saveData();
20 |     public function logout();
21 | }
22 | 
23 | // To implement an interface, the implements operator is used
24 | class AssemblerApp implements iMobileApp
25 | {
26 | 
27 |     const APPNAME = 'ASSEMBLER APP';
28 |     private $username;
29 |     private $password;
30 |     public $data;
31 | 
32 |     // We have to declare every method described in the interface. If we miss a method we'll get a fatal error:
33 |     // Fatal error: Class AssemblerApp contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (mobileApp::methodName)
34 |     public function showSplashScreen()
35 |     {
36 |         return "¡Welcome to " . self::APPNAME . "!\n";
37 |     }
38 | 
39 |     public function login($username, $password)
40 |     {
41 |         $this->username = $username;
42 |         $this->paassword = $password;
43 | 
44 |         return "¡Loggin succesful with $this->username!\n";
45 |     }
46 | 
47 |     public function saveData()
48 |     {
49 |         return "¡The user has successfully saved the information!\n";
50 |     }
51 | 
52 |     public function logout()
53 |     {
54 |         $this->username = null;
55 |         $this->paassword = null;
56 | 
57 |         return "¡The user has successfully logged out the application!\n";
58 |     }
59 | 
60 |     // We can add methods not present in the interface
61 |     public function  exitApp()
62 |     {
63 |         echo "Clossing " . self::APPNAME . "...";
64 |     }
65 | }
66 | 
67 | $app = new AssemblerApp();
68 | 
69 | echo $app->showSplashScreen();
70 | echo $app->login("XxProAssemblerxX", "123456");
71 | echo $app->saveData();
72 | echo $app->logout();
73 | echo $app->exitApp();
74 | 


--------------------------------------------------------------------------------
/09-public-private-protected.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //======================================================================
 3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
 4 | //======================================================================
 5 | 
 6 | /* File 09 - Access modifiers */
 7 | 
 8 | // Properties and methods can have access modifiers which control where they can be accessed. 
 9 | // thanks to them we can improve encapsulation to our classes.
10 | 
11 | class Mobile
12 | {
13 |     public $name; // public makes sure we can access this properties outside the class.
14 |     private $chipset; // private elements may only be accessed by the class that defines the member.
15 |     protected $internalMemory;
16 |     private $imei;
17 | 
18 |     public function __construct($name, $chipset, $internalMemory, $imei)
19 |     {
20 |         $this->name = $name;
21 |         $this->chipset = $chipset;
22 |         $this->internalMemory = $internalMemory;
23 |         $this->imei = $imei;
24 |         echo "+ " . $this->name . " CREATED +<br>";
25 |     }
26 | 
27 |     // now getters methods meke more sense because we won't be able to access properties outside the class
28 |     public function getName()
29 |     {
30 |         return "--- " . $this->name . " ---<br>";
31 |     }
32 | 
33 |     public function getChipset()
34 |     {
35 |         return $this->chipset;
36 |     }
37 | 
38 |     public function getInternalMemory()
39 |     {
40 |         return $this->internalMemory;
41 |     }
42 | 
43 |     // protected elements can be accessed only within the class itself and inside inherited classes.
44 |     protected function getIMEI()
45 |     {
46 |         return $this->imei;
47 |     }
48 | }
49 | 
50 | class Blackberry extends Mobile
51 | {
52 |     private $keyboard;
53 | 
54 |     public function __construct($name, $chipset, $internalMemory, $imei, $keyboard)
55 |     {
56 |         parent::__construct($name, $chipset, $internalMemory, $imei);
57 |         $this->keyboard = $keyboard;
58 |     }
59 | 
60 |     // show protected imei
61 |     public function showIMEI()
62 |     {
63 |         return $this->getIMEI();
64 |     }
65 | }
66 | 
67 | $samsung = new Mobile('Samsung s20', 'Exynos', 128, '000111222333');
68 | $blackberry = new BlackBerry('BlackBerry', 'ARM', 1, '99966688555', 'qwerty');
69 | 
70 | //-----------------------------------------------------
71 | // with this scenario we can't access private or protected
72 | // attributes or methods via arrow operator
73 | //-----------------------------------------------------
74 | 
75 | echo "<br>";
76 | echo $samsung->getName(); // OK | Public method accessing a public property inside the class
77 | echo "<br>";
78 | echo $samsung->name; // OK | Public property
79 | echo "<br>";
80 | echo $samsung->getChipset(); // OK | Public method accessing a protected property inside the class
81 | echo "<br>";
82 | echo $samsung->chipset; // ERROR | Private property so we can't access outside the class and throws: Fatal error: Uncaught Error: Cannot access privated property Mobile::$chipset
83 | echo "<br>";
84 | echo $samsung->getIMEI(); // ERROR | Protected method so we can't call it outside our class and throws: Fatal error: Uncaught Error: Call to protected method Mobile::getIMEI() from context
85 | echo "<br>";
86 | echo $samsung->imei; // ERROR | Private property so we can't access outside the class and throws: Fatal error: Uncaught Error: Cannot access private property Mobile::$imei
87 | echo "<br>";
88 | echo $blackberry->showIMEI(); // OK | Public method accessing a inherited protected method inside the class
89 | echo "<br>";
90 | echo $blackberry->getInternalMemory(); // OK | Public method accessing a inherited protected method inside the class
91 | echo "<br>";
92 | echo $blackberry->internalMemory; // Uncaught Error: Cannot access protected property Blackberry::$internalMemory
93 | echo "<br>";
94 | 


--------------------------------------------------------------------------------
/16-namespaces.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | //======================================================================
  3 | // ASSEMBLER SCHOOL - PHP Object Oriented Programming
  4 | //======================================================================
  5 | 
  6 | /* File 16 - Namespaces */
  7 | 
  8 | // Namespaces are designed to solve two problems we encounter when creating re-usable code elements such as classes or functions:
  9 | // - Name collisions between code you create, and internal PHP classes/functions/constants or third-party classes/functions/constants.
 10 | // - Ability to alias (or shorten) Extra_Long_Names designed to alleviate the first problem, improving readability of source code.
 11 | 
 12 | // imagine we need an external library for implementing some tasks in our mobile classes
 13 | // inside mobileLibs there's already an interface named iMobileApp so if we run this php we will get an error:
 14 | // Fatal error: Cannot declare interface iMobileApp, because the name is already in use in D:\xampp\htdocs\assembler-school\oop-basics\mobileLibs.php on line 4
 15 | // we have to add a namespace in mobileLibs
 16 | 
 17 | include 'mobileLibs.php';
 18 | 
 19 | interface iMobileApp
 20 | {
 21 |     public static function showSplashScreen();
 22 |     public static function getData();
 23 |     public static function showData();
 24 | }
 25 | 
 26 | class AssemblerApp implements iMobileApp
 27 | {
 28 | 
 29 |     const APPNAME = 'ASSEMBLER APP';
 30 |     public static $data;
 31 | 
 32 |     public static function showSplashScreen()
 33 |     {
 34 |         echo "@@@ " . self::APPNAME . " @@@";
 35 |     }
 36 | 
 37 |     public static function getData()
 38 |     {
 39 |         self::$data = self::APPNAME . " " . Internet::connectInternet();
 40 |     }
 41 | 
 42 |     public static function showData()
 43 |     {
 44 |         echo self::$data;
 45 |     }
 46 | 
 47 |     public static function  exitApp()
 48 |     {
 49 |         echo "@@@ BYE " . self::APPNAME . " BYE @@@";
 50 |     }
 51 | }
 52 | 
 53 | class Internet
 54 | {
 55 |     const SERVER = '122.23.4.5';
 56 | 
 57 |     public static function connectInternet()
 58 |     {
 59 |         return "connecting to " . self::SERVER . "...";
 60 |     }
 61 | }
 62 | 
 63 | abstract class Mobile
 64 | {
 65 |     public $name;
 66 |     protected $chipset;
 67 |     protected $internalMemory;
 68 |     private $imei;
 69 | 
 70 |     public function __construct($name, $chipset, $internalMemory, $imei)
 71 |     {
 72 |         $this->name = $name;
 73 |         $this->chipset = $chipset;
 74 |         $this->internalMemory = $internalMemory;
 75 |         $this->imei = $imei;
 76 |         echo "+ CREATED " . $this->name . " WITH " . $this->internalMemory . " INTERNAL MEMORY +<br>";
 77 |     }
 78 | 
 79 |     public function runAssemblerApp()
 80 |     {
 81 |         echo "<br>";
 82 |         AssemblerApp::showSplashScreen();
 83 |         echo "<br>";
 84 |         AssemblerApp::getData();
 85 |         AssemblerApp::showData();
 86 |         echo "<br>";
 87 |         AssemblerApp::exitApp();
 88 |     }
 89 | 
 90 |     public function runAssemblerAppLib()
 91 |     {
 92 |         // We use the namespace for calling our library methods
 93 |         Lib\AssemblerApp::showSplashScreen();
 94 |         echo "<br>";
 95 |         Lib\AssemblerApp::getData();
 96 |         Lib\AssemblerApp::showData();
 97 |         echo "<br>";
 98 |         Lib\AssemblerApp::exitApp();
 99 |     }
100 | }
101 | 
102 | class Blackberry extends Mobile
103 | {
104 |     public $keyboard;
105 | 
106 |     public function __construct($name, $chipset, $internalMemory, $imei, $keyboard)
107 |     {
108 |         parent::__construct($name, $chipset, $internalMemory, $imei);
109 |         $this->keyboard = $keyboard;
110 |     }
111 | }
112 | 
113 | $blackberry = new BlackBerry('BlackBerry', 'ARM', 1, '99966688555', 'qwerty');
114 | echo $blackberry->runAssemblerApp();
115 | echo "<br><br>";
116 | echo $blackberry->runAssemblerAppLib();
117 | 


--------------------------------------------------------------------------------
/oop-pill/respuestas-teoricas.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |     <title>OOP-Pill</title>
  8 | </head>
  9 | <body>
 10 |     <div>
 11 |         <h1>Theoretical part</h1>
 12 |         <div>
 13 |             <span>What is object-oriented programming in general terms?</span>
 14 |             <p>es un modelo de programación en el cual se busca una programación escalable y organizada</p>
 15 |         </div>
 16 | 
 17 |         <div>
 18 |             <span>What is a class?</span>
 19 |             <p>una clase es el molde apartir del cual crearemos los nuevos objetos</p>
 20 |         </div>
 21 | 
 22 |         <div>
 23 |             <span>What is an object?</span>
 24 |             <p>un objeto es un elemento creado a partir de una clase</p>
 25 |         </div>
 26 | 
 27 |         <div>
 28 |             <span>What is an instance?</span>
 29 |             <p>una instancia es la creación de ese objeto</p>
 30 |         </div>
 31 | 
 32 |         <div>
 33 |             <span>What is a property?</span>
 34 |             <p>una propiedad no es más que un atributo que puede tener ese objeto</p>
 35 |         </div>
 36 | 
 37 |         <div>
 38 |             <span>What is a method?</span>
 39 |             <p>un metodo es una acción que puede realizar un objeto</p>
 40 |         </div>
 41 | 
 42 |         <div>
 43 |             <span>What is the difference between a function and a method?</span>
 44 |             <p>la unica diferencia que hay es que se llama funcion si no pertenece a un objeto, en el momento en el que la funcion esté declarada en el objeto este pasa
 45 |                 a llamarse metodo
 46 |             </p>
 47 |         </div>
 48 | 
 49 |         <div>
 50 |             <span>What is a constructor?</span>
 51 |             <p>un constructor es otro metodo</p>
 52 |         </div>
 53 | 
 54 |         <div>
 55 |             <span>What is the difference between a class, an object and an instance?</span>
 56 |             <p>
 57 |                 clase: es la plantilla de la que se crearán los objetos
 58 |                 objeto: elemento creado de esa plantilla
 59 |                 instancia: momento en el que se crea el nuevo objeto
 60 |             </p>
 61 |         </div>
 62 | 
 63 |         <div>
 64 |             <span>What do we understand about the concept of encapsulation?</span>
 65 |             <p>la manera en la que declaramos los atributos y metodos de una clase, pueden ser public, private o protected. Dependiendo de como lo hagamos se
 66 |                 comportarán de una manera o de otra
 67 |             </p>
 68 |         </div>
 69 | 
 70 |         <div>
 71 |             <span>What do we understand about the concept of abstraction?</span>
 72 |             <p>cuando creamos una clase tenemos que saber que atributos y metodos va a tener esa clase, no podemos ser ni muy abstractos ni muy realistas.</p>
 73 |         </div>
 74 | 
 75 |         <div>
 76 |             <span>What do we understand about the concept of inheritance?</span>
 77 |             <p>cuando creamos otra clase esta puede heredar los atributos y metodos de la clase principal creada
 78 |             </p>
 79 |         </div>
 80 | 
 81 |         <div>
 82 |             <span>What do we understand about the concept of polymorphism?</span>
 83 |             <p>tener diferente funcionalidad en una clase, pero compartiendo una misma plantilla</p>
 84 |         </div>
 85 | 
 86 |         <div>
 87 |             <span>What do we understand about the concept of Overload?</span>
 88 |             <p>es tener 2 o mas metodos con el mismo nombre pero con distintos parametros</p>
 89 |         </div>
 90 | 
 91 |         <div>
 92 |             <span>What do we understand about the concept of Override?</span>
 93 |             <p>una subclase puede redefinir los metodos heredados cuando necesite cambiar el comportamiento de este metodo</p>
 94 |         </div>
 95 | 
 96 |         <div>
 97 |             <span>What differences exist between the concept of Overload and Override?</span>
 98 |             <p></p>
 99 |         </div>
100 | 
101 |         <div>
102 |             <span>What is a static class?</span>
103 |             <p>una clase estatica es aquella que no te permite la instanciacion de esta</p>
104 |         </div>
105 | 
106 |         <div>
107 |             <span>Look for 3 advantages over object-oriented programming compared to other programming paradigms</span>
108 |             <p>
109 |                 1. Reeutilizacion de codigo
110 |                 2. Encapsulacion, hacemos mas segura nuestra aplicacion
111 |                 3. Mas facilidad para leer y entender nuestro codigo
112 |             </p>
113 |         </div>
114 | 
115 |         <div>
116 |             <span>Look for disadvantages of this paradigm.</span>
117 |             <p>
118 |                 es mas dificil de aprender
119 |             </p>
120 |         </div>
121 |     </div>
122 | </body>
123 | </html>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | `#php` `#oop` `#master-in-software-engineering`
  2 | 
  3 | # Assembler School: OOP Basics with PHP <!-- omit in toc -->
  4 | 
  5 | In this project you will learn the basics of OOP using mobile devices as a reference. In the _"Project files"_ section you will find a description of the content to be displayed in each file.
  6 | 
  7 | ## Table of contents
  8 | 
  9 | - [Table of contents](#table-of-contents)
 10 | - [Getting Started](#getting-started)
 11 | - [Dependencies](#dependencies)
 12 | - [Tools](#tools)
 13 | - [OOP Introduction](#oop-introduction)
 14 | - [Project files](#project-files)
 15 | 
 16 | ## Getting Started
 17 | 
 18 | ### The repo <!-- omit in toc -->
 19 | 
 20 | First, you will need to clone the repo:
 21 | 
 22 | ```bash
 23 | $ git clone https://github.com/assembler-school/oop-basics.git
 24 | ```
 25 | 
 26 | ### Presentation material <!-- omit in toc -->
 27 | 
 28 | - [Slides](https://docs.google.com/presentation/d/1cZxutGPDqUGsLWLVen_ATjd7dEkeoPS_v_fy1y0C5Co/edit?usp=sharing)
 29 | 
 30 | ## Dependencies
 31 | 
 32 | Before we can get started you will need to make sure that all the necessary dependencies are installed in your system.
 33 | 
 34 | ### PHP <!-- omit in toc -->
 35 | 
 36 | You can install it by following the instructions [in the official docs](https://www.php.net/downloads) (we recommend that you install the version that is named _Current_).
 37 | 
 38 | To verify that you have installed it correctly, you can run the following command from the terminal that should output the version installed:
 39 | 
 40 | ```bash
 41 | $ php -version
 42 | ```
 43 | 
 44 | ## Tools
 45 | 
 46 | In the event that you prefer to use a tool that installs everything you need to configure and run a PHP server, we recommend using [XAMPP](https://www.apachefriends.org/es/download.html)
 47 | 
 48 | ### XAMPP <!-- omit in toc -->
 49 | 
 50 | XAMPP is a completely free and easy to install Apache distribution that contains MariaDB, PHP, and Perl. The XAMPP installation package has been designed to be incredibly easy to install and use.
 51 | 
 52 | <img src='./assets/img/xampp-homepage.png' width='600' alt='xampp homepage'>
 53 | 
 54 | You have to go to the [download page](https://www.apachefriends.org/es/download.html) and it will automatically recommend installing the latest version available.
 55 | 
 56 | <img src='./assets/img/xampp-download.png' width='600' alt='xampp download'>
 57 | 
 58 | Once downloaded and installed, in the case that the Windows operating system you will see the following screen, in which you will only have to start the Apache service.
 59 | 
 60 | <img src='./assets/img/xampp-app.png' width='600' alt='xampp app'>
 61 | 
 62 | ## OOP Introduction
 63 | 
 64 | Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code: data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).
 65 | 
 66 | ## Project files
 67 | 
 68 | ### [01 - Classes](./01-classes.php) <!-- omit in toc -->
 69 | 
 70 | The OOP paradigm encapsulates concepts of the real world in what is called as Classes which create Objects. In this file you will learn how to create a class and instanciate it.
 71 | 
 72 | ### [02 - Properties](02-properties.php) <!-- omit in toc -->
 73 | 
 74 | Class member variables are called properties. In this file, you will learn how to add properties to a class and get them when the class is instantiated.
 75 | 
 76 | ### [03 - Methods](03-methods.php) <!-- omit in toc -->
 77 | 
 78 | Properties define the characteristics of an object and the methods (functions in a class are called methods) which define the behavior of the Class. In this file you will learn how to create methods inside a class.
 79 | 
 80 | ### [04 - Getters](04-getters.php) <!-- omit in toc -->
 81 | 
 82 | The get method returns the attribute value, usually there is a get method for each attribute of the class. In this file you will learn how to create **getter** methods.
 83 | 
 84 | ### [05 - Setters](05-setters.php) <!-- omit in toc -->
 85 | 
 86 | The set method sets the attribute value, usually there is a get method for each attribute of the class. In this file you will learn how to create **setter** methods.
 87 | 
 88 | ### [06 - Constructors](06-constructors.php) <!-- omit in toc -->
 89 | 
 90 | A constructor allows you to initialize an object's properties upon creation of the object. In this file you will learn how to create the constructor method.
 91 | 
 92 | ### [07 - Inheritance problem](07-inheritance-problem.php) <!-- omit in toc -->
 93 | 
 94 | There are several disadvantages of not applying inheritance in our code. In this file you will lean what's the problem if you don't apply any inheritance in your code.
 95 | 
 96 | ### [08 - Inheritance soluction](08-inheritance-solution.php) <!-- omit in toc -->
 97 | 
 98 | The child class will inherit all the public and protected properties and methods from the parent class. In addition, it can have its own properties and methods. In this file you will learn how to apply the inheritance in your code.
 99 | 
100 | ### [09 - Public, private & protected](09-public-private-protected.php) <!-- omit in toc -->
101 | 
102 | Properties and methods can have access modifiers which control where they can be accessed. In this file you will learn le three access modifiers.
103 | 
104 | ### [10 - Static](10-static.php) <!-- omit in toc -->
105 | 
106 | Static properties and methods can be called directly - without creating an instance of the class first. In this file you will learn how to use static properties and methods.
107 | 
108 | ### [11 - Const](11-const.php) <!-- omit in toc -->
109 | 
110 | Constants cannot be changed once it is declared. Class constants can be useful if you need to define some constant data within a class. In this file you will learn how to create constants within a class.
111 | 
112 | ### [12 - Abstract classes](12-abstract-classes.php) <!-- omit in toc -->
113 | 
114 | Abstract classes and methods are when the parent class has a named method, but need its child class(es) to fill out the tasks. In this file you will learn how to create and use abstract classes.
115 | 
116 | ### [13 - Interfaces](13-interfaces.php) <!-- omit in toc -->
117 | 
118 | Interfaces allow you to specify what methods a class should implement.
119 | Interfaces make it easy to use a variety of different classes in the same way. When one or more classes use the same interface, it is referred to as "polymorphism". In this file you will learn how to create and extend interfaces.
120 | 
121 | ### [14 - Overriding](14-overriding.php) <!-- omit in toc -->
122 | 
123 | In function overriding, both parent and child classes should have same function name with and number of arguments. In this file you will learn how to implement overriding.
124 | 
125 | ### [15 - Overloading](15-overloading.php) <!-- omit in toc -->
126 | 
127 | Function overloading contains same function name and that function preforms different task according to number of arguments. In this file you will learn how to implement overloading.
128 | 
129 | ### [16 - Namespaces](16-namespaces.php) <!-- omit in toc -->
130 | 
131 | Namespaces are qualifiers that solve two different problems:
132 | 
133 | 1. They allow for better organization by grouping classes that work together to perform a task
134 | 2. They allow the same name to be used for more than one class
135 | 
136 | In this file you will learn how to create and use namespaces.
137 | 


--------------------------------------------------------------------------------