15

PHP调用父类中的私有方法，而不是调用当前类中的方法定义call_user_func

class Car {
    public function run() {
        return call_user_func(array('Toyota','getName')); // should call toyota
    }
    private static function getName() {
        return 'Car';
    }
}

class Toyota extends Car {
    public static function getName() {
        return 'Toyota';
    }
}

$car = new Car();
echo $car->run(); //Car instead of Toyota

$toyota = new Toyota();
echo $toyota->run(); //Car instead of Toyota
4

7 回答 7

6

我找到了一个不同方法的解决方案..

<?php
 class Car {
    public static function run() {
     return static::getName();
   }
   private static function getName() {
    return 'Car';
    }
  }

   class Toyota extends Car {
     public static function getName() {
        return 'Toyota';
      }
   }
echo Car::run();
echo Toyota::run();
  ?>

使用Late Static Binding..

于 2012-12-21T12:09:14.183 回答
3

你可能会使用这样的东西：

<?php

class Car {
    public function run() {
        return static::getName();
    }

    private static function getName(){
        return 'Car';
    }
}

class Toyota extends Car {
    public static function getName(){
        return 'Toyota';
    }
}

$car = new Car();
echo $car->run();

echo PHP_EOL;

$toyota = new Toyota();
echo $toyota->run();

?>

输出：

Car
Toyota

PHP 5.4.5

于 2013-04-11T10:04:20.277 回答
1

如果您只想从父母和后代获得访问权限，请使用“受保护”修饰符。海事组织，很明显。例如：

<?php

class Car {
    public function run() {
        return call_user_func(array('static','getName'));
    }
    protected static function getName() {
        return 'Car';
    }
}

class Toyota extends Car {
    protected static function getName() {
        return 'Toyota';
    }
}

$car = new Car();
echo $car->run(); // "Car"

$toyota = new Toyota();
echo $toyota->run(); // "Toyota"

您可以使用 get_call_class() 而不是“静态”。

于 2013-04-15T04:29:07.290 回答
1

这是一个似乎在很长一段时间内一直存在和不存在的错误（请参阅@deceze 对问题的评论中的测试）。可以“修复”这个问题——也就是说，在 PHP 版本中提供一致的行为——使用反射：

由于依赖于ReflectionMethod::setAccessible()调用私有/受保护的方法，因此在 PHP 5.3.2 及更高版本中工作。我将很快添加对此代码的进一步解释，它可以做什么和不能做什么以及它是如何工作的。

不幸的是，由于代码太大，无法直接在 3v4l.org 上对此进行测试，但这是第一个真正用于缩小 PHP 代码的用例-如果您这样做，它确实可以在 3v4l 上工作，所以请随意玩耍和看看你能不能打破它。我知道的唯一问题是它目前不理解parent. 它还受到$this5.4 之前的闭包缺乏支持的限制，但实际上并没有什么可以做的。

<?php

function call_user_func_fixed()
{
    $args = func_get_args();
    $callable = array_shift($args);
    return call_user_func_array_fixed($callable, $args);
}

