PHP instantiating child class - php

Question

I'm trying to become an object-oriented coder here, so I'm giving myself some simple tasks.
I built a class that displays all the images in a given directory. That worked fine, so I separated that class into two classes, one to read the filenames in the directory and pass them into an array, and one to parse that array and display the pictures. The method in the child class is exactly the same as it was when it was in the parent class (except of course substituting parent:: for this->).
Now it seems when I instantiate the child class and call its method, nothing happens at all.
Classes:
class Picfind
{
public function findPics($dir){
$files = array();
$i=0;
$handle = opendir($dir);
while (false !== ($file = readdir($handle))){
$extension = strtolower(substr(strrchr($file, '.'), 1));
if($extension == 'jpg' || $extension == 'gif' || $extension == 'png'){
// now use $file as you like
$i++;
$files['file' . $i] = $file;
}
}
return $files;
}
}
class DisplayPics extends Picfind
{
function diplayPics($dir)
{
echo 'displayPics method called';
foreach(parent::findPics($dir) as $key => $val) {
echo '<img src="' . $dir . $val . '" img><br/>';
}
}
}
Instantiation:
include("class.picFind.php");
$Myclass = new DisplayPics();
$Myclass->displayPics('./images/');

Answer 1

To be honest: your whole design is wrong.
DisplayPics shouldn't inherit from Picfind. Honestly, either have Picfind have a display method, or have DisplayPics take the output from Picfind. Think, does the following make sense: "DisplayPics is a PicFind."? If not, it's probably wrong.
Classes normally aren't verbs. A better name would be Pictures, with find and display methods. In your case, you are finding something in a directory, which leads to the next point:
You should make use of the PHP DirectoryIterator class. This way, you can do whatever you'd like with the files you find. You'll have all the information about the file available to you, and it's integrated nicely with PHP.
You need a separation of concerns. This is what hakre's suggestion is all about. Reducing dependencies and decoupling things is normally helpful.
/**
* ExtensionFinder will find all the files in a directory that have the given
* extensions.
*/
class ExtensionFinder extends DirectoryIterator {
protected $extensions = array();
public function __contruct($directory) {
parent::__construct($directory);
}
/**
* Sets the extensions for the iterator.
* #param array $extensions The extensions you want to get (without the dot).
*/
public function extensions(array $extensions) {
$this->extensions = $extensions;
}
/**
* Determines if this resource is valid. If you return false from this
* function, the iterator will stop.
* #return boolean Returns true if the value is a file with proper extension.
*/
public function valid() {
if (parent::valid()) {
$current = parent::current();
if ($current->isFile()) {
// if the extensions array is empty or null, we simply accept it.
if (empty($this->extensions)) {
//otherwise filter it
if (in_array($current->getExtension(), $this->extensions)) {
return true;
} else {
parent::next();
return $this->valid();
}
} else {
return true;
}
} else {
parent::next();
return $this->valid();
}
} else {
return false;
}
}
}
class PictureFinder extends ExtensionFinder {
public function __construct($directory) {
parent::__construct($directory);
$this->extensions = array (
'jpg',
'gif',
'png'
);
}
}
How to use:
$iterator = new PictureFinder('img/');
foreach($iterator as $file) {
//do whatever you want with the picture here.
echo $file->getPathname()."\n";
}
Note that you could use the ExtensionFinder class I defined above to find files of ANY extension. That could potentially be more useful than simply finding images, but I defined a PictureFinder class for you for that specific use-case.

Answer 2

You wrote that you want to learn object oriented programming. What about the following:
class PicFinder
{
/**
* #return array
*/
public function inDirectory($directory)
{
return // array of files
}
}
class PicPresentation
{
public function present(array $pictures)
{
// your presentation code
}
}
$path = '/your/path';
$datasource = new PicFinder();
$presentation = new PicPresentation();
$pictures = $datasource->inDirectory($path);
$presentation->present($pictures);
Keep things separated and loosely coupled. One object should be responsible for one thing, e.g. one object to obtain the list of pictures from a directory and another one for the presentation. Good luck!

Answer 3

$Myclass->displayPics('./images/');
is calling the constructor and nothing is happening.
You have a typo in your function name aswell.

Answer 4

I'd suggest that design instead:
class PicFinder
{
public function findPics($dir){
...
}
}
class PicDisplayer
{
protected $picFinder;
public function __construct() {
// Default pic finder
$this->setPicFinder(new PicFinder());
}
public function diplayPics($dir) {
echo 'displayPics method called';
foreach($this->getPicFinder()->findPics($dir) as $key => $val) {
echo '<img src="' . $dir . $val . '" img><br/>';
}
}
protected function setPicFinder(PicFinder $picFinder) {
$this->picFinder = $picFinder;
}
protected function getPicFinder() {
return $this->picFinder;
}
}
That way you only use PicDisplayer and don't care how it finds the pics. But you can still change the "PicFinder" if needed, by extending the PicFinder class and implementing a specific behavior.