The document describes an object-oriented program for calculating a user's age from their name and birthday input. It introduces classes like Reader, Writer, and AgeCalculator. It then discusses improvements like dependency injection and using a factory pattern to decouple class dependencies and make the code more flexible and reusable.

1. thomas@gasc.fr @methylbro
Manage your objects
Tuesday 9th of September 2014 Montpellier

2. /* ask name */
fwrite(STDOUT, "enter your name :");
$name = trim(fgets(STDIN, 255));
/* ask birthday */
fwrite(STDOUT, "enter your birthday (yyyy/mm/dd) :");
$birthday = new DateTime(trim(fgets(STDIN, 255)));
/* calculate the age */
$age = $birthday->diff(new DateTime());
Case study
/* display the result */
fwrite(
STDOUT,
sprintf(PHP_EOL."hello %s you've got %s years old.", $name, $age->y)
);

3. Oriented Object Programing

4. Reader
+ handle
+ length
+ read(msg)
Writer
+ handle
+ write(msg)
AgeCalculator
+ execute()
Application Class Diagram

5. // src/Reader.php
class Reader
{
private $handle = STDIN;
private $length = 255;
private $writer;
public function __construct()
{
$this->writer = new Writer();
}
public function read($msg)
{
$this->writer->write($msg);
return trim(fgets($this->handle, $this->length));
}
}

6. // src/AgeCalculator.php
class AgeCalculator
{
private $reader, $writer;
public function __construct()
{
$this->reader = new Reader();
$this->writer = new Writer();
}
public function execute()
{
$name = $this->reader->read('your name:');
$birthday = new DateTime(
$this->reader->read('your birthday (yyyy/mm/dd):')
);
$age = $birthday->diff(new DateTime('now'));
$this->writer->write(
sprintf("hello %s you've got %s years old.", $name, $age->y)
);
}
}

7. // age-calculator.php
$ageCalculator = new AgeCalculator();
$ageCalculator->execute();
$ php age-calculator.php
your name: thomas
your birthday (yyyy/mm/dd): 1994/01/01
hello thomas you've got 20 years old.
Running the application

8. Dependency Injection
Pass a dependency to a dependent object

9. // src/Reader.php
class Reader
{
private $handle, $length, $writer;
public function __construct(Writer $writer = null, $handle = STDIN, $length = 255)
{
$this->handle = $handle;
$this->length = $length;
$this->writer = $writer;
}
public function read($msg)
{
if ($this->writer) {
$this->writer->write($msg);
}
return trim(fgets($this->handle, $this->length));
}
}

10. // age-calculator.php
$writer = new Writer();
$reader = new Reader($writer);
$ageCalculator = new AgeCalculator($writer, $reader);
$ageCalculator->execute();

11. // age-calculator.php
$writer = new Writer(fopen('result', 'w+'));
$reader = new Reader(null, fopen('data', 'r'));
$ageCalculator = new AgeCalculator($writer, $reader);
$ageCalculator->execute();

12. Using a Dependency Injection
Framework

13. // config/cli.php
return [
'Writer' => DIobject()->constructor(),
'Reader' => DIobject()
->constructor(DIlink('Writer')),
'AgeCalculator' => DIobject()
->constructor(DIlink('Writer'), DIlink('Reader')),
];

14. // age-calculator.php
require 'vendor/autoload.php';
$builder = new DIContainerBuilder();
$builder->addDefinitions('config/cli.php');
$container = $builder->build();
$ageCalculator = $container->get('AgeCalculator');
$ageCalculator->execute();

15. // config/file.php
return [
'handle.result' => fopen('result', 'w+'),
'handle.data' => fopen('data', 'r'),
'Writer' => DIobject()
->constructor(DIlink('handle.result')),
'Reader' => DIobject()
->constructor(null, DIlink('handle.data')),
'AgeCalculator' => DIobject()
->constructor(DIlink('Writer'), DIlink('Reader')),
];

16. Factory Design Pattern
Deals with the problem of creating objects without
specifying the exact class of object that will be created

17. << abstract >>
Factory
ReaderFactory WriterFactory
+ create()
creates creates
+ write(msg)
FileWriter
uses
Reader Writer
<< interface >>
ReaderInterface
+ setWriter(writer)
+ read(msg)
FileReader
<< interface >>
WriterInterface
extends extends
extends extends
extends extends

18. // src/FileWriter.php
class FileWriter extends Writer
{
public function __construct($filename, $length = 255)
{
$this->handle = fopen($filename, 'w+');
$this->length = $length;
}
}
// src/Filereader.php
class FileReader extends Reader
{
public function __construct($filename, $length = 255)
{
$this->handle = fopen($filename, 'r');
$this->length = $length;
}
}

19. // src/Factory.php
abstract class Factory
{
private $class;
public function __construct($class)
{
$this->class = new ReflectionClass($class);
}
protected abstract function configure(ReflectionClass $class);
public function create($args = array())
{
return $this->class->newInstanceArgs($args);
}
}

20. // config/file.php
return [
'writer.class' => 'FileWriter',
'reader.class' => 'FileReader',
'data.file' => 'data',
'result.file' => 'result',
'WriterFactory' => DIobject()->constructor(DIlink('writer.class')),
'ReaderFactory' => DIobject()
->constructor(
DIlink('reader.class')),
DIfactory(function ($container) {
return $container
->get('WriterFactory')
->create(array($container->get('result.file')))
;
}),
DIfactory(function ($container) {
return $container
->get('ReaderFactory')
->create(array($container->get('data.file')))
;
}
),
'AgeCalculator' => DIobject()->constructor(DIlink('writer'), DIlink('reader')),
];

21. Singleton Design Pattern
Restricts the instantiation of a class to one object

22. Singleton

23. Questions ?
Full examples
https://github.com/methylbro/human-talk-manage-objects-examples