Organizing/extending classes in a PHP project - php

Question

I'm working on a PHP project with a couple simple classes. I'm working on making my classes more complex, but I also wanted to start using classes for additional things like managing users, config settings, display, etc. I'm having a difficult time trying to figure out how to "organize" them. Like how should I extend these classes?
I have the following classes:
//main application settings, constants, etc.
Class Config {
}
//add/edit/delete/check permissions of users
Class Users extends Config {
}
//displays the pages
Class Display extends Config {
}
//main application
Class Analysis extends Config {
}
//specific methods for this type of analysis
Class Standard extends Analysis {
}
//specific methods for this type of analysis
Class Consolidated extends Analysis {
}
The issue I'm having is I want to be able to access the Users and Config classes from all the other classes (Display, Analysis, Standard, and Consolidated). How would I do this? Am I extending the classes properly? I feel like Display and Analysis should extend Users, but it doesn't seem right to me. I appreciate any help you can offer. Thanks!

Answer 1

In my projects my Users and Config classes are singleton classes which allows me to easily pull the instance into any other class with one simple method call.
Class User{
private static $_instance;
private function __construct(){
}
public function getInstance(){
if( !self::$_instance ){
self::$_instance = new User();
}
return self::$_instance;
}
}
Then wherever I need access to that user object
$user = User::getInstance();

Answer 2

You can try
trait Config {
}
// Common to Display
abstract class Display {
function __construct(Users $user);
}
// Common to analysis
abstract class Analysis {
function __construct(Users $user);
}
// add/edit/delete/check permissions of users
class Users {
use Config ;
}
// Mobile Display
class Mobile extends Display {
}
// Web Display
class Web extends Display {
}
// specific methods for this type of analysis
class Standard extends Analysis {
}
// specific methods for this type of analysis
class Consolidated extends Analysis {
}
// main application
class Main {
use Config ;
public function setDisplay(Display $display);
public function setAnalysis(Analysis $analysis);
}
$user = new Users("Jeff");
$main = new Main();
$main->setDisplay(new Mobile($user));
$main->setAnalysis(new Standard($user));

Answer 3

Keep them in separate files, and then use autoloading. Avoid the tendency to go OOP crazy. Remember that classes can be referenced as properties, not simply in an extension method.

Answer 4

As a general rule of thumb, you can use the "is-a" principle to organize your hierarchy of classes. For what you describe, it looks like:
Standard and Consolidated are (in the is-a sense) Analysis, so it looks like a good candidate for a hierarchy.
User and Display need to access the Config values, but they don't seem to be related in the conceptual way nor share common behavior, so it looks that composition is better suited than inheritance here.
Regarding the is-a principle you will generally recognize that it doesn't fit when the behavior that your subclass inherits doesn't belong to it. So, if for example your Config class has a saveValuesToDB() it definitely looks like something that the User shouldn't care about (i.e. how configuration values are stored in a DB). You can find a lot of information on the subject by searching for inheritance vs composition and is a recurrent subject in the pattern community. You can find a list of some good books about OO design and patterns here.
HTH