function call_user_func_array_fixed($callable, $args)
{
    $isStaticMethod = false;
    $expr = '/^([a-z_\x7f-\xff][\w\x7f-\xff]*)::([a-z_\x7f-\xff][\w\x7f-\xff]*)$/i';

    // Extract the callable normalized to an array if it looks like a method call
    if (is_string($callable) && preg_match($expr, $callable, $matches)) {
        $func = array($matches[1], $matches[2]);
    } else if (is_array($callable)
                   && count($callable) === 2
                   && isset($callable[0], $callable[1])
                   && (is_string($callable[0]) || is_object($callable[0]))
                   && is_string($callable[1])) {
        $func = $callable;
    }

    // If we're not interested in it use the regular mechanism
    if (!isset($func)) {
        return call_user_func_array($func, $args);
    }

    $backtrace = debug_backtrace(); // passing args here is fraught with complications for backwards compat :-(
    if ($backtrace[1]['function'] === 'call_user_func_fixed') {
        $called = 'call_user_func_fixed';
        $contextKey = 2;
    } else {
        $called = 'call_user_func_array_fixed';
        $contextKey = 1;
    }

    try {
        // Get a reference to the target static method if possible
        switch (true) {
            case $func[0] === 'self':
            case $func[0] === 'static':
                if (!isset($backtrace[$contextKey]['object'])) {
                    throw new Exception('Use of self:: in an invalid context');
                }

                $contextClass = new ReflectionClass($backtrace[$contextKey][$func[0] === 'self' ? 'class' : 'object']);
                $contextClassName = $contextClass->getName();

                $method = $contextClass->getMethod($func[1]);
                $ownerClassName = $method->getDeclaringClass()->getName();
                if (!$method->isStatic()) {
                    throw new Exception('Attempting to call instance method in a static context');
                }
                $invokeContext = null;

                if ($method->isPrivate()) {
                    if ($ownerClassName !== $contextClassName
                            || !method_exists($method, 'setAccessible')) {
                        throw new Exception('Attempting to call private method in an invalid context');
                    }

                    $method->setAccessible(true);
                } else if ($method->isProtected()) {
                    if (!method_exists($method, 'setAccessible')) {
                        throw new Exception('Attempting to call protected method in an invalid context');
                    }

                    while ($contextClass->getName() !== $ownerClassName) {
                        $contextClass = $contextClass->getParentClass();
                    }
                    if ($contextClass->getName() !== $ownerClassName) {
                        throw new Exception('Attempting to call protected method in an invalid context');
                    }

                    $method->setAccessible(true);
                }

                break;

            case is_object($func[0]):
                $contextClass = new ReflectionClass($func[0]);
                $contextClassName = $contextClass->getName();

                $method = $contextClass->getMethod($func[1]);
                $ownerClassName = $method->getDeclaringClass()->getName();

                if ($method->isStatic()) {
                    $invokeContext = null;

                    if ($method->isPrivate()) {
                        if ($ownerClassName !== $contextClassName || !method_exists($method, 'setAccessible')) {
                            throw new Exception('Attempting to call private method in an invalid context');
                        }

                        $method->setAccessible(true);
                    } else if ($method->isProtected()) {
                        if (!method_exists($method, 'setAccessible')) {
                            throw new Exception('Attempting to call protected method in an invalid context');
                        }

                        while ($contextClass->getName() !== $ownerClassName) {
                            $contextClass = $contextClass->getParentClass();
                        }
                        if ($contextClass->getName() !== $ownerClassName) {
                            throw new Exception('Attempting to call protected method in an invalid context');
                        }

                        $method->setAccessible(true);
                    }
                } else {
                    $invokeContext = $func[0];
                }

                break;

            default:
                $contextClass = new ReflectionClass($backtrace[$contextKey]['object']);
                $method = new ReflectionMethod($func[0], $func[1]);
                $ownerClassName = $method->getDeclaringClass()->getName();
                if (!$method->isStatic()) {
                    throw new Exception('Attempting to call instance method in a static context');
                }
                $invokeContext = null;

                if ($method->isPrivate()) {
                    if (empty($backtrace[$contextKey]['object'])
                            || $func[0] !== $contextClass->getName()
                            || !method_exists($method, 'setAccessible')) {
                        throw new Exception('Attempting to call private method in an invalid context');
                    }

                    $method->setAccessible(true);
                } else if ($method->isProtected()) {
                    $contextClass = new ReflectionClass($backtrace[$contextKey]['object']);

                    if (empty($backtrace[$contextKey]['object']) || !method_exists($method, 'setAccessible')) {
                        throw new Exception('Attempting to call protected method outside a class context');
                    }

                    while ($contextClass->getName() !== $ownerClassName) {
                        $contextClass = $contextClass->getParentClass();
                    }
                    if ($contextClass->getName() !== $ownerClassName) {
                        throw new Exception('Attempting to call protected method in an invalid context');
                    }

                    $method->setAccessible(true);
                }

                break;
        }

        // Invoke the method with the passed arguments and return the result
        return $method->invokeArgs($invokeContext, $args);
    } catch (Exception $e) {
        trigger_error($called . '() expects parameter 1 to be a valid callback: ' . $e->getMessage(), E_USER_ERROR);
        return null;
    }
}
于 2013-04-09T18:02:31.153 回答
0

我认为，问题在于两个 getname 函数的访问级别不同。如果您将 getname() 的基类版本公开（与派生类版本相同），那么在 php 5.3.15（在我的 Mac 上）中，您将获得 Toyota。我认为，由于访问级别不同，您最终会在 Toyota 类中得到两个不同版本的 getname() 函数，而不是派生类版本覆盖基类版本。换句话说，你有重载而不是覆盖。因此，当 run() 函数在 Toyota 类中查找要执行的 getname() 函数时，它会找到两个并获取第一个，这将是第一个被声明的（来自基类）。

当然，这只是我的假设，但听起来似乎有道理。

于 2012-12-21T11:36:44.217 回答
0

使用 get_called_call 函数来执行此操作

public function run() {
    $self = get_called_class();
    return $self::getName();
}
于 2013-04-13T15:50:41.803 回答
0

我相信您的功能会相互覆盖，默认情况下会使用第一个功能。除非您更改某个函数的参数，或重命名该函数，否则它将始终默认为父类函数。

于 2013-04-14T04:20:48.753 回答