Accessing classes from other classes and in functions PHP - php

Question

I've not written OOP code before, I always tried to avoid the extra keystrokes. Anyway, I'm taking the plunge as it's supposed to increase readability.
Anyway, I'm having trouble getting my classes to be able to access each other's methods.
Here's my setup:
$conf = new Conf(); // boot up!
// Include dependencies, system files and other functions
require_once $conf->getIncludePath() . 'error.php';
require_once $conf->getIncludePath() . 'pool.php';
require_once $conf->getIncludePath() . 'database.php';
require_once $conf->getIncludePath() . 'api.php';
require_once $conf->getIncludePath() . 'user.php';
require_once $conf->getIncludePath() . 'forms.php';
require_once $conf->getIncludePath() . 'page.php';
require_once $conf->getIncludePath() . 'resources.php';
$error = new Error();
$pool = new Pool();
$db = new Database();
$api = new Api();
$user = new User();
$forms = new Forms();
$page = new Page();
$resources = new Resources();
My question is, how do I get it so that a method in User class can run the query method inside Database, to say fetch their information?
I'm aware of using global $db; global $user; etc. inside every method ever, but isn't there a way for me to get to these variables without having to essentially redeclare them every time I want to use them?
Thanks
Piers

Answer 1

Using objects is so much more than just readability.
Without going into a full blown explanation of the reasons behind this, I highly recommend further research into the topic. Starting with why they are used and the problems that they resolve (and cause!).
As for your question:
You have a large number of objects that should really be able to 'talk' to each other.
We could say that the User class is dependent on the Database. To resolve this dependency we need to be able to reference the Database in the context on the User (the correct scope).
There are a few ways to accomplish this, however the common practice would be to define a member variable inside the User class and the set the value of the property using setters and getters. This is known to be injecting the dependencies.
For example:
class User {
protected $database;
public function getDatabase()
{
return $this->database;
}
public function setDatabase(Database $database) {
$this->database = $database;
}
public function getUsers()
{
$sql = 'SELECT * FROM user';
return $this->getDatabase()->execute($sql);
}
}
Your client code would then become:
$db = new Database();
$user = new User();
$user->setDatabase($db);
Please note that the above example is a contrived one at best - Making the User class depending on the Database would be a design decision that will cause you other problems further down the line - Something I think you need to research into.

Answer 2

Use dependency injection!
You could create a new class, DBHandler, that stores an instance of your Database class into every other class you want.
For example:
class DBHandler {
public static $db;
public static function init($db) {
self::$db = $db;
}
}
$db = new Database();
DBHandler::init($db);
Then you just need to inherit from this class, by using the extends keyword.
i.e.:
class User extends DBHandler {
// ... your code here ...
}
This is an example of how you could implement the dependency injection.
The __autoload() function
You don't need to require a class everytime you need if you use the __autoload() function.
For example, you can do this to automatically resolve dependencies:
function __autoload($classname) {
require_once $classname . ".php";
}

Answer 3

Following the tutorial at nettuts+ lead me to write this:
// load configuration
require_once 'includes/class.conf.php';
$conf = new Conf(dirname(__FILE__));
// dependency class
$conf->registerRequiredFile('dependencies');
$dependencies = new Dependencies();
// start registering dependencies
$conf->registerRequiredFile('error');
$error = $dependencies->error = function(){ // error
$error = new Error();
$error->conf = $conf;
return $error;
};
$conf->registerRequiredFile('pool');
$pool = $dependencies->pool = function(){ // error
$pool = new Pool();
$pool->db = $db;
$pool->user = $user;
$pool->error = $error;
// etc. any other dependencies
return $pool;
};
It works perfectly, the first conf file contains the registerRequiredFile method that then require_once a uri based on the parameter given.
Thanks for your help in pointing me in the right direction!