在php中调用其他类的对象？

One Solution

Unlike JavaScript PHP will not bubble up through scopes, which means

    public function __construct(){
        $this->lastactivity = $objUtils->getCurrentDateTimeForMySQL();
    }

does not know what $objUtils is, because there is no such object defined in the local scope. This means, you have to make the object available inside that scope. The cleanest and most maintainable way to do that is to inject the utils instance to the member instance, e.g.

    public function __construct($utils){
        $this->lastactivity = $utils->getCurrentDateTimeForMySQL();
    }

However, since you seem to be using that value on construction only anyway, there is no reason why your member instance has to know how to use the utils object. So why not just insert the actual value right from the start, e.g.

    public function __construct($lastActivity){
        $this->lastactivity = $lastActivity;
    }

    // then do
    $utils  = new utils();
    $member = new member($utils->getCurrentDateTimeForMySQL());

On globals

You definitely do not want to use the global keyword or static methods. Both couple back to the global scope. This means you can no longer use the member class without the global scope. This makes maintaining, reusing, refactoring and testing harder. OOP is about encapsulation and by reaching out from the class to the global scope you are breaking that encapsulation. Use Dependency Injection as shown above instead.

Apart from that, using globals will also make your code harder to read. A developer looking at the ctor signature of member is likely to assume there is nothing else to do than just call new member. That's a lie, because she also has to setup the utils instance. In other words, you are hiding dependencies. The developer has to look at the actual code to understand what's going on. Thus, make dependencies explicit.

Some more resources:

• http://c2.com/cgi/wiki?GlobalVariablesAreBad
• http://misko.hevery.com/code-reviewers-guide/flaw-brittle-global-state-singletons/

EDITs after comments

If you really need that utils object, inject the instance and assign it to a property inside the member instance in the ctor. Then you can access it with $this->utils->foo() from anywhere else inside the member instance.

However, Utility classes are almost always a sign of bad design. It is much more likely that they should be broken apart and divided into/onto other objects. Try to find out the reponsibilities. Maybe Member should not use Utils, but Utils should be something else that uses Members.

Out of curiosity, why do you need a utility method for MySql anyway? If you use a Timestamp column in MySql for lastActivity, it will automatically update whenever the row is updated. I am assuming you are setting the lastActivity and then store the member data?

Regarding performance: you should not bother about performance. Write readable and maintainable code first and foremost. If you think your performance is not good enough, profile the application with XDebug to see what is really making an impact.

It sounds like config.php is in the global scope. You need to use the global keyword when using $objUtils

    function __construct(){
        global $objUtils;
        $this->lastactivity = $objUtils->getCurrentDateTimeForMySQL();
    }

Since your getCurrentDateForMySQL doesn't depend on anything else inside your utils object, why not make it a static function? That way you can turn your member() method into:

function __construct(){
    $this->lastactivity = utils::getCurrentDateTimeForMySQL();
}

As another comment states, use dependency injection. Insert the utilities object into the constructor. Do not introduce variables over the global scope, especially between different files. This gets very confusing and creates a mandatory order of some file includes.

class member {
   ...
   public function __construct(utils $objUtils) {
      $this->objUtils = $objUtils;
      ...
   }
}

In calling code:

$member = new member(new utils);

As an aside, I find it humorous that you have a macro with a name that is longer than the operation it performs.

As another aside, do you need a utilities class? Can the utilities just be functions?