面向对象——public、protect、private和extends（继承）、重写

要点：

　　public、protect、private和extends（继承）、重写
　　# 外部调用类内部变量， 只能调用public的变量
　　# 外部调用类内部函数， 只能调用默认或者public的函数
　　# 类函数调用内部变量没有限制
　　# 类函数调用内部函数没有限制
　　# 通过子类调用父类函数， private会报错， public,protected正常
　　# 子类调用父类变量， private会报错， public,protected正常
　　# 子类重写父类函数，没限制
　　# 子类重写父类函数后，调用重写前的用:parent::XXX();调用重写后的用:self::XXX()或者$this->XXX;
　　# 继承父类的普通变量，相当于拷贝一份变量给子类。 因此重写不影响父类，也无法访问父类原本的普通变量。
　　 　　继承父类的静态变量，子类和父类用同一份变量，若子类修改静态变量的值（在子类的函数内修改），父类会受影响。
　　　　若子类重写父类的静态变量（在子类的函数外，类内修改），相当于父类拷贝一份静态变量给子类，此时子类修改静态变量的值（在子类的函数内修改），父类不受影响。
　　# 子类重写父类静态方法，修改子类静态变量，父类不受影响；
　　# 重写的访问控制权不能缩小 访问控制权从大到小排序 public>protected>private
　　# 非静态成员不能修改为静态成员
　　# 静态成员不能修改为非静态成员

代码：

index.php

<?php

/**
 * public、protect、private和extends（继承）、重写
 * # 外部调用类内部变量， 只能调用public的变量
 * # 外部调用类内部函数， 只能调用默认或者public的函数
 * # 类函数调用内部变量没有限制
 * # 类函数调用内部函数没有限制
 * # 通过子类调用父类函数， private会报错， public,protected正常
 * # 子类调用父类变量， private会报错， public,protected正常
 * # 子类重写父类函数，没限制
 * # 子类重写父类函数后，调用重写前的用:parent::XXX();调用重写后的用:self::XXX()或者$this->XXX;
 * # 继承父类的普通变量，相当于拷贝一份变量给子类。 因此重写不影响父类，也无法访问父类原本的普通变量。
 *      继承父类的静态变量，子类和父类用同一份变量，若子类修改静态变量的值（在子类的函数内修改），父类会受影响。
 *      若子类重写父类的静态变量（在子类的函数外，类内修改），相当于父类拷贝一份静态变量给子类，此时子类修改静态变量的值（在子类的函数内修改），父类不受影响。
 * # 子类重写父类静态方法，修改子类静态变量，父类不受影响；
 * # 重写的访问控制权不能缩小 访问控制权从大到小排序 public>protected>private
 * # 非静态成员不能修改为静态成员
 * # 静态成员不能修改为非静态成员
 */

include 'car.php';
$car = new car();
$bus = new bus();

/*获取变量 外部调用类内部变量， 只能调用public的变量*/
// public 可以
echo $car->public_color;
// protected 不能，会报错
echo $cat->protected_color;
// private 不能，会报错
echo $cat->private_color;

/*调用函数 外部调用类内部函数， 只能调用默认或者public的函数*/
// 默认可以调用
$car->car1();

// public函数可以调用
$car->car2();

// protected函数不能调用，会报错
$car->car3();

// private函数不能调用，会报错
$car->car4();

// 调用内部函数, 没有限制
$car->car5();

// 通过子类调用父类函数
$bus->bus1();

// 子类调用父类变量
$bus->bus2();

// 子类重写父类静态方法，修改子类静态变量，父类不受影响；
$bus->bus4();
\bus::$public_static_color='blue';
$bus->bus4();

car.php

<?php

class car
{

    public $public_color = 'public';
    protected $protected_color = 'protected';
    private $private_color = 'private';

    public static $public_static_color = 'public_static';
    protected static $protected_static_color = 'protected_static';
    private static $private_static_color = 'private_static';

