How to use a function of another class in the current class - php

Question

I have a class called adminItems within adminitems.class.php. I am trying to include one of the function of this class in xmlParser::someName() within xmlParser.class.php.
Like this:
require_once("adminitems.class.php");
$obj = new adminitems();
class xmlParser
{
function someName()
{
$obj->addAds(); // addAds is within adminItems object
}
}
`
Is this a correct way of doing it?

Answer 1

Don't use extends simply to gain extra functionality. This is a code smell and implies that xmlParser is-a adminItems which it is obviously not. Also, you can't then extend again in the future because PHP doesn't have multiple inheritance. Choose composition over inheritance like this example shows.
Use Dependency Injection. Invert the control of your objects so that they don't depend on each other: see Inversion on Control.
class xmlParser
{
/**
* #var adminItems
*/
protected $adminItems;
/**
* #constructor
*
* #param adminItems $adminItems
*/
public function __construct(adminItems $adminItems)
{
$this->adminItems = $adminItems;
}
/**
* Whatever this does...
*/
function someName()
{
$this->adminItems->addAds();
}
}
`
You need to, external to the classes you create, wire them together like so. You pass adminItems into the xmlParser, then use it how you need to. This is called Dependency Injection and is something you can do in all object oriented languages, not just php.
You would use the above object API like this:
$adminItems = new adminItems;
$xmlParser = new xmlParser($adminItems);
$xmlParser->somName();
Really simple. Your objects (think of them as re-usable libraries) should not depend on other objects except by constructor or method injection - so you can substitute them out leading to testable and inherently clean code.
Also, I urge you to take a look at the following useful links:
PSR-2 for naming conventions:
Use XmlParser instead of xmlParser for your class names
PSR-4 for autoloading:
Learn how to use composer to generate your autoload files for you
Learn how your files have a 1:1 mapping with directory structure
Learn how you only ever need to use an include once in your project

Answer 2

If a class B need a function of the class A, you have many solutions in PHP:
1. Inheritance
Extend the class A with the class B. The class B will be able to access the public and protected method of the class A.
class B extends A {
}
I wouldn't recommend this. It is a really bad practice in OOP to use inheritance just to use one function of a class that has not the same responsability.
2. Traits
Use traits (since PHP5.4.0):
trait factoredMethods {
function getX() { /*...*/ }
function setY() { /*...*/ }
}
class A {
use factoredMethods;
}
class B {
use factoredMethods;
}
This could be an interesting solution in certain cases but it is often a patch on a bad conception.
3. Composition
The best option is to use composition. B uses A:
class A {
}
class B {
private $a;
public function __construct(A $a) {
$this->a = $a;
}
}
$a = new A();
$b = new B($a);
Of course, the method you want to use in A must be public. I would highly suggest to use an interface between A and B in order to have a low coupling.

Answer 3

Almost the correct method - but $obj is not in scope. An ugly solution would be to delcare it in the global scope...
require_once("adminitems.class.php");
global $obj;
$obj = new adminitems();
class xmlParser
{
function someName()
{
global $obj;
$obj->addAds();
}
You can refine this approach using namespaces but the right answer is probably to pass a reference into scope, e.g.
function someName($obj)
{
$obj->addAds();
}

Answer 4

You can use other class function by extending the parent class
class xmlParser extends adminitems{
function someName(){
$obj->addAds();
}
}