<?php

class grand_pa
{
    public function __construct()
    {
        echo "Hey I am Grand Pa <br>";
    }
}

class pa_pa extends grand_pa
{
    // no need for construct here unless you want to do something specifically within this class as init stuff
    // the construct for this class will be inherited from the parent.
}

class kiddo extends pa_pa
{
    public function __construct()
    {
        parent::__construct();
        echo "Hey I am a child <br>";
    }
}

new kiddo();
?>

当然，这期望您不需要在pa_pa的构造中做任何事情。运行该命令将输出:

嘿，我是爷爷 嘿，我是个孩子

我最终想出了一个解决问题的替代方案。

我创建了一个中间类，扩展了爷爷。 然后爸爸和孩子都延长了这个课程。 Kiddo需要Papa的一些中间功能，但不喜欢它的构造函数，所以类有额外的功能，并扩展了它。

我对另外两个答案大加赞赏，它们为一个更丑陋的问题提供了有效但丑陋的解决方案:)

    class Grandpa 
{
    public function __construct()
    {
        echo"Hello Kiddo";
    }    
}

class Papa extends Grandpa
{
    public function __construct()
    {            
    }
    public function CallGranddad()
    {
        parent::__construct();
    }
}

class Kiddo extends Papa
{
    public function __construct()
    {

    }
    public function needSomethingFromGrandDad
    {
       parent::CallGranddad();
    }
}

你必须使用外公::__construct()，没有其他的快捷方式。此外，这也破坏了Papa类的封装——当读取或处理Papa时，应该可以安全地假设__construct()方法将在构造过程中被调用，但Kiddo类不会这样做。

我同意“太多php”，试试这个:

class Grandpa 
{
    public function __construct()
    {
        echo 'Grandpa<br/>';
    }

}

class Papa extends Grandpa
{
    public function __construct()
    {
        echo 'Papa<br/>';
        parent::__construct();
    }
}

class Kiddo extends Papa
{
    public function __construct()
    {
        // THIS IS WHERE I NEED TO CALL GRANDPA'S
        // CONSTRUCTOR AND NOT PAPA'S
        echo 'Kiddo<br/>';
        Grandpa::__construct();
    }
}

$instance = new Kiddo;

我得到了预期的结果:

老姐 爷爷

这是一个功能而不是一个bug，检查一下以供参考:

https://bugs.php.net/bug.php?id=42016

这就是它的运作方式。如果它看到它来自正确的上下文，这个调用版本不会强制执行静态调用。 相反，它会简单地保留$this，并对它感到满意。

Parent::method()以同样的方式工作，你不必将方法定义为静态的，但它可以在相同的上下文中被调用。试试这个更有趣的:

class Grandpa 
{
    public function __construct()
    {
        echo 'Grandpa<br/>';
        Kiddo::hello();
    }

}

class Papa extends Grandpa
{
    public function __construct()
    {
        echo 'Papa<br/>';
        parent::__construct();
    }
}

class Kiddo extends Papa
{
    public function __construct()
    {
        // THIS IS WHERE I NEED TO CALL GRANDPA'S
        // CONSTRUCTOR AND NOT PAPA'S
        echo 'Kiddo<br/>';
        Grandpa::__construct();
    }

    public function hello()
    {
        echo 'Hello<br/>';
    }
}

$instance = new Kiddo;

它也像预期的那样工作:

老姐 爷爷 你好

但是如果你尝试初始化一个新的Papa，你会得到一个E_STRICT错误:

$papa = new Papa;

严格的标准:非静态方法Kiddo::hello()不应该被静态调用，假设$this来自不兼容的上下文

你可以使用instanceof来确定你是否可以在父方法中调用Children::method():

if ($this instanceof Kiddo) Kiddo::hello();

使用反射的美丽解决方案。

<?php
class Grandpa 
{
    public function __construct()
    {
        echo "Grandpa's constructor called\n";
    }

}

class Papa extends Grandpa
{
    public function __construct()
    {
        echo "Papa's constructor called\n";

        // call Grandpa's constructor
        parent::__construct();
    }
}

class Kiddo extends Papa
{
    public function __construct()
    {
        echo "Kiddo's constructor called\n";

        $reflectionMethod = new ReflectionMethod(get_parent_class(get_parent_class($this)), '__construct');
        $reflectionMethod->invoke($this);
    }
}

$kiddo = new Kiddo();
$papa = new Papa();