<?php

    class A {

        const CONST_NAME = 'A';

        public static $static_name = 'A';

        public static $static_name_no_rewrite = 'A';

        private static $_instance;

        public static function static_func() {

            echo 'A';

        }

        public static function static_func_no_rewrite() {

            echo 'A';

        }

        public static function static_extends_self() {

            echo self::$static_name;

        }

        public static function static_extends_no_rewrite_self() {

            echo self::$static_name;

        }

        public static function static_extends_no_vars() {

            return self::$static_no_vars;

        }

        public static function get_instance() {

            if (empty(self::$_instance)) {

                self::$_instance = new self();

            }

            return self::$_instance;

        }

    }

    class B extends A {

        const CONST_NAME = 'B';

        public static $static_name = 'B';

        public static $static_no_vars = 'B';

        //重写

        public static function static_func() {

            echo 'B';

        }

        public static function static_extends_self() {

            echo self::$static_name;

        }

    }

    //是否继承后是有了一个父类的引用

    //1.查看父类和子类的初始情况

    $str = '1.查看父类和子类的初始情况';

    echo '<hr />';

    echo $str, '<br />';

    echo 'A::CONST_NAME->', A::CONST_NAME, '<br />';

    echo 'B::CONST_NAME->', B::CONST_NAME, '<br />';

    echo 'A::$static_name->', A::$static_name, '<br />';

    echo 'B::$static_name->', B::$static_name, '<br />';

    echo 'B::$static_name_no_rewrite->', B::$static_name_no_rewrite, '<br />';

    echo 'B::$static_name_no_rewrite->', B::$static_name_no_rewrite, '<br />';

    echo '结论：静态属性或类常量可以被继承<br />';

    echo '<hr />';

    //2.测试重定义的类属性 修改子类（父类）的值父类（子类）的值是否会改变

    $str = '2.测试重定义的类属性 修改子类（父类）的值父类（子类）的值是否会改变';

    echo $str, '<br />';

    A::$static_name = 'M_A';

    echo "修改->A::\$static_name = 'M_A'<br />";

    echo 'A::$static_name->', A::$static_name, '<br />';

    echo 'B::$static_name->', B::$static_name, '<br />';

    B::$static_name = 'M_B';

    echo "修改->B::\$static_name = 'M_B'<br />";

    echo 'A::$static_name->', A::$static_name, '<br />';

    echo 'B::$static_name->', B::$static_name, '<br />';

    echo '结论：继承关系的两个类，如果子类重定义了父类的静态属性，则修改父类（子类）的静态属性或常量不会影响到子类（父类）的对应静态属性<br />';

    echo '<hr />';

    //3.测试没有重定义的类属性 修改子类（父类）的值父类（子类）的值是否会改变

    $str = '3.测试没有重定义的类属性 修改子类（父类）的值父类（子类）的值是否会改变';

    echo $str, '<br />';

    echo 'A::$static_name_no_rewrite->', A::$static_name_no_rewrite, '<br />';

    echo 'B::$static_name_no_rewrite->', B::$static_name_no_rewrite, '<br />';

    A::$static_name_no_rewrite = 'M_A';

    echo "修改->A::\$static_name_no_rewrite = 'M_A'<br />";

    echo 'A::$static_name_no_rewrite->', A::$static_name_no_rewrite, '<br />';

    echo 'B::$static_name_no_rewrite->', B::$static_name_no_rewrite, '<br />';

    B::$static_name_no_rewrite = 'M_B';

    echo "修改->B::\$static_name_no_rewrite = 'M_B'<br />";

    echo 'A::$static_name_no_rewrite->', A::$static_name_no_rewrite, '<br />';

    echo 'B::$static_name_no_rewrite->', B::$static_name_no_rewrite, '<br />';

    echo '结论：如果子类没有重定义父类的某个静态属性，则修改父类（子类）则子类（父类）的对应静态属性也随之改变<br />';

    echo '更深结论：子类继承父类会有一个父类的引用指向父类那块内存，如果子类没有重定义一个属性（放到本类内存下）就会调用父类的属性<br />';

    echo '<hr />';

    //4.静态方法是否能继承

    $str = '4.静态方法是否能继承';

    echo $str, '<br />';

    echo 'A::static_func_no_rewrite()->', A::static_func_no_rewrite(), '<br />';

    echo 'B::static_func_no_rewrite()->', B::static_func_no_rewrite(), '<br />';

    echo '结论：静态方法可以继承！';

    echo '<hr />';

    //5.静态方法是否能被重写

    $str = '5.静态方法是否能被重写';

    echo $str, '<br />';

    echo 'A::static_func()->', A::static_func(), '<br />';

    echo 'B::static_func()->', B::static_func(), '<br />';

    echo '结论：静态方法可以被重写！';

    echo '<hr />';

    //6.父类静态方法中有self, 子类继承此方法没有重写后调用的self是谁？

    $str = '6.父类静态方法中有self, 子类继承此方法没有重写后调用的self是谁？';

    echo $str, '<br />';

    echo 'A::static_extends_no_rewrite_self()->', A::static_extends_no_rewrite_self(), '<br />';

    echo 'B::static_extends_no_rewrite_self()->', B::static_extends_no_rewrite_self(), '<br />';

    echo '结论：与3相同, 如若没有重写, 则只是子类对父类的一个引用, 如果子类中没有, 就去父类中寻找, 而且找到的也是依赖于父类！';

    echo '更深结论：在PHP单例的继承中, 父类::get_instance()方法中返回new self(), 如果子类没有重写, 则返回父类的实例！';

    echo '<hr />';

    //7.父类静态方法中有self, 子类继承此方法重写后调用的self是谁？

    $str = '7.父类静态方法中有self, 子类继承此方法重写后调用的self是谁？';

    echo $str, '<br />';

    echo 'A::static_extends_self()->', A::static_extends_self(), '<br />';

    echo 'B::static_extends_self()->', B::static_extends_self(), '<br />';

    echo '结论：子类覆盖父类的方法后, 如果其中有self属性, 则此时会覆盖父类的self, 即此时的self为对象本身';

    echo '<hr />';

    //8.父类静态方法调用本身没有子类却有的静态属性(来验证上述6推测, 如果是引用, 则会为空)

    $str = '8.子类调用父类静态方法调用父类没有子类却有的self的静态属性(来验证上述6推测, 如果是引用, 则会为空)';

    echo $str, '<br />';

    //echo 'B::static_extends_no_vars()->', B::static_extends_no_vars(), '<br />';

    echo 'B::static_extends_no_vars()->报错<br />';

    echo '结论：程序报错, 显示A没有此属性, 说明是子类对父类的一个引用！子类如果没有重写父类的属性或静态方法, 则调用父类的！包括self!';

    echo '<hr />';

    //9.测试下6中的推断, 即单例模式中self

    $str = '9.测试下6中的推断, 即单例模式中self';

    echo $str, '<br />';

    echo 'get_class(B::get_instance())->', get_class(B::get_instance()), '<br />';

    echo '结论：说明6中的更深推断是正确的！';

    echo '<hr />';

    //10.测试实例调用静态属性或常量

    $str = '测试实例调用静态属性或常量';

    echo $str, '<br />';

    $a = new A();

    //echo '$a = new A();echo $a->CONST_NAME->', $a->CONST_NAME, '<br />';

    echo '$a = new A();echo $a->CONST_NAME->报错<br />';

    //echo 'echo $a->$static_name->', $a->$static_name, '<br />';

    echo 'echo $a->$static_name->报错<br />';

    echo '结论：实例不能调用类的静态属性或常量！调用静态属性会转变为变量的变量, 调用常量会调用实例的对应属性！';

    echo '<hr />';

    //11.测试实例调用静态方法

    $str = '测试实例调用静态属性或常量';

    echo $str, '<br />';

    echo '$a->static_func()->', $a->static_func(), '<br />';

    echo '$a->static_extends_self()->', $a->static_extends_self(), '<br />';

    echo '结论：实例可以调用静态方法, 甚至静态方法中包含self！';

    echo '<hr />';