    // 默认使用public
    function car1()
    {
        echo '使用默认函数访问<br />';
        echo $this->public_color.'<br />';
        echo $this->protected_color.'<br />';
        echo $this->private_color.'<br />';
    }

    // public函数
    public function car2()
    {
        echo 'public函数';
    }

    // protected函数
    protected function car3()
    {
        echo 'protected函数';
    }

    // private函数
    private function car4()
    {
        echo 'private函数';
    }

    // 调用内部函数, 没有限制
    function car5() {
        $this->car1();
        $this->car2();
        $this->car3();
        $this->car4();
    }

    static function car6() {
        echo '这是父类<br />';
        static $id = 0;
        echo '父类ID:'.++$id.'<br />';
        echo self::$public_static_color.'<br/><br/>';
    }
}

class bus extends car
{
    // 子类重写父类的普通变量
    public $public_color = 'child_public';
    protected $protected_color = 'child_protected';
    private $private_color = 'child_private';

    // 非静态成员不能修改为静态成员
    // public static $public_color = 'child_public';

    // 静态成员不能修改为非静态成员
    // public $public_static_color = 'child_public_static';

    // 子类重写父类静态变量
    public static $public_static_color = 'child_public_static';
    protected static $protected_static_color = 'child_protected_static';
    private static $private_static_color = 'child_private_static';

    // 子类调用父类函数
    function bus1()
    {
        // 调用父类默认函数
        parent::car1();
        // 调用父类public函数
        parent::car2();
        // 调用父类protected函数
        parent::car3();
        // 调用父类private函数， 会报错
        //parent::car4();
    }

    // 子类调用父类变量和子类重写后的变量
    function bus2() {
        /*普通变量*/
        // 调用public变量
        //echo $this->public_color.'<br/>';
        // 调用protected变量
        //echo $this->protected_color.'<br/>';
        // 调用private变量，会报错
        //echo $this->private_color.'<br/>';
        /*重写后的静态变量*/
        // 调用public静态变量
        echo self::$public_static_color.'<br/>';
        // 调用protected静态变量
        echo self::$protected_static_color.'<br/>';
        // 调用private静态变量  报错
        //echo self::$private_static_color.'<br/>';

        /*父类的静态变量*/
        // 调用public静态变量
        echo parent::$public_static_color.'<br />';
        // 调用protected静态变量
        echo parent::$protected_static_color.'<br />';
        // 调用private静态变量  报错
        //echo parent::$private_static_color.'<br />';
    }

    // 重写的访问控制权不能缩小 访问控制权从大到小排序 public>protected>private
    // 如下会报错 因为父类car2是public,protected比public小
    /*protected function car2() {
    }*/

    // 重写父类默认函数
    /*function car1(){
        echo '子类重写父类默认函数';
    }*/
    // 重写父类public函数        echo '子类重写父类public函数';
    function car2(){
    }
    // 重写父类protected函数
    function car3(){
        echo '子类重写父类protected函数';
    }
    // 重写父类private函数
    function car4(){
        echo '子类重写父类private函数';
    }

    // 调用重写后的父类函数
    function bus3() {
        // 调用重写前的用:parent::XXX();
        // 调用重写后的用:self::XXX()或者$this->XXX;

        echo '调用重后用：$this->car1()：<br/>';
        $this->car1();
        echo '<br/>调用父类：parent::car1()：<br/>';
        parent::car1();
    }

    // 重写父类静态函数
    static function car6() {
        echo '这是子类<br/>';
        static $id = 0;
        echo '子类ID:'.++$id.'<br />';
        echo '父类静态变量：'.parent::$public_static_color."<br />";
        echo '子类静态变量：'.self::$public_static_color.'<br/><br/>';
    }

    // 子类重写父类静态方法，修改子类静态变量，父类不受影响；
    function bus4() {
        $this->car6();
        parent::car6();
    }

}