├── Coffee.php
├── README.md
├── Template.php
├── UsersController_with_Interface.php
├── UsersController_without_Interface.php
├── _config.yml
└── tea.php


/Coffee.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Coffee {
 4 | 
 5 |     public function addCoffee()
 6 |     {
 7 |         var_dump('Add proper amount of tea');
 8 |         return $this;
 9 |     }
10 | 
11 |     protected  function  addHotWater()
12 |     {
13 |         var_dump('Pour Hot water into cup');
14 |         return $this;
15 |     }
16 |     protected  function addSuger()
17 |     {
18 |         var_dump('Add proper amount of suger');
19 |         return $this;
20 |     }
21 |     protected function addMilk()
22 |     {
23 |         var_dump('Add proper amount of Milk');
24 |         return $this;
25 |     }
26 | 
27 |     public function make()
28 |     {
29 |         return $this
30 |             ->addHotWater()
31 |             ->addSuger()
32 |             ->addCoffee()
33 |             ->addMilk();
34 |     }
35 | 
36 | }
37 | 
38 | $tea = new Coffee();
39 | $tea->make();


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Welcome to OOP
  2 | ===================
  3 | 
  4 | 
  5 | 
  6 | Interface
  7 | -------------
  8 | 
  9 | We know that an interface is defined by the interface keyword and all methods are abstract. All methods declared in an interface must be public; this is simply the nature of an interface. Here is the example :
 10 | 
 11 | ```php
 12 | <?php
 13 | interface Logger
 14 | {
 15 |     public function execute();
 16 | }
 17 | ```
 18 | 
 19 | In an interface the method body is not defined, just the name and the parameters.
 20 | If we do not use an interface what problems will happen? Why we should use interface? Herein you will get these answers. Please see the code in below:
 21 | 
 22 | ```php
 23 | <?php
 24 | class LogToDatabase 
 25 | {
 26 |     public function execute($message)
 27 |     {
 28 |         var_dump('log the message to a database :'.$message);
 29 |     }
 30 | }
 31 | 
 32 | class LogToFile 
 33 | {
 34 |     public function execute($message)
 35 |     {
 36 |         var_dump('log the message to a file :'.$message);
 37 |     }
 38 | }
 39 | 
 40 | class UsersController 
 41 | { 
 42 |     protected $logger;
 43 |     
 44 |     public function __construct(LogToFile $logger)
 45 |     {
 46 |         $this->logger = $logger;
 47 |     }
 48 |     
 49 |     public function show()
 50 |     { 
 51 |         $user = 'nahid';
 52 |         $this->logger->execute($user);
 53 |     }
 54 | }
 55 | 
 56 | $controller = new UsersController(new LogToFile);
 57 | $controller->show();
 58 | ```
 59 | 
 60 | In the above example I do not use interface. I write to the log using the LogToFile class. But now if I want to write a log using LogToDatabase I have to change hard coded class reference in the above code on line number 23. That line code in below :
 61 | 
 62 | ```php
 63 | public function __construct(LogToFile $logger)
 64 | ```
 65 | 
 66 | This code will be
 67 | 
 68 | ```php
 69 | public function __construct(LogToDatabase $logger)
 70 | ```
 71 | 
 72 | In a large project, if I have multiple classes and a need to change, then I have to change all the classes manually. But If we use an interface this problem is solved; and we will not need to change code manually.
 73 | 
 74 | 
 75 | Now see the following code and try to realize what happened if I use interface:
 76 | 
 77 | ```php
 78 | <?php
 79 | interface Logger 
 80 | {
 81 |     public function execute($message);
 82 | }
 83 | 
 84 | class LogToDatabase implements Logger 
 85 | {
 86 |     public function execute($message){
 87 |         var_dump('log the message to a database :'.$message);
 88 |     }
 89 | }
 90 | 
 91 | class LogToFile implements Logger 
 92 | {
 93 |     public function execute($message) 
 94 |     {
 95 |         var_dump('log the message to a file :'.$message);
 96 |     }
 97 | }
 98 | 
 99 | class UsersController 
100 | {
101 |     protected $logger;
102 |     
103 |     public function __construct(Logger $logger) 
104 |     {
105 |         $this->logger = $logger;
106 |     }
107 |     
108 |     public function show() 
109 |     {
110 |         $user = 'nahid';
111 |         $this->logger->execute($user);
112 |     }
113 | }
114 | 
115 | $controller = new UsersController(new LogToDatabase);
116 | $controller->show();
117 | ```
118 | 
119 | Now If I change from LogToDatabase to LogToFile I do not have to change the constructor method manually. In the constructor method I have Injected an interface; not any arbitrary class. So If you have multiple classes and swap from one class to another class you will get the same result without changing any class references.
120 | 
121 | In the above example I write a log using LogToDatabase and now I want to write log using LogToFile, I can call it in this way
122 | 
123 | ```php
124 | $controller = new UsersController(new LogToFile);
125 | $controller->show();
126 | ```
127 | 
128 | I get the result without changing other classes. Because the interface class handles the swapping issue.
129 | 
130 | 
131 | Abstract class
132 | -------------
133 | 
134 | An abstract class is a class that is only partially implemented by the programmer. It contains at least one abstract method, which is a method without any actual code in it, just the name and the parameters, and that has been marked as “abstract”.
135 | 
136 | An abstract method is simply a function definition that serves to tell the programmer that the method must be implemented in a child class. Here is the example :
137 | 
138 | ```php
139 | <?php
140 | abstract class AbstractClass
141 | {
142 |     // Force Extending class to define this method
143 |     abstract protected function getValue();
144 |     
145 |     public function printOut() 
146 |     {
147 |         print $this->getValue() . "\n";
148 |     }
149 | }
150 | ```
151 | 
152 | Now the question is when will the situation that a method will be needed and must be implemented? Here I will try to explain. Please see the Tea class.
153 | 
154 | ```php
155 | <?php
156 | class Tea 
157 | {
158 |     public function addTea()
159 |     {
160 |         var_dump('Add proper amount of tea');
161 |         return $this;
162 |     }
163 |     protected  function  addHotWater()
164 |     {
165 |         var_dump('Pour Hot water into cup');
166 |         return $this;
167 |     }
168 |     
169 |     protected  function addSugar()
170 |     {
171 |         var_dump('Add proper amount of sugar');
172 |         return $this;
173 |     }
174 |     
175 |     protected function addMilk()
176 |     {
177 |         var_dump('Add proper amount of Milk');
178 |         return $this;
179 |     }
180 |     
181 |     public function make()
182 |     {
183 |         return $this
184 |             ->addHotWater()
185 |             ->addSugar()
186 |             ->addTea()
187 |             ->addMilk();
188 |     }
189 | }
190 | 
191 | $tea = new Tea();
192 | $tea->make();
193 | ```
194 | 
195 | Now we look at the coffee class.
196 | 
197 | ```php
198 | <?php
199 | class Coffee 
200 | {
201 |     public function addCoffee()
202 |     {
203 |         var_dump('Add proper amount of tea');
204 |         return $this;
205 |     }
206 |     
207 |     protected  function  addHotWater()
208 |     {
209 |         var_dump('Pour Hot water into cup');
210 |         return $this;
211 |     }
212 |     
213 |     protected  function addSugar()
214 |     {
215 |         var_dump('Add proper amount of sugar');
216 |         return $this;
217 |     }
218 |     
219 |     protected function addMilk()
220 |     {
221 |         var_dump('Add proper amount of Milk');
222 |         return $this;
223 |     }
224 |     
225 |     public function make()
226 |     {
227 |         return $this
228 |             ->addHotWater()
229 |             ->addSugar()
230 |             ->addCoffee()
231 |             ->addMilk();
232 |     }
233 | }
234 | 
235 | $tea = new Coffee();
236 | $tea->make();
237 | ```
238 | 
239 | In the above two classes the three methods addHotWater(), addSugar(), and addMilk() are same. So we should remove duplicated code. We can do it in the following way :
240 | 
241 | ```php
242 | abstract class Template
243 | {
244 |     public function make()
245 |     {
246 |         return $this
247 |             ->addHotWater()
248 |             ->addSugar()
249 |             ->addPrimaryToppings()
250 |             ->addMilk();
251 |     }
252 |     
253 |     protected  function  addHotWater()
254 |     {
255 |         var_dump('Pour Hot water into cup');
256 |         return $this;
257 |     }
258 |     
259 |     protected  function addSugar()
260 |     {
261 |         var_dump('Add proper amount of sugar');
262 |         return $this;
263 |     }
264 |     
265 |     protected function addMilk()
266 |     {
267 |         var_dump('Add proper amount of Milk');
268 |         return $this;
269 |     }
270 |     
271 |     protected abstract function addPrimaryToppings();
272 | }
273 | 
274 | class Tea extends Template
275 | {
276 |     public function addPrimaryToppings()
277 |     {
278 |         var_dump('Add proper amount of tea');
279 |         return $this;
280 |     }
281 | }
282 | 
283 | $tea = new Tea();
284 | $tea->make();
285 | 
286 | class Coffee extends Template
287 | {
288 |     public function addPrimaryToppings()
289 |     {
290 |         var_dump('Add proper amount of Coffee');
291 |         return $this;
292 |     }
293 | }
294 | 
295 | $coffee = new Coffee();
296 | $coffee->make();
297 | ```
298 | 
299 | I make an abstract class and name it Template. Here I define addHotWater(), addSugar() and addMilk(); and make an abstract method named addPrimaryToppings.
300 | 
301 | Now If I make the Tea class extend the Template class then I will get the three defined methods and must define the addPrimaryToppings() method. In a similar way the coffee class will as well.
302 | 
303 | I have published this article in the medium. if you’d like to read from the medium blog site, please go to this [link](https://medium.com/@NahidulHasan/understanding-use-of-interface-and-abstract-class-9a82f5f15837)
304 | 
305 | Thanks for reading.
306 | 


--------------------------------------------------------------------------------
/Template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | abstract class Template
 3 | {
 4 |     public function make()
 5 |     {
 6 |         return $this
 7 |             ->addHotWater()
 8 |             ->addSuger()
 9 |             ->addPrimaryToppings()
10 |             ->addMilk();
11 |     }
12 |     
13 |     protected  function  addHotWater()
14 |     {
15 |         var_dump('Pour Hot water into cup');
16 |         return $this;
17 |     }
18 |     
19 |     protected  function addSuger()
20 |     {
21 |         var_dump('Add proper amount of suger');
22 |         return $this;
23 |     }
24 |     
25 |     protected function addMilk()
26 |     {
27 |         var_dump('Add proper amount of Milk');
28 |         return $this;
29 |     }
30 |     
31 |     protected abstract function addPrimaryToppings();
32 | }
33 | 
34 | class Tea extends Template
35 | {
36 |     public function addPrimaryToppings()
37 |     {
38 |         var_dump('Add proper amount of tea');
39 |         return $this;
40 |     }
41 | }
42 | 
43 | $tea = new Tea();
44 | $tea->make();
45 | 
46 | 
47 | class Coffee extends Template
48 | {
49 |     public function addPrimaryToppings()
50 |     {
51 |         var_dump('Add proper amount of Coffee');
52 |         return $this;
53 |     }
54 | }
55 | 
56 | 
57 | $coffee = new Coffee();
58 | $coffee->make();
59 | 


--------------------------------------------------------------------------------
/UsersController_with_Interface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | interface Logger 
 3 | {
 4 |     public function execute($message);
 5 | }
 6 | class LogToDatabase implements Logger 
 7 | {
 8 |     public function execute($message){
 9 |         var_dump('log the message to a database :'.$message);
10 |     }
11 | }
12 | class LogToFile implements Logger 
13 | {
14 |     public function execute($message) 
15 |     {
16 |         var_dump('log the message to a file :'.$message);
17 |     }
18 | }
19 | class UsersController 
20 | {
21 |     protected $logger;
22 |     
23 |     public function __construct(Logger $logger) 
24 |     {
25 |         $this->logger = $logger;
26 |     }
27 |     
28 |     public function show() 
29 |     {
30 |         $user = 'nahid';
31 |         $this->logger->execute($user);
32 |     }
33 | }
34 | 
35 | $controller = new UsersController(new LogToDatabase);
36 | $controller->show();
37 | 


--------------------------------------------------------------------------------
/UsersController_without_Interface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class LogToDatabase 
 4 | {
 5 |     public function execute($message)
 6 |     {
 7 |         var_dump('log the message to a database :'.$message);
 8 |     }
 9 | }
10 | 
11 | class LogToFile 
12 | {
13 |     public function execute($message)
14 |     {
15 |         var_dump('log the message to a file :'.$message);
16 |     }
17 | }
18 | 
19 | class UsersController 
20 | { 
21 |     protected $logger;
22 |     
23 |     public function __construct(LogToFile $logger)
24 |     {
25 |         $this->logger = $logger;
26 |     }
27 |     
28 |     public function show()
29 |     { 
30 |         $user = 'nahid';
31 |         $this->logger->execute($user);
32 |     }
33 | }
34 | 
35 | $controller = new UsersController(new LogToFile);
36 | $controller->show();
37 | 


--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
1 | theme: jekyll-theme-cayman


--------------------------------------------------------------------------------
/tea.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Tea {
 4 | 
 5 |     public function addTea()
 6 |     {
 7 |         var_dump('Add proper amount of tea');
 8 |         return $this;
 9 |     }
10 | 
11 |     protected  function  addHotWater()
12 |     {
13 |         var_dump('Pour Hot water into cup');
14 |         return $this;
15 |     }
16 |     protected  function addSuger()
17 |     {
18 |         var_dump('Add proper amount of suger');
19 |         return $this;
20 |     }
21 |     protected function addMilk()
22 |     {
23 |         var_dump('Add proper amount of Milk');
24 |         return $this;
25 |     }
26 | 
27 |     public function make()
28 |     {
29 |         return $this
30 |             ->addHotWater()
31 |             ->addSuger()
32 |             ->addTea()
33 |             ->addMilk();
34 |     }
35 | 
36 | }
37 | 
38 | $tea = new Tea();
39 | $tea->make();


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