文件本质与作用域，实例演示

1.PHP中文件包含的实例

    <?php
    // 文件包含
    // 本质: 将目录文件复制到当前位置
    // 1. include
    // echo __DIR__ ;
    include __DIR__ .'/inc/f1.php';
    // $username = '张老师';
    // 被包含文件共享作用域
    echo $username . '<br>';
    // echo $email . '<br>';
    $email = include __DIR__ . '/inc/f1.php';
    echo $email . '<hr>';
    // 2. require
    require __DIR__ . '/inc/f1.php';
    echo $username . '<br>';
    $email = require __DIR__ . '/inc/f1.php';
    echo $email . '<br>';
    // 3. include,require区别 
    // 区别1
    // include: 用到时再加载, 动态
    // require: 应该写到顶部, 静态
    // if (false) include __DIR__ . '/inc/f2.php';
    // echo $site . '<br>';
    // if (false) require __DIR__ . '/inc/f2.php';
    // echo $site . '<br>';
    //  区别2
    // include: 加载失败,继续执行不中断
    // requrie: 加载失败,中断退出
    // include __DIR__ . '/inc/hello.php';
    @include __DIR__ . '/inc/hello.php';
    echo 'include后面的代码' . '<br>';
    // require __DIR__ . '/inc/hello.php';
    // echo 'require后面的代码' . '<br>';
    // include_once: 只包含一次
    // require_once: 只包含一次

2.PHP中关键字

    <?php
    /**
     * 类的扩展/抽象/最终
     * 1. protected: 受保护/可继承
     * 2. extends: 扩展/继承
     * 3. parent: 父类引用
     * 4. abstract: 抽象
     * 5. final: 最终类
     */
     // 父类，基类，超类
     class Person
     {
        // proteced:成员可继承，可以在子类中使用 
        protected $name;
        // private: 私有，仅限当前类，子类，外部都不可见
        private $id = 12345;
        // public: 类中，子类，类外都可见
        public function __construct($name){
            $this->name = $name;
        }
        // getInfo::proteced
        // 比protected再严格的是 private,比它更宽松的是：public
        protected function getInfo(){
            return $this->name;
        }
     }
     // 学生类
     // extends:Stu这个类，扩展了Person类的功能
     class Stu extends Person
     {
         // 1. 属性扩展
         private $lesson;
         private $score;
         // 2. 方法扩展、重写
         public function __construct($name,$lesson,$score)
         {
             // 引用了父类的构造方法
             // parent: 父类引用 Person
             parent::__construct($name);
             $this->lesson = $lesson;
             $this->score = $score;
         }
         public function getInfo()
         {
             // $this->name
             // return $this->name . "同学，($this->lesson : $this->score 分)";
             return parent::getInfo() . "同学，($this->lesson : $this->score 分)";
         }
     }
     $stu = new Stu('小王','php',88);
     echo $stu->getInfo();
     echo '<hr>';
     // 如果不想让用户直接使用父类，而必须通过继承/扩展的子类来间接使用
     // 将父类声明为一个抽象类
     abstract class Demo1{
     }
     // (new Demo1)
     class Demo2 extends Demo1{
     }
     echo 'Demo2的父类是：'.get_parent_class(new Demo2);
     echo '<hr>';
     abstract class Demo3{
         // 抽象方法：只有方法名，参数列表，没有具体实现（大括号）
         abstract protected function hello($name);
     }
     class Demo4 extends Demo3{
         // 工作类Demo4中必须实现父类中的抽象成员
         public function hello($name){
             return 'hello,'.$name;
         }
     }
     echo call_user_func([new Demo4,'hello'],'张老师');
     echo '<hr>';
     // interface接口实例
    interface A{}
    interface B{}
    interface C{}
    class Test implements A,B,C{
    }
    // 查看当前类实现的所有接口
    $arr = class_implements('Test');
    printf('<pre>%s</pre>',print_r($arr,true));
     // 如果一个类不用扩展,直接当成工作类/直接干活的,直接new
    // 为了防止被继承, 可声明为最终类
    // final class Demo5
    // {
    // }
    // class Demo6 extends Demo5
    // {
    // }