Question

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

Answer 1

我找到了一种采用不同方法的解决方案..

<?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 ..

Answer 2

您可以使用以下内容：

<?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

Answer 3

这是一个长期存在和不存在的错误（请参阅@ deceze在该问题评论中的测试）。可以使用reflection“修复”此问题 - 也就是说，跨PHP版本提供一致的行为：

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

不幸的是，直接在3v4l.org上测试它是不可能的，因为代码太大，但这是minifying PHP代码的第一个真实用例 - 如果你这样做，它确实可以在3v4l上运行，所以随意玩，看看你是否可以打破它。我所知道的唯一问题是它目前无法理解parent。它也受到5.4之前关闭时缺乏$this支持的限制，但实际上并没有什么可以解决这个问题。

<?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;
    }
}

Answer 4

如果您只想从父级和后代访问，请使用“protected”修饰符。 IMO，很明显。例如：

<?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_called_class（）代替'static'。

Answer 5

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

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

Answer 6

使用get_called_called函数todo this

public function run() {
    $self = get_called_class();
    return $self::getName();
}

Answer 7

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

错误的静态方法

7 个答案: