Question: I am planning to use PHP's autoload function to dynamicly load only class files that are needed. Now this could create a huge mess if every single function has a seperate file, So I am hoping and asking is there a way to have related classes remain in 1 class file and still be auto-loaded

```
function __autoload($class_name){
    include('classes/' . $class_name . '.class.php');
}

```

Let's say there is a class name animals and then another class named dogs. Dogs class extends animals class, now if I were to call the dogs class but NOT call the animals class, would the animals class file still be loaded?

Answer: 
Have you considered explicit definitions of your class locations? Sometimes it makes a lot of sense to group related classes.

Here is a proven way of handling it.

This code is placed in an `auto_prepend_file` (or included first)

```
class Import
{
    public static $_AutoLoad = array();
    public static $_Imported = array();

    public static function Load($sName)
    {
        if(! isset(self::$_AutoLoad[$sName]))
            throw new ImportError("Cannot import module with name '$sName'.");

        if(! isset(self::$_Imported[$sName]))
        {
            self::$_Imported[$sName] = True;
            require(self::$_AutoLoad[$sName]);
        }
    }

    public static function Push($sName, $sPath)
    {
        self::$_AutoLoad[$sName] = $sPath;
    }

    public static function Auto()
    {
        function __autoload($sClass)
        {
            Import::Load($sClass);
        }
    }
}

```

And in your bootstrap file, define your classes, and what file they are in. 

```
//Define autoload items
Import::Push('Admin_Layout',        App::$Path . '/PHP/Admin_Layout.php');
Import::Push('Admin_Layout_Dialog', App::$Path . '/PHP/Admin_Layout.php');
Import::Push('FileClient',          App::$Path . '/PHP/FileClient.php');

```

And lastly, enable AutoLoad by calling 

```
Import::Auto()

```

---

One of the nice things is that you can define "Modules":

```
Import::Push('MyModule',          App::$Path . '/Module/MyModule/Init.php');

```

And then load them explicitly when needed:

```
Import::Load('MyModule');

```

And one of the best parts is you can have additional `Import::Push` lines in the module, which will define all of its classes at runtime.
There's a workaround, I've just used it and it seems to work:

Let's assume we have an autoloaded class called animals stored in animals.class.php. In the same file you could have other classes that extends animals 

```
    class animals{
        static function load(){
            return true;
        }
    }

    class dogs extends animals{

    }

    class cats extends animals{

    }

```

Now... when you need to use your class `dogs` you need PHP autoload it's parent class (and doing this you're sure it will parse also all the extendend classes inside the same file) so you just have to write:

```
animals::load();
$fuffy = new dogs();

```